/*
* FUNCTION: pkix_OcspChecker_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_OcspChecker_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_OcspChecker *checker = NULL;
PKIX_ENTER(OCSPCHECKER, "pkix_OcspChecker_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a ocsp checker */
PKIX_CHECK(pkix_CheckType
(object, PKIX_OCSPCHECKER_TYPE, plContext),
PKIX_OBJECTNOTOCSPCHECKER);
checker = (PKIX_OcspChecker *)object;
PKIX_DECREF(checker->response);
PKIX_DECREF(checker->validityTime);
PKIX_DECREF(checker->cert);
/* These are not yet ref-counted objects */
/* PKIX_DECREF(checker->passwordInfo); */
/* PKIX_DECREF(checker->responder); */
/* PKIX_DECREF(checker->nbioContext); */
cleanup:
PKIX_RETURN(OCSPCHECKER);
}
/*
* FUNCTION: pkix_VerifyNode_Duplicate
* (see comments for PKIX_PL_Duplicate_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_VerifyNode_Duplicate(
PKIX_PL_Object *object,
PKIX_PL_Object **pNewObject,
void *plContext)
{
PKIX_VerifyNode *original = NULL;
PKIX_VerifyNode *copy = NULL;
PKIX_ENTER(VERIFYNODE, "pkix_VerifyNode_Duplicate");
PKIX_NULLCHECK_TWO(object, pNewObject);
PKIX_CHECK(pkix_CheckType
(object, PKIX_VERIFYNODE_TYPE, plContext),
PKIX_OBJECTNOTVERIFYNODE);
original = (PKIX_VerifyNode *)object;
PKIX_CHECK(pkix_VerifyNode_DuplicateHelper
(original, NULL, ©, plContext),
PKIX_VERIFYNODEDUPLICATEHELPERFAILED);
*pNewObject = (PKIX_PL_Object *)copy;
cleanup:
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_VerifyNode_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_VerifyNode_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_VerifyNode *node = NULL;
PKIX_ENTER(VERIFYNODE, "pkix_VerifyNode_Destroy");
PKIX_NULLCHECK_ONE(object);
PKIX_CHECK(pkix_CheckType(object, PKIX_VERIFYNODE_TYPE, plContext),
PKIX_OBJECTNOTVERIFYNODE);
node = (PKIX_VerifyNode*)object;
PKIX_DECREF(node->verifyCert);
PKIX_DECREF(node->children);
PKIX_DECREF(node->error);
node->depth = 0;
cleanup:
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_pl_CRL_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_CRL_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_PL_String *crlString = NULL;
PKIX_PL_CRL *crl = NULL;
PKIX_ENTER(CRL, "pkix_pl_CRL_ToString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_CRL_TYPE, plContext),
PKIX_OBJECTNOTCRL);
crl = (PKIX_PL_CRL *) object;
PKIX_CHECK(pkix_pl_CRL_ToString_Helper(crl, &crlString, plContext),
PKIX_CRLTOSTRINGHELPERFAILED);
*pString = crlString;
cleanup:
PKIX_RETURN(CRL);
}
/*
* FUNCTION: pkix_ResourceLimits_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ResourceLimits_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_ResourceLimits *rLimits = NULL;
PKIX_ENTER(RESOURCELIMITS, "pkix_ResourceLimits_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a ResourceLimits object */
PKIX_CHECK(pkix_CheckType(object, PKIX_RESOURCELIMITS_TYPE, plContext),
PKIX_OBJECTNOTRESOURCELIMITS);
rLimits = (PKIX_ResourceLimits *)object;
rLimits->maxTime = 0;
rLimits->maxFanout = 0;
rLimits->maxDepth = 0;
rLimits->maxCertsNumber = 0;
rLimits->maxCrlsNumber = 0;
cleanup:
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: pkix_pl_CertPolicyQualifier_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_CertPolicyQualifier_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_PL_CertPolicyQualifier *certPQ = NULL;
PKIX_UInt32 cpidHash = 0;
PKIX_UInt32 cpqHash = 0;
PKIX_ENTER(CERTPOLICYQUALIFIER, "pkix_pl_CertPolicyQualifier_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType
(object, PKIX_CERTPOLICYQUALIFIER_TYPE, plContext),
PKIX_OBJECTNOTCERTPOLICYQUALIFIER);
certPQ = (PKIX_PL_CertPolicyQualifier *)object;
PKIX_NULLCHECK_TWO(certPQ->policyQualifierId, certPQ->qualifier);
PKIX_HASHCODE(certPQ->policyQualifierId, &cpidHash, plContext,
PKIX_ERRORINOIDHASHCODE);
PKIX_HASHCODE(certPQ->qualifier, &cpqHash, plContext,
PKIX_ERRORINBYTEARRAYHASHCODE);
*pHashcode = cpidHash*31 + cpqHash;
cleanup:
PKIX_RETURN(CERTPOLICYQUALIFIER);
}
/*
* FUNCTION: pkix_pl_OID_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_OID_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_PL_OID *oid = NULL;
PKIX_ENTER(OID, "pkix_pl_OID_HashCode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_OID_TYPE, plContext),
PKIX_OBJECTNOTANOID);
oid = (PKIX_PL_OID *)object;
PKIX_CHECK(pkix_hash
((unsigned char *)oid->derOid.data,
oid->derOid.len * sizeof (char),
pHashcode,
plContext),
PKIX_HASHFAILED);
cleanup:
PKIX_RETURN(OID);
}
/*
* FUNCTION: pkix_pl_Date_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_Date_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_PL_Date *date = NULL;
SECItem nssTime = {siBuffer, NULL, 0};
SECStatus rv;
PKIX_ENTER(DATE, "pkix_pl_Date_toString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_DATE_TYPE, plContext),
PKIX_OBJECTNOTDATE);
date = (PKIX_PL_Date *)object;
rv = DER_EncodeTimeChoice(NULL, &nssTime, date->nssTime);
if (rv == SECFailure) {
PKIX_ERROR(PKIX_DERENCODETIMECHOICEFAILED);
}
PKIX_CHECK(pkix_pl_Date_ToString_Helper
(&nssTime, pString, plContext),
PKIX_DATETOSTRINGHELPERFAILED);
cleanup:
if (nssTime.data) {
SECITEM_FreeItem(&nssTime, PR_FALSE);
}
PKIX_RETURN(DATE);
}
/*
* FUNCTION: pkix_pl_Date_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_Date_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_PL_Date *date = NULL;
PKIX_UInt32 dateHash;
PKIX_ENTER(DATE, "pkix_pl_Date_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_DATE_TYPE, plContext),
PKIX_OBJECTNOTDATE);
date = (PKIX_PL_Date *)object;
PKIX_CHECK(pkix_hash
((const unsigned char *)&date->nssTime,
sizeof(date->nssTime),
&dateHash,
plContext),
PKIX_HASHFAILED);
*pHashcode = dateHash;
cleanup:
PKIX_RETURN(DATE);
}
/*
* FUNCTION: pkix_CertStore_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_CertStore_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_CertStore *certStore = NULL;
PKIX_ENTER(CERTSTORE, "pkix_CertStore_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a CertStore object */
PKIX_CHECK(pkix_CheckType(object, PKIX_CERTSTORE_TYPE, plContext),
PKIX_OBJECTNOTCERTSTORE);
certStore = (PKIX_CertStore *)object;
certStore->certCallback = NULL;
certStore->crlCallback = NULL;
certStore->certContinue = NULL;
certStore->crlContinue = NULL;
certStore->trustCallback = NULL;
PKIX_DECREF(certStore->certStoreContext);
cleanup:
PKIX_RETURN(CERTSTORE);
}
/*
* FUNCTION: pkix_PolicyNode_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_PolicyNode_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_PolicyNode *node = NULL;
PKIX_ENTER(CERTPOLICYNODE, "pkix_PolicyNode_Destroy");
PKIX_NULLCHECK_ONE(object);
PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYNODE_TYPE, plContext),
PKIX_OBJECTNOTPOLICYNODE);
node = (PKIX_PolicyNode*)object;
node->criticality = PKIX_FALSE;
PKIX_DECREF(node->validPolicy);
PKIX_DECREF(node->qualifierSet);
PKIX_DECREF(node->expectedPolicySet);
PKIX_DECREF(node->children);
/*
* Note: the link to parent is not reference-counted. See comment
* in pkix_PolicyNode_AddToParent for more details.
*/
node->parent = NULL;
node->depth = 0;
cleanup:
PKIX_RETURN(CERTPOLICYNODE);
}
/*
* FUNCTION: pkix_pl_Date_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_Date_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_PL_String *dateString = NULL;
PKIX_PL_Date *date = NULL;
SECItem *nssTime = NULL;
char *asciiDate = NULL;
PKIX_ENTER(DATE, "pkix_pl_Date_toString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_DATE_TYPE, plContext),
PKIX_OBJECTNOTDATE);
date = (PKIX_PL_Date *)object;
nssTime = &date->nssTime;
PKIX_CHECK(pkix_pl_Date_ToString_Helper
(nssTime, &dateString, plContext),
PKIX_DATETOSTRINGHELPERFAILED);
*pString = dateString;
cleanup:
PKIX_FREE(asciiDate);
PKIX_RETURN(DATE);
}
/*
* FUNCTION: pkix_pl_GeneralName_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_GeneralName_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_PL_String *nameString = NULL;
PKIX_PL_GeneralName *name = NULL;
PKIX_ENTER(GENERALNAME, "pkix_pl_GeneralName_toString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_GENERALNAME_TYPE, plContext),
PKIX_OBJECTNOTGENERALNAME);
name = (PKIX_PL_GeneralName *)object;
PKIX_CHECK(pkix_pl_GeneralName_ToString_Helper
(name, &nameString, plContext),
PKIX_GENERALNAMETOSTRINGHELPERFAILED);
*pString = nameString;
cleanup:
PKIX_RETURN(GENERALNAME);
}
/*
* FUNCTION: pkix_pl_HttpCertStoreContext_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_HttpCertStoreContext_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
const SEC_HttpClientFcnV1 *hcv1 = NULL;
PKIX_PL_HttpCertStoreContext *context = NULL;
PKIX_ENTER
(HTTPCERTSTORECONTEXT, "pkix_pl_HttpCertStoreContext_Destroy");
PKIX_NULLCHECK_ONE(object);
PKIX_CHECK(pkix_CheckType
(object, PKIX_HTTPCERTSTORECONTEXT_TYPE, plContext),
PKIX_OBJECTNOTANHTTPCERTSTORECONTEXT);
context = (PKIX_PL_HttpCertStoreContext *)object;
hcv1 = (const SEC_HttpClientFcnV1 *)(context->client);
if (context->requestSession != NULL) {
(*hcv1->freeFcn)(context->requestSession);
context->requestSession = NULL;
}
if (context->serverSession != NULL) {
(*hcv1->freeSessionFcn)(context->serverSession);
context->serverSession = NULL;
}
if (context->path != NULL) {
PORT_Free(context->path);
context->path = NULL;
}
cleanup:
PKIX_RETURN(HTTPCERTSTORECONTEXT);
}
/*
* FUNCTION: pkix_pl_AIAMgr_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_pki.h)
*/
static PKIX_Error *
pkix_pl_AIAMgr_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_PL_AIAMgr *aiaMgr = NULL;
PKIX_ENTER(AIAMGR, "pkix_pl_AIAMgr_Destroy");
PKIX_NULLCHECK_ONE(object);
PKIX_CHECK(pkix_CheckType(object, PKIX_AIAMGR_TYPE, plContext),
PKIX_OBJECTNOTAIAMGR);
aiaMgr = (PKIX_PL_AIAMgr *)object;
/* pointer to cert cache */
/* pointer to crl cache */
aiaMgr->method = 0;
aiaMgr->aiaIndex = 0;
aiaMgr->numAias = 0;
PKIX_DECREF(aiaMgr->aia);
PKIX_DECREF(aiaMgr->location);
PKIX_DECREF(aiaMgr->results);
PKIX_DECREF(aiaMgr->client.ldapClient);
cleanup:
PKIX_RETURN(AIAMGR);
}
/*
* 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)
{
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;
}
*pResult = PKIX_FALSE;
pkixErrorResult =
pkix_pl_Date_Comparator(firstObject, secondObject,
pResult, plContext);
if (pkixErrorResult) {
PKIX_DECREF(pkixErrorResult);
}
cleanup:
PKIX_RETURN(DATE);
}
/*
* FUNCTION: pkix_pl_CertPolicyMap_Duplicate
* (see comments for PKIX_PL_Duplicate_Callback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_CertPolicyMap_Duplicate(
PKIX_PL_Object *object,
PKIX_PL_Object **pNewObject,
void *plContext)
{
PKIX_PL_CertPolicyMap *original = NULL;
PKIX_PL_CertPolicyMap *copy = NULL;
PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Duplicate");
PKIX_NULLCHECK_TWO(object, pNewObject);
PKIX_CHECK(pkix_CheckType
(object, PKIX_CERTPOLICYMAP_TYPE, plContext),
PKIX_OBJECTARGUMENTNOTPOLICYMAP);
original = (PKIX_PL_CertPolicyMap *)object;
PKIX_CHECK(pkix_pl_CertPolicyMap_Create
(original->issuerDomainPolicy,
original->subjectDomainPolicy,
©,
plContext),
PKIX_CERTPOLICYMAPCREATEFAILED);
*pNewObject = (PKIX_PL_Object *)copy;
cleanup:
PKIX_RETURN(CERTPOLICYMAP);
}
/*
* 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_List_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_List_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_List *list = NULL;
PKIX_List *nextItem = NULL;
PKIX_ENTER(LIST, "pkix_List_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a list */
PKIX_CHECK(pkix_CheckType(object, PKIX_LIST_TYPE, plContext),
PKIX_OBJECTNOTLIST);
list = (PKIX_List *)object;
/* We have a valid list. DecRef its item and recurse on next */
PKIX_DECREF(list->item);
while ((nextItem = list->next) != NULL) {
list->next = nextItem->next;
nextItem->next = NULL;
PKIX_DECREF(nextItem);
}
list->immutable = PKIX_FALSE;
list->length = 0;
list->isHeader = PKIX_FALSE;
cleanup:
PKIX_RETURN(LIST);
}
/*
* 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)((char *)logger->callback - (char *)NULL) + tempHash) << 7) +
logger->maxLevel) << 7) + (PKIX_UInt32)logger->logComponent;
*pHashcode = hash;
cleanup:
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: pkix_pl_OID_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
* Use this function only for printing OIDs and not to make any
* critical security decision.
*/
static PKIX_Error *
pkix_pl_OID_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_PL_OID *oid = NULL;
char *oidString = NULL;
PKIX_ENTER(OID, "pkix_pl_OID_toString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_OID_TYPE, plContext),
PKIX_OBJECTNOTANOID);
oid = (PKIX_PL_OID*)object;
oidString = CERT_GetOidString(&oid->derOid);
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII, oidString , 0, pString, plContext),
PKIX_STRINGCREATEFAILED);
cleanup:
PR_smprintf_free(oidString);
PKIX_RETURN(OID);
}
/*
* FUNCTION: pkix_TargetCertCheckerState_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_TargetCertCheckerState_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
pkix_TargetCertCheckerState *state = NULL;
PKIX_ENTER(TARGETCERTCHECKERSTATE,
"pkix_TargetCertCheckerState_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a target cert checker state */
PKIX_CHECK(pkix_CheckType
(object, PKIX_TARGETCERTCHECKERSTATE_TYPE, plContext),
PKIX_OBJECTNOTTARGETCERTCHECKERSTATE);
state = (pkix_TargetCertCheckerState *)object;
PKIX_DECREF(state->certSelector);
PKIX_DECREF(state->extKeyUsageOID);
PKIX_DECREF(state->subjAltNameOID);
PKIX_DECREF(state->pathToNameList);
PKIX_DECREF(state->extKeyUsageList);
PKIX_DECREF(state->subjAltNameList);
cleanup:
PKIX_RETURN(TARGETCERTCHECKERSTATE);
}
/*
* FUNCTION: pkix_pl_CollectionCertStoreContext_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_CollectionCertStoreContext_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_PL_CollectionCertStoreContext *collectionCSContext = NULL;
PKIX_UInt32 tempHash = 0;
PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
"pkix_pl_CollectionCertStoreContext_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType
(object,
PKIX_COLLECTIONCERTSTORECONTEXT_TYPE,
plContext),
PKIX_OBJECTNOTCOLLECTIONCERTSTORECONTEXT);
collectionCSContext = (PKIX_PL_CollectionCertStoreContext *)object;
PKIX_CHECK(PKIX_PL_Object_Hashcode
((PKIX_PL_Object *) collectionCSContext->storeDir,
&tempHash,
plContext),
PKIX_STRINGHASHCODEFAILED);
*pHashcode = tempHash << 7;
/* should not hash on crlList and certList, values are dynamic */
cleanup:
PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
}
/*
* FUNCTION: pkix_pl_OcspResponse_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_OcspResponse_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_PL_OcspResponse *ocspRsp = NULL;
PKIX_ENTER(OCSPRESPONSE, "pkix_pl_OcspResponse_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_OCSPRESPONSE_TYPE, plContext),
PKIX_OBJECTNOTANOCSPRESPONSE);
ocspRsp = (PKIX_PL_OcspResponse *)object;
if (ocspRsp->encodedResponse->data == NULL) {
*pHashcode = 0;
} else {
PKIX_CHECK(pkix_hash
(ocspRsp->encodedResponse->data,
ocspRsp->encodedResponse->len,
pHashcode,
plContext),
PKIX_HASHFAILED);
}
cleanup:
PKIX_RETURN(OCSPRESPONSE);
}
/*
* FUNCTION: pkix_ResourceLimits_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ResourceLimits_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_ResourceLimits *rLimits = NULL;
PKIX_UInt32 hash = 0;
PKIX_ENTER(RESOURCELIMITS, "pkix_ResourceLimits_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_RESOURCELIMITS_TYPE, plContext),
PKIX_OBJECTNOTRESOURCELIMITS);
rLimits = (PKIX_ResourceLimits*)object;
hash = 31 * rLimits->maxTime + (rLimits->maxFanout << 1) +
(rLimits->maxDepth << 2) + (rLimits->maxCertsNumber << 3) +
rLimits->maxCrlsNumber;
*pHashcode = hash;
cleanup:
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: pkix_ProcessingParams_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ProcessingParams_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_ProcessingParams *params = NULL;
PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a processing params object */
PKIX_CHECK(pkix_CheckType
(object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
PKIX_OBJECTNOTPROCESSINGPARAMS);
params = (PKIX_ProcessingParams *)object;
PKIX_DECREF(params->trustAnchors);
PKIX_DECREF(params->hintCerts);
PKIX_DECREF(params->constraints);
PKIX_DECREF(params->date);
PKIX_DECREF(params->initialPolicies);
PKIX_DECREF(params->certChainCheckers);
PKIX_DECREF(params->revCheckers);
PKIX_DECREF(params->certStores);
PKIX_DECREF(params->resourceLimits);
cleanup:
PKIX_RETURN(PROCESSINGPARAMS);
}
/*
* FUNCTION: pkix_VerifyNode_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_VerifyNode_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pTreeString,
void *plContext)
{
PKIX_VerifyNode *rootNode = NULL;
PKIX_PL_String *resultString = NULL;
PKIX_ENTER(VERIFYNODE, "pkix_VerifyNode_ToString");
PKIX_NULLCHECK_TWO(object, pTreeString);
PKIX_CHECK(pkix_CheckType(object, PKIX_VERIFYNODE_TYPE, plContext),
PKIX_OBJECTNOTVERIFYNODE);
rootNode = (PKIX_VerifyNode *)object;
PKIX_CHECK(pkix_VerifyNode_ToString_Helper
(rootNode, NULL, &resultString, plContext),
PKIX_ERRORCREATINGSUBTREESTRING);
*pTreeString = resultString;
cleanup:
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_NameConstraintsCheckerstate_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_NameConstraintsCheckerState_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
pkix_NameConstraintsCheckerState *state = NULL;
PKIX_ENTER(CERTNAMECONSTRAINTSCHECKERSTATE,
"pkix_NameConstraintsCheckerState_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that object type */
PKIX_CHECK(pkix_CheckType
(object, PKIX_CERTNAMECONSTRAINTSCHECKERSTATE_TYPE, plContext),
PKIX_OBJECTNOTNAMECONSTRAINTSCHECKERSTATE);
state = (pkix_NameConstraintsCheckerState *)object;
PKIX_DECREF(state->nameConstraints);
PKIX_DECREF(state->nameConstraintsOID);
cleanup:
PKIX_RETURN(CERTNAMECONSTRAINTSCHECKERSTATE);
}
/*
* FUNCTION: pkix_TrustAnchor_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_TrustAnchor_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_TrustAnchor *anchor = NULL;
PKIX_ENTER(TRUSTANCHOR, "pkix_TrustAnchor_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a trust anchor */
PKIX_CHECK(pkix_CheckType(object, PKIX_TRUSTANCHOR_TYPE, plContext),
PKIX_OBJECTNOTTRUSTANCHOR);
anchor = (PKIX_TrustAnchor *)object;
PKIX_DECREF(anchor->trustedCert);
PKIX_DECREF(anchor->caName);
PKIX_DECREF(anchor->caPubKey);
PKIX_DECREF(anchor->nameConstraints);
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: pkix_pl_ByteArray_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_ByteArray_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_PL_ByteArray *array = NULL;
PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_BYTEARRAY_TYPE, plContext),
PKIX_OBJECTNOTBYTEARRAY);
array = (PKIX_PL_ByteArray*)object;
PKIX_CHECK(pkix_hash
((const unsigned char *)array->array,
array->length,
pHashcode,
plContext),
PKIX_HASHFAILED);
cleanup:
PKIX_RETURN(BYTEARRAY);
}
