static void
testGetType(
PKIX_PL_Object *obj,
PKIX_PL_Object *obj2,
PKIX_PL_Object *obj3)
{
PKIX_UInt32 testType;
PKIX_TEST_STD_VARS();
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_GetType(obj, &testType, plContext));
if (testType != 1000)
testError("Object 1 returned the wrong type");
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_GetType(obj2, &testType, plContext));
if (testType != 2000)
testError("Object 2 returned the wrong type");
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_GetType(obj3, &testType, plContext));
if (testType != 1000)
testError("Object 3 returned the wrong type");
cleanup:
PKIX_TEST_RETURN();
}
/*
* FUNCTION: pkix_pl_CRL_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_CRL_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_PL_CRL *firstCrl = NULL;
PKIX_PL_CRL *secondCrl = NULL;
PKIX_UInt32 secondType;
PKIX_ENTER(CRL, "pkix_pl_CRL_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
/* test that firstObject is a CRL */
PKIX_CHECK(pkix_CheckType(firstObject, PKIX_CRL_TYPE, plContext),
PKIX_FIRSTOBJECTNOTCRL);
firstCrl = (PKIX_PL_CRL *)firstObject;
secondCrl = (PKIX_PL_CRL *)secondObject;
/*
* Since we know firstObject is a CRL, if both references are
* identical, they must be equal
*/
if (firstCrl == secondCrl) {
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondCrl isn't a CRL, we don't throw an error.
* We simply return a Boolean result of FALSE
*/
*pResult = PKIX_FALSE;
PKIX_CHECK(PKIX_PL_Object_GetType
((PKIX_PL_Object *)secondCrl, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_CRL_TYPE) goto cleanup;
/* Compare DER Bytes */
PKIX_NULLCHECK_TWO
(firstCrl->nssSignedCrl,
firstCrl->nssSignedCrl->derCrl);
PKIX_NULLCHECK_TWO
(secondCrl->nssSignedCrl,
secondCrl->nssSignedCrl->derCrl);
PKIX_CRL_DEBUG("\t\tCalling SECITEM_CompareItem on derCrl\n");
if (SECITEM_CompareItem(firstCrl->nssSignedCrl->derCrl,
secondCrl->nssSignedCrl->derCrl) == SECEqual) {
*pResult = PKIX_TRUE;
}
cleanup:
PKIX_RETURN(CRL);
}
/*
* FUNCTION: pkix_pl_Date_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_Date_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
/* note: pkix_pl_Date can only represent UTCTime,not GeneralizedTime */
SECItem *firstTime = NULL;
SECItem *secondTime = NULL;
PKIX_UInt32 secondType;
SECComparison cmpResult;
PKIX_ENTER(DATE, "pkix_pl_Date_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
/* test that firstObject is a Date */
PKIX_CHECK(pkix_CheckType(firstObject, PKIX_DATE_TYPE, plContext),
PKIX_FIRSTOBJECTNOTDATE);
/*
* Since we know firstObject is a Date, if both references are
* identical, they must be equal
*/
if (firstObject == secondObject){
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondObject isn't a Date, we don't throw an error.
* We simply return a Boolean result of FALSE
*/
*pResult = PKIX_FALSE;
PKIX_CHECK(PKIX_PL_Object_GetType
(secondObject, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_DATE_TYPE) goto cleanup;
firstTime = &((PKIX_PL_Date *)firstObject)->nssTime;
secondTime = &((PKIX_PL_Date *)secondObject)->nssTime;
PKIX_DATE_DEBUG("\t\tCalling SECITEM_CompareItem).\n");
cmpResult = SECITEM_CompareItem(firstTime, secondTime);
*pResult = (cmpResult == SECEqual);
cleanup:
PKIX_RETURN(DATE);
}
static PKIX_Error *
equalsCallback(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *result,
void *plContext)
{
PKIX_UInt32 firstType = 0, secondType = 0;
if ((first == plContext) || (second == plContext))
testError("Null Object");
(void)PKIX_PL_Object_GetType(first, &firstType, plContext);
(void)PKIX_PL_Object_GetType(second, &secondType, plContext);
*result = (firstType == secondType) ? PKIX_TRUE : PKIX_FALSE;
return (NULL);
}
/*
* FUNCTION: pkix_ValidateParams_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ValidateParams_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_ValidateParams *firstValParams = NULL;
PKIX_ValidateParams *secondValParams = NULL;
PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
PKIX_CHECK(pkix_CheckType(first, PKIX_VALIDATEPARAMS_TYPE, plContext),
PKIX_FIRSTOBJECTNOTVALIDATEPARAMS);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
*pResult = PKIX_FALSE;
if (secondType != PKIX_VALIDATEPARAMS_TYPE) goto cleanup;
firstValParams = (PKIX_ValidateParams *)first;
secondValParams = (PKIX_ValidateParams *)second;
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstValParams->procParams,
(PKIX_PL_Object *)secondValParams->procParams,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstValParams->chain,
(PKIX_PL_Object *)secondValParams->chain,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
*pResult = cmpResult;
cleanup:
PKIX_RETURN(VALIDATEPARAMS);
}
/*
* FUNCTION: pkix_ResourceLimits_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ResourceLimits_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_ResourceLimits *firstRLimits = NULL;
PKIX_ResourceLimits *secondRLimits = NULL;
PKIX_ENTER(RESOURCELIMITS, "pkix_ResourceLimits_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
PKIX_CHECK(pkix_CheckType(first, PKIX_RESOURCELIMITS_TYPE, plContext),
PKIX_FIRSTOBJECTNOTRESOURCELIMITS);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
*pResult = PKIX_FALSE;
if (secondType != PKIX_RESOURCELIMITS_TYPE) goto cleanup;
firstRLimits = (PKIX_ResourceLimits *)first;
secondRLimits = (PKIX_ResourceLimits *)second;
cmpResult = (firstRLimits->maxTime == secondRLimits->maxTime) &&
(firstRLimits->maxFanout == secondRLimits->maxFanout) &&
(firstRLimits->maxDepth == secondRLimits->maxDepth) &&
(firstRLimits->maxCertsNumber ==
secondRLimits->maxCertsNumber) &&
(firstRLimits->maxCrlsNumber ==
secondRLimits->maxCrlsNumber);
*pResult = cmpResult;
cleanup:
PKIX_RETURN(RESOURCELIMITS);
}
static PKIX_Error *
toStringCallback(
PKIX_PL_Object *obj,
PKIX_PL_String **pString,
/* ARGSUSED */ void *plContext)
{
PKIX_Error *errorResult;
PKIX_UInt32 type;
char *format = "(addr: %x, type: %d)";
PKIX_PL_String *formatString = NULL;
errorResult = PKIX_PL_String_Create(
PKIX_ESCASCII,
format,
PL_strlen(format),
&formatString,
plContext);
if (errorResult)
testError("PKIX_PL_String_Create failed");
if (pString == plContext)
testError("Null String");
type = (unsigned int)0;
(void)PKIX_PL_Object_GetType(obj, &type, plContext);
errorResult = PKIX_PL_Sprintf(pString, plContext,
formatString,
(int)obj, type);
if (errorResult)
testError("PKIX_PL_Sprintf failed");
errorResult = PKIX_PL_Object_DecRef((PKIX_PL_Object *)formatString,
plContext);
if (errorResult)
testError("PKIX_PL_Object_DecRef failed");
return (NULL);
}
/*
* FUNCTION: pkix_pl_OID_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_OID_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
SECComparison cmpResult;
PKIX_ENTER(OID, "pkix_pl_OID_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
PKIX_CHECK(pkix_CheckType(first, PKIX_OID_TYPE, plContext),
PKIX_FIRSTARGUMENTNOTANOID);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
*pResult = PKIX_FALSE;
/*
* Do a quick check that the second object is an OID.
* If so, check that their lengths are equal.
*/
if (secondType != PKIX_OID_TYPE) {
goto cleanup;
}
PKIX_CHECK(pkix_pl_OID_Comparator
(first, second, &cmpResult, plContext),
PKIX_OIDCOMPARATORFAILED);
*pResult = (cmpResult == SECEqual);
cleanup:
PKIX_RETURN(OID);
}
/*
* FUNCTION: pkix_pl_ByteArray_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_ByteArray_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Int32 cmpResult = 0;
PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
/* Sanity check: Test that "first" is a ByteArray */
PKIX_CHECK(pkix_CheckType(first, PKIX_BYTEARRAY_TYPE, plContext),
PKIX_FIRSTARGUMENTNOTBYTEARRAY);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
/* If types differ, then we will return false */
*pResult = PKIX_FALSE;
/* Second type may not be a BA */
if (secondType != PKIX_BYTEARRAY_TYPE) goto cleanup;
/* It's safe to cast here */
PKIX_CHECK(pkix_pl_ByteArray_Comparator
(first, second, &cmpResult, plContext),
PKIX_BYTEARRAYCOMPARATORFAILED);
/* ByteArrays are equal iff Comparator Result is 0 */
*pResult = (cmpResult == 0);
cleanup:
PKIX_RETURN(BYTEARRAY);
}
/*
* 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_List_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_List_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_List *firstList = NULL;
PKIX_List *secondList = NULL;
PKIX_UInt32 firstLength = 0;
PKIX_UInt32 secondLength = 0;
PKIX_PL_Object *firstItem = NULL;
PKIX_PL_Object *secondItem = NULL;
PKIX_UInt32 i = 0;
PKIX_ENTER(LIST, "pkix_List_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
/* test that first is a List */
PKIX_CHECK(pkix_CheckType(first, PKIX_LIST_TYPE, plContext),
PKIX_FIRSTOBJECTNOTLIST);
/*
* Since we know first is a List, if both references are
* identical, they must be equal
*/
if (first == second){
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If second isn't a List, 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_LIST_TYPE) goto cleanup;
firstList = (PKIX_List *)first;
secondList = (PKIX_List *)second;
if ((!firstList->isHeader) && (!secondList->isHeader)){
PKIX_ERROR(PKIX_INPUTLISTSMUSTBELISTHEADERS);
}
firstLength = firstList->length;
secondLength = secondList->length;
cmpResult = PKIX_FALSE;
if (firstLength == secondLength){
for (i = 0, cmpResult = PKIX_TRUE;
((i < firstLength) && cmpResult);
i++){
PKIX_CHECK(PKIX_List_GetItem
(firstList, i, &firstItem, plContext),
PKIX_LISTGETITEMFAILED);
PKIX_CHECK(PKIX_List_GetItem
(secondList, i, &secondItem, plContext),
PKIX_LISTGETITEMFAILED);
if ((!firstItem && secondItem) ||
(firstItem && !secondItem)){
cmpResult = PKIX_FALSE;
} else if (!firstItem && !secondItem){
continue;
} else {
PKIX_CHECK(PKIX_PL_Object_Equals
(firstItem,
secondItem,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
PKIX_DECREF(firstItem);
PKIX_DECREF(secondItem);
}
}
}
*pResult = cmpResult;
cleanup:
PKIX_DECREF(firstItem);
PKIX_DECREF(secondItem);
PKIX_RETURN(LIST);
}
/*
* FUNCTION: pkix_pl_CertPolicyQualifier_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_CertPolicyQualifier_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_PL_CertPolicyQualifier *firstCPQ = NULL;
PKIX_PL_CertPolicyQualifier *secondCPQ = NULL;
PKIX_UInt32 secondType = 0;
PKIX_Boolean compare = PKIX_FALSE;
PKIX_ENTER(CERTPOLICYQUALIFIER, "pkix_pl_CertPolicyQualifier_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
/* test that firstObject is a CertPolicyQualifier */
PKIX_CHECK(pkix_CheckType
(firstObject, PKIX_CERTPOLICYQUALIFIER_TYPE, plContext),
PKIX_FIRSTOBJECTNOTCERTPOLICYQUALIFIER);
/*
* Since we know firstObject is a CertPolicyQualifier,
* if both references are identical, they must be equal
*/
if (firstObject == secondObject){
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondObject isn't a CertPolicyQualifier, we
* don't throw an error. We simply return FALSE.
*/
PKIX_CHECK(PKIX_PL_Object_GetType
(secondObject, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_CERTPOLICYQUALIFIER_TYPE) {
*pResult = PKIX_FALSE;
goto cleanup;
}
firstCPQ = (PKIX_PL_CertPolicyQualifier *)firstObject;
secondCPQ = (PKIX_PL_CertPolicyQualifier *)secondObject;
/*
* Compare the value of the OID components
*/
PKIX_NULLCHECK_TWO
(firstCPQ->policyQualifierId, secondCPQ->policyQualifierId);
PKIX_EQUALS
(firstCPQ->policyQualifierId,
secondCPQ->policyQualifierId,
&compare,
plContext,
PKIX_OIDEQUALSFAILED);
/*
* If the OIDs did not match, we don't need to
* compare the ByteArrays. If the OIDs did match,
* the return value is the value of the
* ByteArray comparison.
*/
if (compare) {
PKIX_NULLCHECK_TWO(firstCPQ->qualifier, secondCPQ->qualifier);
PKIX_EQUALS
(firstCPQ->qualifier,
secondCPQ->qualifier,
&compare,
plContext,
PKIX_BYTEARRAYEQUALSFAILED);
}
*pResult = compare;
cleanup:
PKIX_RETURN(CERTPOLICYQUALIFIER);
}
/*
* FUNCTION: pkix_pl_CertPolicyMap_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_CertPolicyMap_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_PL_CertPolicyMap *firstCertMap = NULL;
PKIX_PL_CertPolicyMap *secondCertMap = NULL;
PKIX_UInt32 secondType = 0;
PKIX_Boolean compare = PKIX_FALSE;
PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
/* test that firstObject is a CertPolicyMap */
PKIX_CHECK(pkix_CheckType
(firstObject, PKIX_CERTPOLICYMAP_TYPE, plContext),
PKIX_FIRSTOBJECTNOTCERTPOLICYMAP);
/*
* Since we know firstObject is a CertPolicyMap,
* if both references are identical, they must be equal
*/
if (firstObject == secondObject){
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondObject isn't a CertPolicyMap, we
* don't throw an error. We simply return FALSE.
*/
PKIX_CHECK(PKIX_PL_Object_GetType
(secondObject, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_CERTPOLICYMAP_TYPE) {
*pResult = PKIX_FALSE;
goto cleanup;
}
firstCertMap = (PKIX_PL_CertPolicyMap *)firstObject;
secondCertMap = (PKIX_PL_CertPolicyMap *)secondObject;
PKIX_EQUALS
(firstCertMap->issuerDomainPolicy,
secondCertMap->issuerDomainPolicy,
&compare,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (compare) {
PKIX_EQUALS
(firstCertMap->subjectDomainPolicy,
secondCertMap->subjectDomainPolicy,
&compare,
plContext,
PKIX_OBJECTEQUALSFAILED);
}
*pResult = compare;
cleanup:
PKIX_RETURN(CERTPOLICYMAP);
}
/*
* FUNCTION: pkix_pl_GeneralName_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_GeneralName_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_PL_GeneralName *firstName = NULL;
PKIX_PL_GeneralName *secondName = NULL;
PKIX_UInt32 secondType;
PKIX_ENTER(GENERALNAME, "pkix_pl_GeneralName_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
/* test that firstObject is a GeneralName */
PKIX_CHECK(pkix_CheckType
(firstObject, PKIX_GENERALNAME_TYPE, plContext),
PKIX_FIRSTOBJECTNOTGENERALNAME);
/*
* Since we know firstObject is a GeneralName, if both references are
* identical, they must be equal
*/
if (firstObject == secondObject){
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondObject isn't a GeneralName, we don't throw an error.
* We simply return a Boolean result of FALSE
*/
*pResult = PKIX_FALSE;
PKIX_CHECK(PKIX_PL_Object_GetType
(secondObject, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_GENERALNAME_TYPE){
goto cleanup;
}
firstName = (PKIX_PL_GeneralName *)firstObject;
secondName = (PKIX_PL_GeneralName *)secondObject;
if (firstName->type != secondName->type){
goto cleanup;
}
switch (firstName->type) {
case certRFC822Name:
case certDNSName:
case certX400Address:
case certEDIPartyName:
case certURI:
case certIPAddress:
PKIX_GENERALNAME_DEBUG("\t\tCalling SECITEM_CompareItem).\n");
if (SECITEM_CompareItem(firstName->other,
secondName->other) != SECEqual) {
goto cleanup;
}
break;
case certRegisterID:
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstName->oid,
(PKIX_PL_Object *)secondName->oid,
pResult,
plContext),
PKIX_OIDEQUALSFAILED);
goto cleanup;
case certOtherName:
PKIX_NULLCHECK_TWO(firstName->OthName, secondName->OthName);
PKIX_GENERALNAME_DEBUG("\t\tCalling SECITEM_CompareItem).\n");
if (SECITEM_CompareItem(&firstName->OthName->oid,
&secondName->OthName->oid)
!= SECEqual ||
SECITEM_CompareItem(&firstName->OthName->name,
&secondName->OthName->name)
!= SECEqual) {
goto cleanup;
}
break;
case certDirectoryName:
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstName->directoryName,
(PKIX_PL_Object *)secondName->directoryName,
pResult,
plContext),
PKIX_X500NAMEEQUALSFAILED);
goto cleanup;
}
*pResult = PKIX_TRUE;
cleanup:
PKIX_RETURN(GENERALNAME);
}
/*
* FUNCTION: pkix_pl_Object_ToString_Default
* DESCRIPTION:
*
* Default Object_ToString callback: Creates a string consisting of the
* typename and address of the Object pointed to by "object" and stores
* the result at "pString". The format for the string is
* "TypeName@Address: <address>", where the default typename is "Object".
*
* PARAMETERS:
* "object"
* Address of Object to convert to a string. Must be non-NULL.
* "pString"
* 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 an Object Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_Object_ToString_Default(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_PL_String *formatString = NULL;
PKIX_PL_String *descString = NULL;
char *format = "%s@Address: %x";
char *description = NULL;
PKIX_UInt32 objType;
PKIX_ENTER(OBJECT, "pkix_pl_Object_ToString_Default");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(PKIX_PL_Object_GetType(object, &objType, plContext),
PKIX_OBJECTGETTYPEFAILED);
if (objType >= PKIX_NUMTYPES){
#ifdef PKIX_USER_OBJECT_TYPE
pkix_ClassTable_Entry *ctEntry = NULL;
PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
PR_Lock(classTableLock);
pkixErrorResult = pkix_pl_PrimHashTable_Lookup
(classTable,
(void *)&objType,
objType,
NULL,
(void **)&ctEntry,
plContext);
PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
PR_Unlock(classTableLock);
if (pkixErrorResult){
PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY);
}
if (ctEntry == NULL){
PKIX_ERROR_FATAL(PKIX_UNDEFINEDCLASSTABLEENTRY);
} else {
description = ctEntry->description;
if (description == NULL) {
description = "User Type Object";
}
}
#else
PORT_Assert (0);
pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
pkixErrorClass = PKIX_FATAL_ERROR;
goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
} else {
description = systemClasses[objType].description;
}
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
(void *)format,
0,
&formatString,
plContext),
PKIX_STRINGCREATEFAILED);
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
(void *)description,
0,
&descString,
plContext),
PKIX_STRINGCREATEFAILED);
PKIX_CHECK(PKIX_PL_Sprintf
(pString,
plContext,
formatString,
descString,
object),
PKIX_SPRINTFFAILED);
cleanup:
PKIX_DECREF(formatString);
PKIX_DECREF(descString);
PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: pkix_PolicyNode_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_PolicyNode_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_PolicyNode *firstPN = NULL;
PKIX_PolicyNode *secondPN = NULL;
PKIX_UInt32 secondType;
PKIX_Boolean compResult = PKIX_FALSE;
PKIX_ENTER(CERTPOLICYNODE, "pkix_PolicyNode_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
/* test that firstObject is a PolicyNode */
PKIX_CHECK(pkix_CheckType
(firstObject, PKIX_CERTPOLICYNODE_TYPE, plContext),
PKIX_FIRSTOBJECTNOTPOLICYNODE);
/*
* Since we know firstObject is a PolicyNode,
* if both references are identical, they must be equal
*/
if (firstObject == secondObject) {
compResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondObject isn't a PolicyNode, we
* don't throw an error. We simply return FALSE.
*/
PKIX_CHECK(PKIX_PL_Object_GetType
(secondObject, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_CERTPOLICYNODE_TYPE) {
goto cleanup;
}
/*
* Oh, well, we have to do the comparisons. Do
* the easiest ones first.
*/
firstPN = (PKIX_PolicyNode *)firstObject;
secondPN = (PKIX_PolicyNode *)secondObject;
/*
* We don't require the parents to be identical. In the
* course of traversing the tree, we will have checked the
* attributes of the parent nodes, and checking the lists
* of children will determine whether they match.
*/
PKIX_EQUALS
(firstPN->children,
secondPN->children,
&compResult,
plContext,
PKIX_OBJECTEQUALSFAILEDONCHILDREN);
if (compResult == PKIX_FALSE) {
goto cleanup;
}
PKIX_CHECK(pkix_SinglePolicyNode_Equals
(firstPN, secondPN, &compResult, plContext),
PKIX_SINGLEPOLICYNODEEQUALSFAILED);
cleanup:
*pResult = compResult;
PKIX_RETURN(CERTPOLICYNODE);
}
/*
* FUNCTION: pkix_Error_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_Error_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_Error *firstError = NULL;
PKIX_Error *secondError = NULL;
PKIX_Error *firstCause = NULL;
PKIX_Error *secondCause = NULL;
PKIX_PL_Object *firstInfo = NULL;
PKIX_PL_Object *secondInfo = NULL;
PKIX_ERRORCLASS firstClass, secondClass;
PKIX_UInt32 secondType;
PKIX_Boolean boolResult, unequalFlag;
PKIX_ENTER(ERROR, "pkix_Error_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
unequalFlag = PKIX_FALSE;
/* First just compare pointer values to save time */
if (firstObject == secondObject) {
*pResult = PKIX_TRUE;
goto cleanup;
} else {
/* Result will only be set to true if all tests pass */
*pResult = PKIX_FALSE;
}
PKIX_CHECK(pkix_CheckType(firstObject, PKIX_ERROR_TYPE, plContext),
PKIX_FIRSTOBJECTNOTANERROROBJECT);
PKIX_CHECK(PKIX_PL_Object_GetType
(secondObject, &secondType, plContext),
PKIX_ERRORGETTINGSECONDOBJECTTYPE);
/* If types differ, then return false. Result is already set */
if (secondType != PKIX_ERROR_TYPE) goto cleanup;
/* It is safe to cast to PKIX_Error */
firstError = (PKIX_Error *) firstObject;
secondError = (PKIX_Error *) secondObject;
/* Compare error codes */
firstClass = firstError->errClass;
secondClass = secondError->errClass;
/* If codes differ, return false. Result is already set */
if (firstClass != secondClass) goto cleanup;
/* Compare causes */
firstCause = firstError->cause;
secondCause = secondError->cause;
/* Ensure that either both or none of the causes are NULL */
if (((firstCause != NULL) && (secondCause == NULL))||
((firstCause == NULL) && (secondCause != NULL)))
unequalFlag = PKIX_TRUE;
if ((firstCause != NULL) && (secondCause != NULL)) {
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object*)firstCause,
(PKIX_PL_Object*)secondCause,
&boolResult,
plContext),
PKIX_ERRORINRECURSIVEEQUALSCALL);
/* Set the unequalFlag so that we return after dec refing */
if (boolResult == 0) unequalFlag = PKIX_TRUE;
}
/* If the cause errors are not equal, return null */
if (unequalFlag) goto cleanup;
/* Compare info fields */
firstInfo = firstError->info;
secondInfo = secondError->info;
if (firstInfo != secondInfo) goto cleanup;
/* Ensure that either both or none of the infos are NULL */
if (((firstInfo != NULL) && (secondInfo == NULL))||
((firstInfo == NULL) && (secondInfo != NULL)))
unequalFlag = PKIX_TRUE;
if ((firstInfo != NULL) && (secondInfo != NULL)) {
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object*)firstInfo,
(PKIX_PL_Object*)secondInfo,
&boolResult,
plContext),
PKIX_ERRORINRECURSIVEEQUALSCALL);
/* Set the unequalFlag so that we return after dec refing */
if (boolResult == 0) unequalFlag = PKIX_TRUE;
}
/* If the infos are not equal, return null */
if (unequalFlag) goto cleanup;
/* Compare descs */
if (firstError->errCode != secondError->errCode) {
unequalFlag = PKIX_TRUE;
}
if (firstError->plErr != secondError->plErr) {
unequalFlag = PKIX_TRUE;
}
/* If the unequalFlag was set, return false */
if (unequalFlag) goto cleanup;
/* Errors are equal in all fields at this point */
*pResult = PKIX_TRUE;
cleanup:
PKIX_RETURN(ERROR);
}
/*
* 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_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;
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstValResult->anchor,
(PKIX_PL_Object *)secondValResult->anchor,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
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 {
if (PKIX_EXACTLY_ONE_NULL(firstTree, secondTree)) {
cmpResult = PKIX_FALSE;
}
}
/*
* The remaining case is that both are null,
* which we consider equality.
* cmpResult = PKIX_TRUE;
*/
*pResult = cmpResult;
cleanup:
PKIX_RETURN(VALIDATERESULT);
}
/*
* FUNCTION: pkix_pl_CertBasicConstraints_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_CertBasicConstraints_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_PL_CertBasicConstraints *firstCBC = NULL;
PKIX_PL_CertBasicConstraints *secondCBC = NULL;
PKIX_UInt32 secondType;
PKIX_Boolean firstIsCA = PKIX_FALSE;
PKIX_Boolean secondIsCA = PKIX_FALSE;
PKIX_Int32 firstPathLen = 0;
PKIX_Int32 secondPathLen = 0;
PKIX_ENTER(CERTBASICCONSTRAINTS,
"pkix_pl_CertBasicConstraints_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
/* test that firstObject is a CertBasicConstraints */
PKIX_CHECK(pkix_CheckType
(firstObject, PKIX_CERTBASICCONSTRAINTS_TYPE, plContext),
PKIX_FIRSTOBJECTNOTCERTBASICCONSTRAINTS);
/*
* Since we know firstObject is a CertBasicConstraints,
* if both references are identical, they must be equal
*/
if (firstObject == secondObject){
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondObject isn't a CertBasicConstraints, we
* don't throw an error. We simply return FALSE.
*/
PKIX_CHECK(PKIX_PL_Object_GetType
(secondObject, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_CERTBASICCONSTRAINTS_TYPE) {
*pResult = PKIX_FALSE;
goto cleanup;
}
firstCBC = (PKIX_PL_CertBasicConstraints *)firstObject;
secondCBC = (PKIX_PL_CertBasicConstraints *)secondObject;
/*
* Compare the value of the CAFlag components
*/
firstIsCA = firstCBC->isCA;
/*
* Failure here would be an error, not merely a miscompare,
* since we know second is a CertBasicConstraints.
*/
secondIsCA = secondCBC->isCA;
/*
* If isCA flags differ, the objects are not equal.
*/
if (secondIsCA != firstIsCA) {
*pResult = PKIX_FALSE;
goto cleanup;
}
/*
* If isCA was FALSE, the objects are equal, because
* pathLen is meaningless in that case.
*/
if (!firstIsCA) {
*pResult = PKIX_TRUE;
goto cleanup;
}
firstPathLen = firstCBC->pathLen;
secondPathLen = secondCBC->pathLen;
*pResult = (secondPathLen == firstPathLen);
cleanup:
PKIX_RETURN(CERTBASICCONSTRAINTS);
}
/*
* FUNCTION: pkix_VerifyNode_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_VerifyNode_Equals(
PKIX_PL_Object *firstObject,
PKIX_PL_Object *secondObject,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_VerifyNode *firstVN = NULL;
PKIX_VerifyNode *secondVN = NULL;
PKIX_UInt32 secondType;
PKIX_Boolean compResult = PKIX_FALSE;
PKIX_ENTER(VERIFYNODE, "pkix_VerifyNode_Equals");
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
/* test that firstObject is a VerifyNode */
PKIX_CHECK(pkix_CheckType
(firstObject, PKIX_VERIFYNODE_TYPE, plContext),
PKIX_FIRSTOBJECTNOTVERIFYNODE);
/*
* Since we know firstObject is a VerifyNode,
* if both references are identical, they must be equal
*/
if (firstObject == secondObject){
compResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondObject isn't a VerifyNode, we
* don't throw an error. We simply return FALSE.
*/
PKIX_CHECK(PKIX_PL_Object_GetType
(secondObject, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_VERIFYNODE_TYPE) {
goto cleanup;
}
/*
* Oh, well, we have to do the comparisons. Do
* the easiest ones first.
*/
firstVN = (PKIX_VerifyNode *)firstObject;
secondVN = (PKIX_VerifyNode *)secondObject;
PKIX_CHECK(pkix_SingleVerifyNode_Equals
(firstVN, secondVN, &compResult, plContext),
PKIX_SINGLEVERIFYNODEEQUALSFAILED);
if (compResult == PKIX_FALSE) {
goto cleanup;
}
PKIX_EQUALS
(firstVN->children,
secondVN->children,
&compResult,
plContext,
PKIX_OBJECTEQUALSFAILEDONCHILDREN);
cleanup:
*pResult = compResult;
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_pl_OcspResponse_Equals
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_OcspResponse_Equals(
PKIX_PL_Object *firstObj,
PKIX_PL_Object *secondObj,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType = 0;
PKIX_UInt32 firstLen = 0;
PKIX_UInt32 i = 0;
PKIX_PL_OcspResponse *rsp1 = NULL;
PKIX_PL_OcspResponse *rsp2 = NULL;
const unsigned char *firstData = NULL;
const unsigned char *secondData = NULL;
PKIX_ENTER(OCSPRESPONSE, "pkix_pl_OcspResponse_Equals");
PKIX_NULLCHECK_THREE(firstObj, secondObj, pResult);
/* test that firstObj is a OcspResponse */
PKIX_CHECK(pkix_CheckType(firstObj, PKIX_OCSPRESPONSE_TYPE, plContext),
PKIX_FIRSTOBJARGUMENTNOTANOCSPRESPONSE);
/*
* Since we know firstObj is a OcspResponse, if both references are
* identical, they must be equal
*/
if (firstObj == secondObj){
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If secondObj isn't a OcspResponse, we don't throw an error.
* We simply return a Boolean result of FALSE
*/
*pResult = PKIX_FALSE;
PKIX_CHECK(PKIX_PL_Object_GetType(secondObj, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_OCSPRESPONSE_TYPE) {
goto cleanup;
}
rsp1 = (PKIX_PL_OcspResponse *)firstObj;
rsp2 = (PKIX_PL_OcspResponse *)secondObj;
/* If either lacks an encoded string, they cannot be compared */
firstData = (const unsigned char *)rsp1->encodedResponse->data;
secondData = (const unsigned char *)rsp2->encodedResponse->data;
if ((firstData == NULL) || (secondData == NULL)) {
goto cleanup;
}
firstLen = rsp1->encodedResponse->len;
if (firstLen != rsp2->encodedResponse->len) {
goto cleanup;
}
for (i = 0; i < firstLen; i++) {
if (*firstData++ != *secondData++) {
goto cleanup;
}
}
*pResult = PKIX_TRUE;
cleanup:
PKIX_RETURN(OCSPRESPONSE);
}
/*
* FUNCTION: pkix_TrustAnchor_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_TrustAnchor_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_TrustAnchor *firstAnchor = NULL;
PKIX_TrustAnchor *secondAnchor = NULL;
PKIX_PL_Cert *firstCert = NULL;
PKIX_PL_Cert *secondCert = NULL;
PKIX_ENTER(TRUSTANCHOR, "pkix_TrustAnchor_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
PKIX_CHECK(pkix_CheckType(first, PKIX_TRUSTANCHOR_TYPE, plContext),
PKIX_FIRSTOBJECTNOTTRUSTANCHOR);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
*pResult = PKIX_FALSE;
if (secondType != PKIX_TRUSTANCHOR_TYPE) goto cleanup;
firstAnchor = (PKIX_TrustAnchor *)first;
secondAnchor = (PKIX_TrustAnchor *)second;
firstCert = firstAnchor->trustedCert;
secondCert = secondAnchor->trustedCert;
if ((firstCert && !secondCert) || (!firstCert && secondCert)){
goto cleanup;
}
if (firstCert && secondCert){
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstCert,
(PKIX_PL_Object *)secondCert,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
} else {
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstAnchor->caName,
(PKIX_PL_Object *)secondAnchor->caName,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstAnchor->caPubKey,
(PKIX_PL_Object *)secondAnchor->caPubKey,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_EQUALS
(firstAnchor->nameConstraints,
secondAnchor->nameConstraints,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
}
*pResult = cmpResult;
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: pkix_ProcessingParams_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ProcessingParams_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_ProcessingParams *firstProcParams = NULL;
PKIX_ProcessingParams *secondProcParams = NULL;
PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
PKIX_CHECK(pkix_CheckType(first, PKIX_PROCESSINGPARAMS_TYPE, plContext),
PKIX_FIRSTOBJECTNOTPROCESSINGPARAMS);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
*pResult = PKIX_FALSE;
if (secondType != PKIX_PROCESSINGPARAMS_TYPE) goto cleanup;
firstProcParams = (PKIX_ProcessingParams *)first;
secondProcParams = (PKIX_ProcessingParams *)second;
/* Do the simplest tests first */
if ((firstProcParams->qualifiersRejected) !=
(secondProcParams->qualifiersRejected)) {
goto cleanup;
}
if (firstProcParams->isCrlRevocationCheckingEnabled !=
secondProcParams->isCrlRevocationCheckingEnabled) {
goto cleanup;
}
if (firstProcParams->isCrlRevocationCheckingEnabledWithNISTPolicy !=
secondProcParams->isCrlRevocationCheckingEnabledWithNISTPolicy) {
goto cleanup;
}
/* trustAnchors can never be NULL */
PKIX_EQUALS
(firstProcParams->trustAnchors,
secondProcParams->trustAnchors,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_EQUALS
(firstProcParams->hintCerts,
secondProcParams->hintCerts,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_EQUALS
(firstProcParams->date,
secondProcParams->date,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_EQUALS
(firstProcParams->constraints,
secondProcParams->constraints,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_EQUALS
(firstProcParams->initialPolicies,
secondProcParams->initialPolicies,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
/* There is no Equals function for CertChainCheckers */
PKIX_EQUALS
((PKIX_PL_Object *)firstProcParams->certStores,
(PKIX_PL_Object *)secondProcParams->certStores,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_EQUALS
(firstProcParams->resourceLimits,
secondProcParams->resourceLimits,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (cmpResult == PKIX_FALSE) {
*pResult = PKIX_FALSE;
goto cleanup;
}
*pResult = cmpResult;
cleanup:
PKIX_RETURN(PROCESSINGPARAMS);
}
