/* 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_verifynode.c
*
* Verify Node Object Type Definition
*
*/
#include "pkix_verifynode.h"
/* --Private-VerifyNode-Functions---------------------------------- */
/*
* FUNCTION: pkix_VerifyNode_Create
* DESCRIPTION:
*
* This function creates a VerifyNode using the Cert pointed to by "cert",
* the depth given by "depth", and the Error pointed to by "error", storing
* the result at "pObject".
*
* PARAMETERS
* "cert"
* Address of Cert for the node. Must be non-NULL
* "depth"
* UInt32 value of the depth for this node.
* "error"
* Address of Error for the node.
* "pObject"
* Address where the VerifyNode 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_VerifyNode_Create(
PKIX_PL_Cert *cert,
PKIX_UInt32 depth,
PKIX_Error *error,
PKIX_VerifyNode **pObject,
void *plContext)
{
PKIX_VerifyNode *node = NULL;
PKIX_ENTER(VERIFYNODE,
"pkix_VerifyNode_Create");
PKIX_NULLCHECK_TWO(cert, pObject);
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_VERIFYNODE_TYPE,
sizeof (PKIX_VerifyNode),
(PKIX_PL_Object **)&node,
plContext),
PKIX_COULDNOTCREATEVERIFYNODEOBJECT);
PKIX_INCREF(cert);
node->verifyCert = cert;
PKIX_INCREF(error);
node->error = error;
node->depth = depth;
node->children = NULL;
*pObject = node;
node = NULL;
cleanup:
PKIX_DECREF(node);
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_VerifyNode_AddToChain
* DESCRIPTION:
*
* Adds the VerifyNode pointed to by "child", at the appropriate depth, to the
* List of children of the VerifyNode pointed to by "parentNode". The chain of
* VerifyNodes is traversed until a VerifyNode is found at a depth one less
* than that specified in "child". An Error is returned if there is no parent
* at a suitable depth.
*
* If "parentNode" has a NULL pointer for the List of children, a new List is
* created containing "child". Otherwise "child" is appended to the existing
* List.
*
* Depth, in this context, means distance from the root node, which
* is at depth zero.
*
* PARAMETERS:
* "parentNode"
* Address of VerifyNode whose List of child VerifyNodes is to be
* created or appended to. Must be non-NULL.
* "child"
* Address of VerifyNode to be added to parentNode's List. Must be
* non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Not Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a VerifyNode Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_VerifyNode_AddToChain(
PKIX_VerifyNode *parentNode,
PKIX_VerifyNode *child,
void *plContext)
{
PKIX_VerifyNode *successor = NULL;
PKIX_List *listOfChildren = NULL;
PKIX_UInt32 numChildren = 0;
PKIX_UInt32 parentDepth = 0;
PKIX_ENTER(VERIFYNODE,
"pkix_VerifyNode_AddToChain");
PKIX_NULLCHECK_TWO(parentNode, child);
parentDepth = parentNode->depth;
listOfChildren = parentNode->children;
if (listOfChildren == NULL) {
if (parentDepth != (child->depth - 1)) {
PKIX_ERROR(PKIX_NODESMISSINGFROMCHAIN);
}
PKIX_CHECK(PKIX_List_Create(&listOfChildren, plContext),
PKIX_LISTCREATEFAILED);
PKIX_CHECK(PKIX_List_AppendItem
(listOfChildren, (PKIX_PL_Object *)child, plContext),
PKIX_COULDNOTAPPENDCHILDTOPARENTSVERIFYNODELIST);
parentNode->children = listOfChildren;
}
else {
/* get number of children */
PKIX_CHECK(PKIX_List_GetLength
(listOfChildren, &numChildren, plContext),
PKIX_LISTGETLENGTHFAILED);
if (numChildren != 1) {
PKIX_ERROR(PKIX_AMBIGUOUSPARENTAGEOFVERIFYNODE);
}
/* successor = listOfChildren[0] */
PKIX_CHECK(PKIX_List_GetItem
(listOfChildren,
0,
(PKIX_PL_Object **)&successor,
plContext),
PKIX_LISTGETITEMFAILED);
PKIX_CHECK(pkix_VerifyNode_AddToChain
(successor, child, plContext),
PKIX_VERIFYNODEADDTOCHAINFAILED);
}
PKIX_CHECK(PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)parentNode, plContext),
PKIX_OBJECTINVALIDATECACHEFAILED);
cleanup:
PKIX_DECREF(successor);
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_VerifyNode_SetDepth
* DESCRIPTION:
*
* The function sets the depth field of each VerifyNode in the List "children"
* to the value given by "depth", and recursively sets the depth of any
* successive generations to the successive values.
*
* PARAMETERS:
* "children"
* The List of VerifyNodes. Must be non-NULL.
* "depth"
* The value of the depth field to be set in members of the List.
* "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.
*/
static PKIX_Error *
pkix_VerifyNode_SetDepth(PKIX_List *children,
PKIX_UInt32 depth,
void *plContext)
{
PKIX_UInt32 numChildren = 0;
PKIX_UInt32 chIx = 0;
PKIX_VerifyNode *child = NULL;
PKIX_ENTER(VERIFYNODE,
"pkix_VerifyNode_SetDepth");
PKIX_NULLCHECK_ONE(children);
PKIX_CHECK(PKIX_List_GetLength(children, &numChildren, plContext),
PKIX_LISTGETLENGTHFAILED);
for (chIx = 0; chIx < numChildren; chIx++) {
PKIX_CHECK(PKIX_List_GetItem
(children, chIx, (PKIX_PL_Object **)&child, plContext),
PKIX_LISTGETITEMFAILED);
child->depth = depth;
if (child->children != NULL) {
PKIX_CHECK(pkix_VerifyNode_SetDepth
(child->children, depth + 1, plContext),
PKIX_VERIFYNODESETDEPTHFAILED);
}
PKIX_DECREF(child);
}
cleanup:
PKIX_DECREF(child);
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_VerifyNode_AddToTree
* DESCRIPTION:
*
* Adds the VerifyNode pointed to by "child" to the List of children of the
* VerifyNode pointed to by "parentNode". If "parentNode" has a NULL pointer
* for the List of children, a new List is created containing "child".
* Otherwise "child" is appended to the existing List. The depth field of
* "child" is set to one more than the corresponding value in "parent", and
* if the "child" itself has child nodes, their depth fields are updated
* accordingly.
*
* Depth, in this context, means distance from the root node, which
* is at depth zero.
*
* PARAMETERS:
* "parentNode"
* Address of VerifyNode whose List of child VerifyNodes is to be
* created or appended to. Must be non-NULL.
* "child"
* Address of VerifyNode to be added to parentNode's List. Must be
* non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Not 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_VerifyNode_AddToTree(
PKIX_VerifyNode *parentNode,
PKIX_VerifyNode *child,
void *plContext)
{
PKIX_List *listOfChildren = NULL;
PKIX_UInt32 parentDepth = 0;
PKIX_ENTER(VERIFYNODE,
"pkix_VerifyNode_AddToTree");
PKIX_NULLCHECK_TWO(parentNode, child);
parentDepth = parentNode->depth;
listOfChildren = parentNode->children;
if (listOfChildren == NULL) {
PKIX_CHECK(PKIX_List_Create(&listOfChildren, plContext),
PKIX_LISTCREATEFAILED);
parentNode->children = listOfChildren;
}
child->depth = parentDepth + 1;
PKIX_CHECK(PKIX_List_AppendItem
(parentNode->children, (PKIX_PL_Object *)child, plContext),
PKIX_COULDNOTAPPENDCHILDTOPARENTSVERIFYNODELIST);
if (child->children != NULL) {
PKIX_CHECK(pkix_VerifyNode_SetDepth
(child->children, child->depth + 1, plContext),
PKIX_VERIFYNODESETDEPTHFAILED);
}
cleanup:
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_SingleVerifyNode_ToString
* DESCRIPTION:
*
* Creates a String representation of the attributes of the VerifyNode pointed
* to by "node", other than its children, and stores the result at "pString".
*
* PARAMETERS:
* "node"
* Address of VerifyNode to be described by the string. Must be non-NULL.
* "pString"
* Address where object pointer will be stored. Must be non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Conditionally Thread Safe
* (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if function succeeds
* Returns a VerifyNode Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in a fatal way
*/
PKIX_Error *
pkix_SingleVerifyNode_ToString(
PKIX_VerifyNode *node,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_PL_String *fmtString = NULL;
PKIX_PL_String *errorString = NULL;
PKIX_PL_String *outString = NULL;
PKIX_PL_X500Name *issuerName = NULL;
PKIX_PL_X500Name *subjectName = NULL;
PKIX_PL_String *issuerString = NULL;
PKIX_PL_String *subjectString = NULL;
PKIX_ENTER(VERIFYNODE,
"pkix_SingleVerifyNode_ToString");
PKIX_NULLCHECK_THREE(node, pString, node->verifyCert);
PKIX_TOSTRING(node->error, &errorString, plContext,
PKIX_ERRORTOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_Cert_GetIssuer
(node->verifyCert, &issuerName, plContext),
PKIX_CERTGETISSUERFAILED);
PKIX_TOSTRING(issuerName, &issuerString, plContext,
PKIX_X500NAMETOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_Cert_GetSubject
(node->verifyCert, &subjectName, plContext),
PKIX_CERTGETSUBJECTFAILED);
PKIX_TOSTRING(subjectName, &subjectString, plContext,
PKIX_X500NAMETOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
"CERT[Issuer:%s, Subject:%s], depth=%d, error=%s",
0,
&fmtString,
plContext),
PKIX_CANTCREATESTRING);
PKIX_CHECK(PKIX_PL_Sprintf
(&outString,
plContext,
fmtString,
issuerString,
subjectString,
node->depth,
errorString),
PKIX_SPRINTFFAILED);
*pString = outString;
cleanup:
PKIX_DECREF(fmtString);
PKIX_DECREF(errorString);
PKIX_DECREF(issuerName);
PKIX_DECREF(subjectName);
PKIX_DECREF(issuerString);
PKIX_DECREF(subjectString);
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_VerifyNode_ToString_Helper
* DESCRIPTION:
*
* Produces a String representation of a VerifyNode tree below the VerifyNode
* pointed to by "rootNode", with each line of output prefixed by the String
* pointed to by "indent", and stores the result at "pTreeString". It is
* called recursively, with ever-increasing indentation, for successively
* lower nodes on the tree.
*
* PARAMETERS:
* "rootNode"
* Address of VerifyNode subtree. Must be non-NULL.
* "indent"
* Address of String to be prefixed to each line of output. May be NULL
* if no indentation is desired
* "pTreeString"
* Address where the resulting String will be stored; must be non-NULL
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Conditionally Thread Safe
* (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a VerifyNode 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_VerifyNode_ToString_Helper(
PKIX_VerifyNode *rootNode,
PKIX_PL_String *indent,
PKIX_PL_String **pTreeString,
void *plContext)
{
PKIX_PL_String *nextIndentFormat = NULL;
PKIX_PL_String *thisNodeFormat = NULL;
PKIX_PL_String *childrenFormat = NULL;
PKIX_PL_String *nextIndentString = NULL;
PKIX_PL_String *resultString = NULL;
PKIX_PL_String *thisItemString = NULL;
PKIX_PL_String *childString = NULL;
PKIX_VerifyNode *childNode = NULL;
PKIX_UInt32 numberOfChildren = 0;
PKIX_UInt32 childIndex = 0;
PKIX_ENTER(VERIFYNODE,
"pkix_VerifyNode_ToString_Helper");
PKIX_NULLCHECK_TWO(rootNode, pTreeString);
/* Create a string for this node */
PKIX_CHECK(pkix_SingleVerifyNode_ToString
(rootNode, &thisItemString, plContext),
PKIX_ERRORINSINGLEVERIFYNODETOSTRING);
if (indent) {
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
"%s%s",
0,
&thisNodeFormat,
plContext),
PKIX_ERRORCREATINGFORMATSTRING);
PKIX_CHECK(PKIX_PL_Sprintf
(&resultString,
plContext,
thisNodeFormat,
indent,
thisItemString),
PKIX_ERRORINSPRINTF);
}
else {
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
"%s",
0,
&thisNodeFormat,
plContext),
PKIX_ERRORCREATINGFORMATSTRING);
PKIX_CHECK(PKIX_PL_Sprintf
(&resultString,
plContext,
thisNodeFormat,
thisItemString),
PKIX_ERRORINSPRINTF);
}
PKIX_DECREF(thisItemString);
thisItemString = resultString;
/* if no children, we are done */
if (rootNode->children) {
PKIX_CHECK(PKIX_List_GetLength
(rootNode->children, &numberOfChildren, plContext),
PKIX_LISTGETLENGTHFAILED);
}
if (numberOfChildren != 0) {
/*
* We create a string for each child in turn,
* concatenating them to thisItemString.
*/
/* Prepare an indent string for each child */
if (indent) {
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
"%s. ",
0,
&nextIndentFormat,
plContext),
PKIX_ERRORCREATINGFORMATSTRING);
PKIX_CHECK(PKIX_PL_Sprintf
(&nextIndentString,
plContext,
nextIndentFormat,
indent),
PKIX_ERRORINSPRINTF);
}
else {
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
". ",
0,
&nextIndentString,
plContext),
PKIX_ERRORCREATINGINDENTSTRING);
}
/* Prepare the format for concatenation. */
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
"%s\n%s",
0,
&childrenFormat,
plContext),
PKIX_ERRORCREATINGFORMATSTRING);
for (childIndex = 0;
childIndex < numberOfChildren;
childIndex++) {
PKIX_CHECK(PKIX_List_GetItem
(rootNode->children,
childIndex,
(PKIX_PL_Object **)&childNode,
plContext),
PKIX_LISTGETITEMFAILED);
PKIX_CHECK(pkix_VerifyNode_ToString_Helper
(childNode,
nextIndentString,
&childString,
plContext),
PKIX_ERRORCREATINGCHILDSTRING);
PKIX_CHECK(PKIX_PL_Sprintf
(&resultString,
plContext,
childrenFormat,
thisItemString,
childString),
PKIX_ERRORINSPRINTF);
PKIX_DECREF(childNode);
PKIX_DECREF(childString);
PKIX_DECREF(thisItemString);
thisItemString = resultString;
}
}
*pTreeString = thisItemString;
cleanup:
if (PKIX_ERROR_RECEIVED) {
PKIX_DECREF(thisItemString);
}
PKIX_DECREF(nextIndentFormat);
PKIX_DECREF(thisNodeFormat);
PKIX_DECREF(childrenFormat);
PKIX_DECREF(nextIndentString);
PKIX_DECREF(childString);
PKIX_DECREF(childNode);
PKIX_RETURN(VERIFYNODE);
}
/*
* 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_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_SingleVerifyNode_Hashcode
* DESCRIPTION:
*
* Computes the hashcode of the attributes of the VerifyNode pointed to by
* "node", other than its parents and children, and stores the result at
* "pHashcode".
*
* PARAMETERS:
* "node"
* Address of VerifyNode to be hashcoded; must be non-NULL
* "pHashcode"
* Address where UInt32 result will be stored; must be non-NULL
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Conditionally Thread Safe
* (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if function succeeds
* Returns a VerifyNode Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in a fatal way
*/
static PKIX_Error *
pkix_SingleVerifyNode_Hashcode(
PKIX_VerifyNode *node,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_UInt32 errorHash = 0;
PKIX_UInt32 nodeHash = 0;
PKIX_ENTER(VERIFYNODE,
"pkix_SingleVerifyNode_Hashcode");
PKIX_NULLCHECK_TWO(node, pHashcode);
PKIX_HASHCODE
(node->verifyCert,
&nodeHash,
plContext,
PKIX_FAILUREHASHINGCERT);
PKIX_CHECK(PKIX_PL_Object_Hashcode
((PKIX_PL_Object *)node->error,
&errorHash,
plContext),
PKIX_FAILUREHASHINGERROR);
nodeHash = 31*nodeHash + errorHash;
*pHashcode = nodeHash;
cleanup:
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_VerifyNode_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_VerifyNode_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_VerifyNode *node = NULL;
PKIX_UInt32 childrenHash = 0;
PKIX_UInt32 nodeHash = 0;
PKIX_ENTER(VERIFYNODE,
"pkix_VerifyNode_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType
(object, PKIX_VERIFYNODE_TYPE, plContext),
PKIX_OBJECTNOTVERIFYNODE);
node = (PKIX_VerifyNode *)object;
PKIX_CHECK(pkix_SingleVerifyNode_Hashcode
(node, &nodeHash, plContext),
PKIX_SINGLEVERIFYNODEHASHCODEFAILED);
PKIX_HASHCODE
(node->children,
&childrenHash,
plContext,
PKIX_OBJECTHASHCODEFAILED);
nodeHash = 31*nodeHash + childrenHash;
*pHashcode = nodeHash;
cleanup:
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: pkix_SingleVerifyNode_Equals
* DESCRIPTION:
*
* Compares for equality the components of the VerifyNode pointed to by
* "firstPN", other than its parents and children, with those of the
* VerifyNode pointed to by "secondPN" and stores the result at "pResult"
* (PKIX_TRUE if equal; PKIX_FALSE if not).
*
* PARAMETERS:
* "firstPN"
* Address of first of the VerifyNodes to be compared; must be non-NULL
* "secondPN"
* Address of second of the VerifyNodes to be compared; must be non-NULL
* "pResult"
* Address where Boolean will be stored; must be non-NULL
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Conditionally Thread Safe
* (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if function succeeds
* Returns a VerifyNode Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in a fatal way
*/
static PKIX_Error *
pkix_SingleVerifyNode_Equals(
PKIX_VerifyNode *firstVN,
PKIX_VerifyNode *secondVN,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_Boolean compResult = PKIX_FALSE;
PKIX_ENTER(VERIFYNODE,
"pkix_SingleVerifyNode_Equals");
PKIX_NULLCHECK_THREE(firstVN, secondVN, pResult);
/* If both references are identical, they must be equal */
if (firstVN == secondVN) {
compResult = PKIX_TRUE;
goto cleanup;
}
/*
* It seems we have to do the comparisons. Do
* the easiest ones first.
*/
if ((firstVN->depth) != (secondVN->depth)) {
goto cleanup;
}
/* These fields must be non-NULL */
PKIX_NULLCHECK_TWO(firstVN->verifyCert, secondVN->verifyCert);
PKIX_EQUALS
(firstVN->verifyCert,
secondVN->verifyCert,
&compResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (compResult == PKIX_FALSE) {
goto cleanup;
}
PKIX_EQUALS
(firstVN->error,
secondVN->error,
&compResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
cleanup:
*pResult = compResult;
PKIX_RETURN(VERIFYNODE);
}
/*
* 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_VerifyNode_DuplicateHelper
* DESCRIPTION:
*
* Duplicates the VerifyNode whose address is pointed to by "original",
* and stores the result at "pNewNode", if a non-NULL pointer is provided
* for "pNewNode". In addition, the created VerifyNode is added as a child
* to "parent", if a non-NULL pointer is provided for "parent". Then this
* function is called recursively to duplicate each of the children of
* "original". At the top level this function is called with a null
* "parent" and a non-NULL "pNewNode". Below the top level "parent" will
* be non-NULL and "pNewNode" will be NULL.
*
* PARAMETERS:
* "original"
* Address of VerifyNode to be copied; must be non-NULL
* "parent"
* Address of VerifyNode to which the created node is to be added as a
* child; NULL for the top-level call and non-NULL below the top level
* "pNewNode"
* Address to store the node created; should be NULL if "parent" is
* non-NULL and vice versa
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Conditionally Thread Safe
* (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if function succeeds
* Returns a VerifyNode Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in a fatal way
*/
static PKIX_Error *
pkix_VerifyNode_DuplicateHelper(
PKIX_VerifyNode *original,
PKIX_VerifyNode *parent,
PKIX_VerifyNode **pNewNode,
void *plContext)
{
PKIX_UInt32 numChildren = 0;
PKIX_UInt32 childIndex = 0;
PKIX_List *children = NULL;
/* List of PKIX_VerifyNode */
PKIX_VerifyNode *copy = NULL;
PKIX_VerifyNode *child = NULL;
PKIX_ENTER(VERIFYNODE,
"pkix_VerifyNode_DuplicateHelper");
PKIX_NULLCHECK_TWO
(original, original->verifyCert);
/*
* These components are immutable, so copying the pointers
* is sufficient. The create function increments the reference
* counts as it stores the pointers into the new object.
*/
PKIX_CHECK(pkix_VerifyNode_Create
(original->verifyCert,
original->depth,
original->error,
©,
plContext),
PKIX_VERIFYNODECREATEFAILED);
/* Are there any children to duplicate? */
children = original->children;
if (children) {
PKIX_CHECK(PKIX_List_GetLength(children, &numChildren, plContext),
PKIX_LISTGETLENGTHFAILED);
}
for (childIndex = 0; childIndex < numChildren; childIndex++) {
PKIX_CHECK(PKIX_List_GetItem
(children,
childIndex,
(PKIX_PL_Object **)&child,
plContext),
PKIX_LISTGETITEMFAILED);
PKIX_CHECK(pkix_VerifyNode_DuplicateHelper
(child, copy, NULL, plContext),
PKIX_VERIFYNODEDUPLICATEHELPERFAILED);
PKIX_DECREF(child);
}
if (pNewNode) {
*pNewNode = copy;
copy = NULL;
/* no DecRef if we give our handle away */
}
cleanup:
PKIX_DECREF(copy);
PKIX_DECREF(child);
PKIX_RETURN(VERIFYNODE);
}
/*
* 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_RegisterSelf
* DESCRIPTION:
*
* Registers PKIX_VERIFYNODE_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_VerifyNode_RegisterSelf(
void *plContext)
{
extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
pkix_ClassTable_Entry entry;
PKIX_ENTER(VERIFYNODE,
"pkix_VerifyNode_RegisterSelf");
entry.description =
"VerifyNode";
entry.objCounter = 0;
entry.typeObjectSize =
sizeof(PKIX_VerifyNode);
entry.destructor = pkix_VerifyNode_Destroy;
entry.equalsFunction = pkix_VerifyNode_Equals;
entry.hashcodeFunction = pkix_VerifyNode_Hashcode;
entry.toStringFunction = pkix_VerifyNode_ToString;
entry.comparator = NULL;
entry.duplicateFunction = pkix_VerifyNode_Duplicate;
systemClasses[PKIX_VERIFYNODE_TYPE] = entry;
PKIX_RETURN(VERIFYNODE);
}
/* --Public-VerifyNode-Functions----------------------------------- */
/*
* FUNCTION: PKIX_VerifyNode_SetError
* DESCRIPTION:
*
* This function sets the Error field of the VerifyNode pointed to by "node"
* to contain the Error pointed to by "error".
*
* PARAMETERS:
* "node"
* The address of the VerifyNode to be modified. Must be non-NULL.
* "error"
* The address of the Error to be stored.
* "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_VerifyNode_SetError(
PKIX_VerifyNode *node,
PKIX_Error *error,
void *plContext)
{
PKIX_ENTER(VERIFYNODE,
"PKIX_VerifyNode_SetError");
PKIX_NULLCHECK_TWO(node, error);
PKIX_DECREF(node->error);
/* should have been NULL */
PKIX_INCREF(error);
node->error = error;
cleanup:
PKIX_RETURN(VERIFYNODE);
}
/*
* FUNCTION: PKIX_VerifyNode_FindError
* DESCRIPTION:
*
* Finds meaningful error in the log. For now, just returns the first
* error it finds in. In the future the function should be changed to
* return a top priority error.
*
* PARAMETERS:
* "node"
* The address of the VerifyNode to be modified. Must be non-NULL.
* "error"
* The address of a pointer the error will be returned to.
* "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_VerifyNode_FindError(
PKIX_VerifyNode *node,
PKIX_Error **error,
void *plContext)
{
PKIX_VerifyNode *childNode = NULL;
PKIX_ENTER(VERIFYNODE,
"PKIX_VerifyNode_FindError");
/* Make sure the return address is initialized with NULL */
PKIX_DECREF(*error);
if (!node)
goto cleanup;
/* First, try to get error from lowest level. */
if (node->children) {
PKIX_UInt32 length = 0;
PKIX_UInt32 index = 0;
PKIX_CHECK(
PKIX_List_GetLength(node->children, &length,
plContext),
PKIX_LISTGETLENGTHFAILED);
for (index = 0;index < length;index++) {
PKIX_CHECK(
PKIX_List_GetItem(node->children, index,
(PKIX_PL_Object**)&childNode, plContext),
PKIX_LISTGETITEMFAILED);
if (!childNode)
continue;
PKIX_CHECK(
pkix_VerifyNode_FindError(childNode, error,
plContext),
PKIX_VERIFYNODEFINDERRORFAILED);
PKIX_DECREF(childNode);
if (*error) {
goto cleanup;
}
}
}
if (node->error && node->error->plErr) {
PKIX_INCREF(node->error);
*error = node->error;
}
cleanup:
PKIX_DECREF(childNode);
PKIX_RETURN(VERIFYNODE);
}
