Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(1318)

Unified Diff: lib/libpkix/pkix_pl_nss/system/pkix_pl_object.c

Issue 201830043: Bug 1118245 - Apply uniform style across NSS
Patch Set: Created 9 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « lib/libpkix/pkix_pl_nss/system/pkix_pl_object.h ('k') | lib/libpkix/pkix_pl_nss/system/pkix_pl_oid.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: lib/libpkix/pkix_pl_nss/system/pkix_pl_object.c
===================================================================
old mode 100755
new mode 100644
--- a/lib/libpkix/pkix_pl_nss/system/pkix_pl_object.c
+++ b/lib/libpkix/pkix_pl_nss/system/pkix_pl_object.c
@@ -14,31 +14,29 @@
/* --Class-Table-Initializers------------------------------------ */
/*
* Create storage space for 20 Class Table buckets.
* These are only for user-defined types. System types are registered
* separately by PKIX_PL_Initialize.
*/
-static pkix_pl_HT_Elem*
-pkix_Raw_ClassTable_Buckets[] = {
- NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
- NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
-};
+static pkix_pl_HT_Elem *pkix_Raw_ClassTable_Buckets[] = {
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
/*
* Allocate static memory for a ClassTable.
* XXX This assumes the bucket pointer will fit into a PKIX_UInt32
*/
static pkix_pl_PrimHashTable pkix_Raw_ClassTable = {
- (void *)pkix_Raw_ClassTable_Buckets, /* Buckets */
- 20 /* Number of Buckets */
+ (void *)pkix_Raw_ClassTable_Buckets, /* Buckets */
+ 20 /* Number of Buckets */
};
-static pkix_pl_PrimHashTable * classTable = &pkix_Raw_ClassTable;
+static pkix_pl_PrimHashTable *classTable = &pkix_Raw_ClassTable;
#endif /* PKIX_USER_OBJECT_TYPE */
/* --Private-Functions-------------------------------------------- */
/*
* FUNCTION: pkix_pl_Object_GetHeader
* DESCRIPTION:
*
@@ -53,79 +51,71 @@ static pkix_pl_PrimHashTable * classTabl
* "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_pl_Object_GetHeader(
- PKIX_PL_Object *object,
- PKIX_PL_Object **pObjectHeader,
- void *plContext)
-{
- PKIX_PL_Object *header = NULL;
- PKIX_UInt32 objType;
+static PKIX_Error *pkix_pl_Object_GetHeader(PKIX_PL_Object *object,
+ PKIX_PL_Object **pObjectHeader,
+ void *plContext) {
+ PKIX_PL_Object *header = NULL;
+ PKIX_UInt32 objType;
- PKIX_ENTER(OBJECT, "pkix_pl_Object_GetHeader");
- PKIX_NULLCHECK_TWO(object, pObjectHeader);
+ PKIX_ENTER(OBJECT, "pkix_pl_Object_GetHeader");
+ PKIX_NULLCHECK_TWO(object, pObjectHeader);
- PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");
+ PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");
- /* The header is sizeof(PKIX_PL_Object) before the object pointer */
- header = (PKIX_PL_Object *)((char *)object - sizeof(PKIX_PL_Object));
+ /* The header is sizeof(PKIX_PL_Object) before the object pointer */
+ header = (PKIX_PL_Object *)((char *)object - sizeof(PKIX_PL_Object));
- objType = header->type;
+ objType = header->type;
- if (objType >= PKIX_NUMTYPES) { /* if this is a user-defined type */
+ if (objType >= PKIX_NUMTYPES) {/* if this is a user-defined type */
#ifdef PKIX_USER_OBJECT_TYPE
- pkix_ClassTable_Entry *ctEntry = NULL;
+ pkix_ClassTable_Entry *ctEntry = NULL;
- PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
- PR_Lock(classTableLock);
+ PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
+ PR_Lock(classTableLock);
- PKIX_CHECK(pkix_pl_PrimHashTable_Lookup
- (classTable,
- (void *)&objType,
- objType,
- NULL,
- (void **)&ctEntry,
- plContext),
- PKIX_ERRORGETTINGCLASSTABLEENTRY);
+ PKIX_CHECK(
+ pkix_pl_PrimHashTable_Lookup(classTable, (void *)&objType, objType,
+ NULL, (void **)&ctEntry, plContext),
+ PKIX_ERRORGETTINGCLASSTABLEENTRY);
- PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
- PR_Unlock(classTableLock);
+ PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
+ PR_Unlock(classTableLock);
- if (ctEntry == NULL) {
- PKIX_ERROR_FATAL(PKIX_UNKNOWNOBJECTTYPE);
- }
+ if (ctEntry == NULL) {
+ PKIX_ERROR_FATAL(PKIX_UNKNOWNOBJECTTYPE);
+ }
#else
- PORT_Assert(objType < PKIX_NUMTYPES);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(objType < PKIX_NUMTYPES);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- }
+ }
#ifdef PKIX_OBJECT_LEAK_TEST
- PORT_Assert(header && header->magicHeader == PKIX_MAGIC_HEADER);
+ PORT_Assert(header && header->magicHeader == PKIX_MAGIC_HEADER);
#endif /* PKIX_OBJECT_LEAK_TEST */
- if ((header == NULL)||
- (header->magicHeader != PKIX_MAGIC_HEADER)) {
- PKIX_ERROR_ALLOC_ERROR();
- }
+ if ((header == NULL) || (header->magicHeader != PKIX_MAGIC_HEADER)) {
+ PKIX_ERROR_ALLOC_ERROR();
+ }
- *pObjectHeader = header;
+ *pObjectHeader = header;
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: pkix_Destroy_Object
* DESCRIPTION:
*
* Destroys and deallocates Object pointed to by "object". The caller is
* assumed to hold the Object's lock, which is acquired in
@@ -137,61 +127,58 @@ cleanup:
* "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_pl_Object_Destroy(
- PKIX_PL_Object *object,
- void *plContext)
-{
- PKIX_PL_Object *objectHeader = NULL;
+static PKIX_Error *pkix_pl_Object_Destroy(PKIX_PL_Object *object,
+ void *plContext) {
+ PKIX_PL_Object *objectHeader = NULL;
- PKIX_ENTER(OBJECT, "pkix_pl_Object_Destroy");
- PKIX_NULLCHECK_ONE(object);
+ PKIX_ENTER(OBJECT, "pkix_pl_Object_Destroy");
+ PKIX_NULLCHECK_ONE(object);
#ifdef PKIX_OBJECT_LEAK_TEST
- PKIX_CHECK_FATAL(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ PKIX_CHECK_FATAL(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
#else
- PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
#endif /* PKIX_OBJECT_LEAK_TEST */
- /* Attempt to delete an object still being used */
- if (objectHeader->references != 0) {
- PKIX_ERROR_FATAL(PKIX_OBJECTSTILLREFERENCED);
- }
+ /* Attempt to delete an object still being used */
+ if (objectHeader->references != 0) {
+ PKIX_ERROR_FATAL(PKIX_OBJECTSTILLREFERENCED);
+ }
- PKIX_DECREF(objectHeader->stringRep);
+ PKIX_DECREF(objectHeader->stringRep);
- /* Destroy this object's lock */
- PKIX_OBJECT_DEBUG("\tCalling PR_DestroyLock).\n");
- PR_DestroyLock(objectHeader->lock);
- objectHeader->lock = NULL;
- object = NULL;
+ /* Destroy this object's lock */
+ PKIX_OBJECT_DEBUG("\tCalling PR_DestroyLock).\n");
+ PR_DestroyLock(objectHeader->lock);
+ objectHeader->lock = NULL;
+ object = NULL;
- objectHeader->magicHeader = PKIX_MAGIC_HEADER_DESTROYED;
+ objectHeader->magicHeader = PKIX_MAGIC_HEADER_DESTROYED;
#ifdef PKIX_OBJECT_LEAK_TEST
- memset(objectHeader, 0xbf, systemClasses[PKIX_OBJECT_TYPE].typeObjectSize);
+ memset(objectHeader, 0xbf, systemClasses[PKIX_OBJECT_TYPE].typeObjectSize);
#endif
- PKIX_FREE(objectHeader);
+ PKIX_FREE(objectHeader);
cleanup:
#ifdef PKIX_OBJECT_LEAK_TEST
fatal:
#endif
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/* --Default-Callbacks-------------------------------------------- */
/*
* FUNCTION: pkix_pl_Object_Equals_Default
* DESCRIPTION:
*
@@ -209,30 +196,27 @@ fatal:
* "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_pl_Object_Equals_Default(
- PKIX_PL_Object *firstObject,
- PKIX_PL_Object *secondObject,
- PKIX_Boolean *pResult,
- void *plContext)
-{
- PKIX_ENTER(OBJECT, "pkix_pl_Object_Equals_Default");
- PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
+static PKIX_Error *pkix_pl_Object_Equals_Default(PKIX_PL_Object *firstObject,
+ PKIX_PL_Object *secondObject,
+ PKIX_Boolean *pResult,
+ void *plContext) {
+ PKIX_ENTER(OBJECT, "pkix_pl_Object_Equals_Default");
+ PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
- /* Just compare pointer values */
- *pResult = (firstObject == secondObject)?PKIX_TRUE:PKIX_FALSE;
+ /* Just compare pointer values */
+ *pResult = (firstObject == secondObject) ? PKIX_TRUE : PKIX_FALSE;
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* 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
@@ -248,100 +232,81 @@ pkix_pl_Object_Equals_Default(
* 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;
+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_ENTER(OBJECT, "pkix_pl_Object_ToString_Default");
+ PKIX_NULLCHECK_TWO(object, pString);
- PKIX_CHECK(PKIX_PL_Object_GetType(object, &objType, plContext),
- PKIX_OBJECTGETTYPEFAILED);
+ PKIX_CHECK(PKIX_PL_Object_GetType(object, &objType, plContext),
+ PKIX_OBJECTGETTYPEFAILED);
- if (objType >= PKIX_NUMTYPES){
+ if (objType >= PKIX_NUMTYPES) {
#ifdef PKIX_USER_OBJECT_TYPE
- pkix_ClassTable_Entry *ctEntry = NULL;
+ 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);
- }
+ 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";
- }
- }
+ 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;
+ 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);
+ } 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_String_Create(PKIX_ESCASCII, (void *)description, 0,
+ &descString, plContext),
+ PKIX_STRINGCREATEFAILED);
- PKIX_CHECK(PKIX_PL_Sprintf
- (pString,
- plContext,
- formatString,
- descString,
- object),
- PKIX_SPRINTFFAILED);
+ PKIX_CHECK(
+ PKIX_PL_Sprintf(pString, plContext, formatString, descString, object),
+ PKIX_SPRINTFFAILED);
cleanup:
- PKIX_DECREF(formatString);
- PKIX_DECREF(descString);
+ PKIX_DECREF(formatString);
+ PKIX_DECREF(descString);
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: pkix_pl_Object_Hashcode_Default
* DESCRIPTION:
*
* Default Object_Hashcode callback. Creates the a hashcode value using the
* address of the Object pointed to by "object" and stores the result at
@@ -357,28 +322,25 @@ cleanup:
* "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_pl_Object_Hashcode_Default(
- PKIX_PL_Object *object,
- PKIX_UInt32 *pValue,
- void *plContext)
-{
- PKIX_ENTER(OBJECT, "pkix_pl_Object_Hashcode_Default");
- PKIX_NULLCHECK_TWO(object, pValue);
+static PKIX_Error *pkix_pl_Object_Hashcode_Default(PKIX_PL_Object *object,
+ PKIX_UInt32 *pValue,
+ void *plContext) {
+ PKIX_ENTER(OBJECT, "pkix_pl_Object_Hashcode_Default");
+ PKIX_NULLCHECK_TWO(object, pValue);
- *pValue = (PKIX_UInt32)object;
+ *pValue = (PKIX_UInt32)object;
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: pkix_pl_Object_RetrieveEqualsCallback
* DESCRIPTION:
*
* Retrieves Equals callback function of Object pointed to by "object and
* stores it at "pEqualsCallback". If the object's type is one of the system
@@ -396,1045 +358,911 @@ pkix_pl_Object_Hashcode_Default(
* 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.
*/
-PKIX_Error *
-pkix_pl_Object_RetrieveEqualsCallback(
- PKIX_PL_Object *object,
- PKIX_PL_EqualsCallback *pEqualsCallback,
- void *plContext)
-{
- PKIX_PL_Object *objectHeader = NULL;
- PKIX_PL_EqualsCallback func = NULL;
- pkix_ClassTable_Entry entry;
- PKIX_UInt32 objType;
+PKIX_Error *pkix_pl_Object_RetrieveEqualsCallback(
+ PKIX_PL_Object *object, PKIX_PL_EqualsCallback *pEqualsCallback,
+ void *plContext) {
+ PKIX_PL_Object *objectHeader = NULL;
+ PKIX_PL_EqualsCallback func = NULL;
+ pkix_ClassTable_Entry entry;
+ PKIX_UInt32 objType;
- PKIX_ENTER(OBJECT, "pkix_pl_Object_RetrieveEqualsCallback");
- PKIX_NULLCHECK_TWO(object, pEqualsCallback);
+ PKIX_ENTER(OBJECT, "pkix_pl_Object_RetrieveEqualsCallback");
+ PKIX_NULLCHECK_TWO(object, pEqualsCallback);
- PKIX_CHECK(pkix_pl_Object_GetHeader
- (object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- objType = objectHeader->type;
+ objType = objectHeader->type;
- if (objType >= PKIX_NUMTYPES){
+ if (objType >= PKIX_NUMTYPES) {
#ifdef PKIX_USER_OBJECT_TYPE
- pkix_ClassTable_Entry *ctEntry = NULL;
+ 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(PKIX_ERRORGETTINGCLASSTABLEENTRY);
- }
+ 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(PKIX_ERRORGETTINGCLASSTABLEENTRY);
+ }
- if ((ctEntry == NULL) || (ctEntry->equalsFunction == NULL)) {
- PKIX_ERROR(PKIX_UNDEFINEDEQUALSCALLBACK);
- } else {
- *pEqualsCallback = ctEntry->equalsFunction;
- }
+ if ((ctEntry == NULL) || (ctEntry->equalsFunction == NULL)) {
+ PKIX_ERROR(PKIX_UNDEFINEDEQUALSCALLBACK);
+ } else {
+ *pEqualsCallback = ctEntry->equalsFunction;
+ }
#else
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- } else {
- entry = systemClasses[objType];
- func = entry.equalsFunction;
- if (func == NULL){
- func = pkix_pl_Object_Equals_Default;
- }
- *pEqualsCallback = func;
- }
+ } else {
+ entry = systemClasses[objType];
+ func = entry.equalsFunction;
+ if (func == NULL) {
+ func = pkix_pl_Object_Equals_Default;
+ }
+ *pEqualsCallback = func;
+ }
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: pkix_pl_Object_RegisterSelf
* DESCRIPTION:
* Registers PKIX_OBJECT_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_PL_Object should have all function pointes to be to NULL: they
* work as proxy function to a real objects.
- *
+ *
*/
-PKIX_Error *
-pkix_pl_Object_RegisterSelf(void *plContext)
-{
- pkix_ClassTable_Entry entry;
+PKIX_Error *pkix_pl_Object_RegisterSelf(void *plContext) {
+ pkix_ClassTable_Entry entry;
- PKIX_ENTER(ERROR, "pkix_pl_Object_RegisterSelf");
+ PKIX_ENTER(ERROR, "pkix_pl_Object_RegisterSelf");
- entry.description = "Object";
- entry.objCounter = 0;
- entry.typeObjectSize = sizeof(PKIX_PL_Object);
- entry.destructor = NULL;
- entry.equalsFunction = NULL;
- entry.hashcodeFunction = NULL;
- entry.toStringFunction = NULL;
- entry.comparator = NULL;
- entry.duplicateFunction = NULL;
+ entry.description = "Object";
+ entry.objCounter = 0;
+ entry.typeObjectSize = sizeof(PKIX_PL_Object);
+ entry.destructor = NULL;
+ entry.equalsFunction = NULL;
+ entry.hashcodeFunction = NULL;
+ entry.toStringFunction = NULL;
+ entry.comparator = NULL;
+ entry.duplicateFunction = NULL;
- systemClasses[PKIX_OBJECT_TYPE] = entry;
+ systemClasses[PKIX_OBJECT_TYPE] = entry;
- PKIX_RETURN(ERROR);
+ PKIX_RETURN(ERROR);
}
/* --Public-Functions------------------------------------------------------- */
/*
* FUNCTION: PKIX_PL_Object_Alloc (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_Alloc(
- PKIX_TYPENUM objType,
- PKIX_UInt32 size,
- PKIX_PL_Object **pObject,
- void *plContext)
-{
- PKIX_PL_Object *object = NULL;
- pkix_ClassTable_Entry *ctEntry = NULL;
+PKIX_Error *PKIX_PL_Object_Alloc(PKIX_TYPENUM objType, PKIX_UInt32 size,
+ PKIX_PL_Object **pObject, void *plContext) {
+ PKIX_PL_Object *object = NULL;
+ pkix_ClassTable_Entry *ctEntry = NULL;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_Alloc");
- PKIX_NULLCHECK_ONE(pObject);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_Alloc");
+ PKIX_NULLCHECK_ONE(pObject);
- /*
- * We need to ensure that user-defined types have been registered.
- * All system types have already been registered by PKIX_PL_Initialize.
- */
+ /*
+ * We need to ensure that user-defined types have been registered.
+ * All system types have already been registered by PKIX_PL_Initialize.
+ */
- if (objType >= PKIX_NUMTYPES) { /* i.e. if this is a user-defined type */
+ if (objType >= PKIX_NUMTYPES) {/* i.e. if this is a user-defined type */
#ifdef PKIX_USER_OBJECT_TYPE
- PKIX_Boolean typeRegistered;
- 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_COULDNOTLOOKUPINHASHTABLE);
- }
+ PKIX_Boolean typeRegistered;
+ 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_COULDNOTLOOKUPINHASHTABLE);
+ }
- typeRegistered = (ctEntry != NULL);
+ typeRegistered = (ctEntry != NULL);
- if (!typeRegistered) {
- PKIX_ERROR_FATAL(PKIX_UNKNOWNTYPEARGUMENT);
- }
+ if (!typeRegistered) {
+ PKIX_ERROR_FATAL(PKIX_UNKNOWNTYPEARGUMENT);
+ }
#else
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- } else {
- ctEntry = &systemClasses[objType];
- }
-
- PORT_Assert(size == ctEntry->typeObjectSize);
+ } else {
+ ctEntry = &systemClasses[objType];
+ }
- /* Allocate space for the object header and the requested size */
-#ifdef PKIX_OBJECT_LEAK_TEST
- PKIX_CHECK(PKIX_PL_Calloc
- (1,
- ((PKIX_UInt32)sizeof (PKIX_PL_Object))+size,
- (void **)&object,
- plContext),
- PKIX_MALLOCFAILED);
+ PORT_Assert(size == ctEntry->typeObjectSize);
+
+/* Allocate space for the object header and the requested size */
+#ifdef PKIX_OBJECT_LEAK_TEST
+ PKIX_CHECK(PKIX_PL_Calloc(1, ((PKIX_UInt32)sizeof(PKIX_PL_Object)) + size,
+ (void **)&object, plContext),
+ PKIX_MALLOCFAILED);
#else
- PKIX_CHECK(PKIX_PL_Malloc
- (((PKIX_UInt32)sizeof (PKIX_PL_Object))+size,
- (void **)&object,
- plContext),
- PKIX_MALLOCFAILED);
+ PKIX_CHECK(PKIX_PL_Malloc(((PKIX_UInt32)sizeof(PKIX_PL_Object)) + size,
+ (void **)&object, plContext),
+ PKIX_MALLOCFAILED);
#endif /* PKIX_OBJECT_LEAK_TEST */
- /* Initialize all object fields */
- object->magicHeader = PKIX_MAGIC_HEADER;
- object->type = objType;
- object->references = 1; /* Default to a single reference */
- object->stringRep = NULL;
- object->hashcode = 0;
- object->hashcodeCached = 0;
+ /* Initialize all object fields */
+ object->magicHeader = PKIX_MAGIC_HEADER;
+ object->type = objType;
+ object->references = 1; /* Default to a single reference */
+ object->stringRep = NULL;
+ object->hashcode = 0;
+ object->hashcodeCached = 0;
- /* Cannot use PKIX_PL_Mutex because it depends on Object */
- /* Using NSPR Locks instead */
- PKIX_OBJECT_DEBUG("\tCalling PR_NewLock).\n");
- object->lock = PR_NewLock();
- if (object->lock == NULL) {
- PKIX_ERROR_ALLOC_ERROR();
- }
+ /* Cannot use PKIX_PL_Mutex because it depends on Object */
+ /* Using NSPR Locks instead */
+ PKIX_OBJECT_DEBUG("\tCalling PR_NewLock).\n");
+ object->lock = PR_NewLock();
+ if (object->lock == NULL) {
+ PKIX_ERROR_ALLOC_ERROR();
+ }
- PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");
+ PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");
+ /* Return a pointer to the user data. Need to offset by object size */
+ *pObject = object + 1;
+ object = NULL;
- /* Return a pointer to the user data. Need to offset by object size */
- *pObject = object + 1;
- object = NULL;
-
- /* Atomically increment object counter */
- PR_ATOMIC_INCREMENT(&ctEntry->objCounter);
+ /* Atomically increment object counter */
+ PR_ATOMIC_INCREMENT(&ctEntry->objCounter);
cleanup:
- PKIX_FREE(object);
+ PKIX_FREE(object);
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_IsTypeRegistered (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_IsTypeRegistered(
- PKIX_UInt32 objType,
- PKIX_Boolean *pBool,
- void *plContext)
-{
+PKIX_Error *PKIX_PL_Object_IsTypeRegistered(PKIX_UInt32 objType,
+ PKIX_Boolean *pBool,
+ void *plContext) {
#ifdef PKIX_USER_OBJECT_TYPE
- pkix_ClassTable_Entry *ctEntry = NULL;
+ pkix_ClassTable_Entry *ctEntry = NULL;
#endif
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_IsTypeRegistered");
- PKIX_NULLCHECK_ONE(pBool);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_IsTypeRegistered");
+ PKIX_NULLCHECK_ONE(pBool);
- /* first, we handle the system types */
- if (objType < PKIX_NUMTYPES) {
- *pBool = PKIX_TRUE;
- goto cleanup;
- }
+ /* first, we handle the system types */
+ if (objType < PKIX_NUMTYPES) {
+ *pBool = PKIX_TRUE;
+ goto cleanup;
+ }
#ifndef PKIX_USER_OBJECT_TYPE
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
#else
- 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);
+ 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_COULDNOTLOOKUPINHASHTABLE);
- }
+ if (pkixErrorResult) {
+ PKIX_ERROR_FATAL(PKIX_COULDNOTLOOKUPINHASHTABLE);
+ }
- *pBool = (ctEntry != NULL);
+ *pBool = (ctEntry != NULL);
#endif /* PKIX_USER_OBJECT_TYPE */
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
#ifdef PKIX_USER_OBJECT_TYPE
/*
* FUNCTION: PKIX_PL_Object_RegisterType (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_RegisterType(
- PKIX_UInt32 objType,
- char *description,
- PKIX_PL_DestructorCallback destructor,
- PKIX_PL_EqualsCallback equalsFunction,
- PKIX_PL_HashcodeCallback hashcodeFunction,
- PKIX_PL_ToStringCallback toStringFunction,
- PKIX_PL_ComparatorCallback comparator,
- PKIX_PL_DuplicateCallback duplicateFunction,
- void *plContext)
-{
- pkix_ClassTable_Entry *ctEntry = NULL;
- pkix_pl_Integer *key = NULL;
+PKIX_Error *PKIX_PL_Object_RegisterType(
+ PKIX_UInt32 objType, char *description,
+ PKIX_PL_DestructorCallback destructor,
+ PKIX_PL_EqualsCallback equalsFunction,
+ PKIX_PL_HashcodeCallback hashcodeFunction,
+ PKIX_PL_ToStringCallback toStringFunction,
+ PKIX_PL_ComparatorCallback comparator,
+ PKIX_PL_DuplicateCallback duplicateFunction, void *plContext) {
+ pkix_ClassTable_Entry *ctEntry = NULL;
+ pkix_pl_Integer *key = NULL;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_RegisterType");
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_RegisterType");
- /*
- * System types are registered on startup by PKIX_PL_Initialize.
- * These can not be overwritten.
- */
+ /*
+ * System types are registered on startup by PKIX_PL_Initialize.
+ * These can not be overwritten.
+ */
- if (objType < PKIX_NUMTYPES) { /* if this is a system type */
- PKIX_ERROR(PKIX_CANTREREGISTERSYSTEMTYPE);
- }
+ if (objType < PKIX_NUMTYPES) {/* if this is a system type */
+ PKIX_ERROR(PKIX_CANTREREGISTERSYSTEMTYPE);
+ }
- PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
- PR_Lock(classTableLock);
- PKIX_CHECK(pkix_pl_PrimHashTable_Lookup
- (classTable,
- (void *)&objType,
- objType,
- NULL,
- (void **)&ctEntry,
- plContext),
- PKIX_PRIMHASHTABLELOOKUPFAILED);
+ PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
+ PR_Lock(classTableLock);
+ PKIX_CHECK(pkix_pl_PrimHashTable_Lookup(classTable, (void *)&objType, objType,
+ NULL, (void **)&ctEntry, plContext),
+ PKIX_PRIMHASHTABLELOOKUPFAILED);
- /* If the type is already registered, throw an error */
- if (ctEntry) {
- PKIX_ERROR(PKIX_TYPEALREADYREGISTERED);
- }
+ /* If the type is already registered, throw an error */
+ if (ctEntry) {
+ PKIX_ERROR(PKIX_TYPEALREADYREGISTERED);
+ }
- PKIX_CHECK(PKIX_PL_Malloc
- (((PKIX_UInt32)sizeof (pkix_ClassTable_Entry)),
- (void **)&ctEntry,
- plContext),
- PKIX_MALLOCFAILED);
+ PKIX_CHECK(PKIX_PL_Malloc(((PKIX_UInt32)sizeof(pkix_ClassTable_Entry)),
+ (void **)&ctEntry, plContext),
+ PKIX_MALLOCFAILED);
- /* Set Default Values if none specified */
+ /* Set Default Values if none specified */
- if (description == NULL){
- description = "Object";
- }
+ if (description == NULL) {
+ description = "Object";
+ }
- if (equalsFunction == NULL) {
- equalsFunction = pkix_pl_Object_Equals_Default;
- }
+ if (equalsFunction == NULL) {
+ equalsFunction = pkix_pl_Object_Equals_Default;
+ }
- if (toStringFunction == NULL) {
- toStringFunction = pkix_pl_Object_ToString_Default;
- }
+ if (toStringFunction == NULL) {
+ toStringFunction = pkix_pl_Object_ToString_Default;
+ }
- if (hashcodeFunction == NULL) {
- hashcodeFunction = pkix_pl_Object_Hashcode_Default;
- }
+ if (hashcodeFunction == NULL) {
+ hashcodeFunction = pkix_pl_Object_Hashcode_Default;
+ }
- ctEntry->destructor = destructor;
- ctEntry->equalsFunction = equalsFunction;
- ctEntry->toStringFunction = toStringFunction;
- ctEntry->hashcodeFunction = hashcodeFunction;
- ctEntry->comparator = comparator;
- ctEntry->duplicateFunction = duplicateFunction;
- ctEntry->description = description;
+ ctEntry->destructor = destructor;
+ ctEntry->equalsFunction = equalsFunction;
+ ctEntry->toStringFunction = toStringFunction;
+ ctEntry->hashcodeFunction = hashcodeFunction;
+ ctEntry->comparator = comparator;
+ ctEntry->duplicateFunction = duplicateFunction;
+ ctEntry->description = description;
- PKIX_CHECK(PKIX_PL_Malloc
- (((PKIX_UInt32)sizeof (pkix_pl_Integer)),
- (void **)&key,
- plContext),
- PKIX_COULDNOTMALLOCNEWKEY);
+ PKIX_CHECK(PKIX_PL_Malloc(((PKIX_UInt32)sizeof(pkix_pl_Integer)),
+ (void **)&key, plContext),
+ PKIX_COULDNOTMALLOCNEWKEY);
- key->ht_int = objType;
+ key->ht_int = objType;
- PKIX_CHECK(pkix_pl_PrimHashTable_Add
- (classTable,
- (void *)key,
- (void *)ctEntry,
- objType,
- NULL,
- plContext),
- PKIX_PRIMHASHTABLEADDFAILED);
+ PKIX_CHECK(pkix_pl_PrimHashTable_Add(classTable, (void *)key, (void *)ctEntry,
+ objType, NULL, plContext),
+ PKIX_PRIMHASHTABLEADDFAILED);
cleanup:
- PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
- PR_Unlock(classTableLock);
+ PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
+ PR_Unlock(classTableLock);
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
#endif /* PKIX_USER_OBJECT_TYPE */
/*
* FUNCTION: PKIX_PL_Object_IncRef (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_IncRef(
- PKIX_PL_Object *object,
- void *plContext)
-{
- PKIX_PL_Object *objectHeader = NULL;
- PKIX_PL_NssContext *context = NULL;
- PKIX_Int32 refCount = 0;
+PKIX_Error *PKIX_PL_Object_IncRef(PKIX_PL_Object *object, void *plContext) {
+ PKIX_PL_Object *objectHeader = NULL;
+ PKIX_PL_NssContext *context = NULL;
+ PKIX_Int32 refCount = 0;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_IncRef");
- PKIX_NULLCHECK_ONE(object);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_IncRef");
+ PKIX_NULLCHECK_ONE(object);
- if (plContext){
- /*
- * PKIX_PL_NssContext is not a complete PKIX Type, it doesn't
- * have a header therefore we cannot verify its type before
- * casting.
- */
- context = (PKIX_PL_NssContext *) plContext;
- if (context->arena != NULL) {
- goto cleanup;
- }
- }
+ if (plContext) {
+ /*
+ * PKIX_PL_NssContext is not a complete PKIX Type, it doesn't
+ * have a header therefore we cannot verify its type before
+ * casting.
+ */
+ context = (PKIX_PL_NssContext *)plContext;
+ if (context->arena != NULL) {
+ goto cleanup;
+ }
+ }
- if (object == (PKIX_PL_Object*)PKIX_ALLOC_ERROR()) {
- goto cleanup;
- }
+ if (object == (PKIX_PL_Object *)PKIX_ALLOC_ERROR()) {
+ goto cleanup;
+ }
- /* Shift pointer from user data to object header */
- PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ /* Shift pointer from user data to object header */
+ PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- /* This object should never have zero references */
- refCount = PR_ATOMIC_INCREMENT(&objectHeader->references);
+ /* This object should never have zero references */
+ refCount = PR_ATOMIC_INCREMENT(&objectHeader->references);
- if (refCount <= 1) {
- PKIX_THROW(FATAL, PKIX_OBJECTWITHNONPOSITIVEREFERENCES);
- }
+ if (refCount <= 1) {
+ PKIX_THROW(FATAL, PKIX_OBJECTWITHNONPOSITIVEREFERENCES);
+ }
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_DecRef (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_DecRef(
- PKIX_PL_Object *object,
- void *plContext)
-{
- PKIX_Int32 refCount = 0;
- PKIX_PL_Object *objectHeader = NULL;
- PKIX_PL_NssContext *context = NULL;
-
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_DecRef");
- PKIX_NULLCHECK_ONE(object);
+PKIX_Error *PKIX_PL_Object_DecRef(PKIX_PL_Object *object, void *plContext) {
+ PKIX_Int32 refCount = 0;
+ PKIX_PL_Object *objectHeader = NULL;
+ PKIX_PL_NssContext *context = NULL;
- if (plContext){
- /*
- * PKIX_PL_NssContext is not a complete PKIX Type, it doesn't
- * have a header therefore we cannot verify its type before
- * casting.
- */
- context = (PKIX_PL_NssContext *) plContext;
- if (context->arena != NULL) {
- goto cleanup;
- }
- }
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_DecRef");
+ PKIX_NULLCHECK_ONE(object);
- if (object == (PKIX_PL_Object*)PKIX_ALLOC_ERROR()) {
- goto cleanup;
- }
+ if (plContext) {
+ /*
+ * PKIX_PL_NssContext is not a complete PKIX Type, it doesn't
+ * have a header therefore we cannot verify its type before
+ * casting.
+ */
+ context = (PKIX_PL_NssContext *)plContext;
+ if (context->arena != NULL) {
+ goto cleanup;
+ }
+ }
- /* Shift pointer from user data to object header */
- PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ if (object == (PKIX_PL_Object *)PKIX_ALLOC_ERROR()) {
+ goto cleanup;
+ }
- refCount = PR_ATOMIC_DECREMENT(&objectHeader->references);
+ /* Shift pointer from user data to object header */
+ PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- if (refCount == 0) {
- PKIX_PL_DestructorCallback destructor = NULL;
- pkix_ClassTable_Entry *ctEntry = NULL;
- PKIX_UInt32 objType = objectHeader->type;
-
- /* first, special handling for system types */
- if (objType >= PKIX_NUMTYPES){
+ refCount = PR_ATOMIC_DECREMENT(&objectHeader->references);
+
+ if (refCount == 0) {
+ PKIX_PL_DestructorCallback destructor = NULL;
+ pkix_ClassTable_Entry *ctEntry = NULL;
+ PKIX_UInt32 objType = objectHeader->type;
+
+ /* first, special handling for system types */
+ if (objType >= PKIX_NUMTYPES) {
#ifdef PKIX_USER_OBJECT_TYPE
- 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_ERRORINGETTINGDESTRUCTOR);
- }
-
- if (ctEntry != NULL){
- destructor = ctEntry->destructor;
- }
+ 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_ERRORINGETTINGDESTRUCTOR);
+ }
+
+ if (ctEntry != NULL) {
+ destructor = ctEntry->destructor;
+ }
#else
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- } else {
- ctEntry = &systemClasses[objType];
- destructor = ctEntry->destructor;
- }
-
- if (destructor != NULL){
- /* Call destructor on user data if necessary */
- pkixErrorResult = destructor(object, plContext);
- if (pkixErrorResult) {
- pkixErrorClass = PKIX_FATAL_ERROR;
- PKIX_DoAddError(stdVarsPtr, pkixErrorResult, plContext);
- pkixErrorResult = NULL;
- }
- }
-
- /* Atomically decrement object counter */
- PR_ATOMIC_DECREMENT(&ctEntry->objCounter);
-
- /* pkix_pl_Object_Destroy assumes the lock is held */
- /* It will call unlock and destroy the object */
- pkixErrorResult = pkix_pl_Object_Destroy(object, plContext);
- goto cleanup;
- }
+ } else {
+ ctEntry = &systemClasses[objType];
+ destructor = ctEntry->destructor;
+ }
- if (refCount < 0) {
- PKIX_ERROR_ALLOC_ERROR();
- }
+ if (destructor != NULL) {
+ /* Call destructor on user data if necessary */
+ pkixErrorResult = destructor(object, plContext);
+ if (pkixErrorResult) {
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ PKIX_DoAddError(stdVarsPtr, pkixErrorResult, plContext);
+ pkixErrorResult = NULL;
+ }
+ }
+
+ /* Atomically decrement object counter */
+ PR_ATOMIC_DECREMENT(&ctEntry->objCounter);
+
+ /* pkix_pl_Object_Destroy assumes the lock is held */
+ /* It will call unlock and destroy the object */
+ pkixErrorResult = pkix_pl_Object_Destroy(object, plContext);
+ goto cleanup;
+ }
+
+ if (refCount < 0) {
+ PKIX_ERROR_ALLOC_ERROR();
+ }
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
-
-
/*
* FUNCTION: PKIX_PL_Object_Equals (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_Equals(
- PKIX_PL_Object *firstObject,
- PKIX_PL_Object *secondObject,
- PKIX_Boolean *pResult,
- void *plContext)
-{
- PKIX_PL_Object *firstObjectHeader = NULL;
- PKIX_PL_Object *secondObjectHeader = NULL;
- PKIX_PL_EqualsCallback func = NULL;
- pkix_ClassTable_Entry entry;
- PKIX_UInt32 objType;
+PKIX_Error *PKIX_PL_Object_Equals(PKIX_PL_Object *firstObject,
+ PKIX_PL_Object *secondObject,
+ PKIX_Boolean *pResult, void *plContext) {
+ PKIX_PL_Object *firstObjectHeader = NULL;
+ PKIX_PL_Object *secondObjectHeader = NULL;
+ PKIX_PL_EqualsCallback func = NULL;
+ pkix_ClassTable_Entry entry;
+ PKIX_UInt32 objType;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_Equals");
- PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_Equals");
+ PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
- PKIX_CHECK(pkix_pl_Object_GetHeader
- (firstObject, &firstObjectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ PKIX_CHECK(
+ pkix_pl_Object_GetHeader(firstObject, &firstObjectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- PKIX_CHECK(pkix_pl_Object_GetHeader
- (secondObject, &secondObjectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ PKIX_CHECK(
+ pkix_pl_Object_GetHeader(secondObject, &secondObjectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- /* if hashcodes are cached but not equal, objects can't be equal */
- if (firstObjectHeader->hashcodeCached &&
- secondObjectHeader->hashcodeCached){
- if (firstObjectHeader->hashcode !=
- secondObjectHeader->hashcode){
- *pResult = PKIX_FALSE;
- goto cleanup;
- }
- }
+ /* if hashcodes are cached but not equal, objects can't be equal */
+ if (firstObjectHeader->hashcodeCached && secondObjectHeader->hashcodeCached) {
+ if (firstObjectHeader->hashcode != secondObjectHeader->hashcode) {
+ *pResult = PKIX_FALSE;
+ goto cleanup;
+ }
+ }
- objType = firstObjectHeader->type;
+ objType = firstObjectHeader->type;
- if (objType >= PKIX_NUMTYPES) {
+ 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 *)&firstObjectHeader->type,
- firstObjectHeader->type,
- NULL,
- (void **)&ctEntry,
- plContext);
- PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
- PR_Unlock(classTableLock);
+ pkix_ClassTable_Entry *ctEntry = NULL;
+ PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
+ PR_Lock(classTableLock);
+ pkixErrorResult = pkix_pl_PrimHashTable_Lookup(
+ classTable, (void *)&firstObjectHeader->type, firstObjectHeader->type,
+ NULL, (void **)&ctEntry, plContext);
+ PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
+ PR_Unlock(classTableLock);
- if (pkixErrorResult){
- PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY);
- }
+ if (pkixErrorResult) {
+ PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY);
+ }
- if ((ctEntry == NULL) || (ctEntry->equalsFunction == NULL)) {
- PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK);
- } else {
- func = ctEntry->equalsFunction;
- }
+ if ((ctEntry == NULL) || (ctEntry->equalsFunction == NULL)) {
+ PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK);
+ } else {
+ func = ctEntry->equalsFunction;
+ }
#else
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- } else {
- entry = systemClasses[objType];
- func = entry.equalsFunction;
- if (func == NULL){
- func = pkix_pl_Object_Equals_Default;
- }
- }
+ } else {
+ entry = systemClasses[objType];
+ func = entry.equalsFunction;
+ if (func == NULL) {
+ func = pkix_pl_Object_Equals_Default;
+ }
+ }
- PKIX_CHECK(func(firstObject, secondObject, pResult, plContext),
- PKIX_OBJECTSPECIFICFUNCTIONFAILED);
+ PKIX_CHECK(func(firstObject, secondObject, pResult, plContext),
+ PKIX_OBJECTSPECIFICFUNCTIONFAILED);
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_Duplicate (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_Duplicate(
- PKIX_PL_Object *firstObject,
- PKIX_PL_Object **pNewObject,
- void *plContext)
-{
- PKIX_PL_Object *firstObjectHeader = NULL;
- PKIX_PL_DuplicateCallback func = NULL;
- pkix_ClassTable_Entry entry;
- PKIX_UInt32 objType;
+PKIX_Error *PKIX_PL_Object_Duplicate(PKIX_PL_Object *firstObject,
+ PKIX_PL_Object **pNewObject,
+ void *plContext) {
+ PKIX_PL_Object *firstObjectHeader = NULL;
+ PKIX_PL_DuplicateCallback func = NULL;
+ pkix_ClassTable_Entry entry;
+ PKIX_UInt32 objType;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_Duplicate");
- PKIX_NULLCHECK_TWO(firstObject, pNewObject);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_Duplicate");
+ PKIX_NULLCHECK_TWO(firstObject, pNewObject);
- PKIX_CHECK(pkix_pl_Object_GetHeader
- (firstObject, &firstObjectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ PKIX_CHECK(
+ pkix_pl_Object_GetHeader(firstObject, &firstObjectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- objType = firstObjectHeader->type;
+ objType = firstObjectHeader->type;
- if (objType >= PKIX_NUMTYPES) {
+ if (objType >= PKIX_NUMTYPES) {
#ifdef PKIX_USER_OBJECT_TYPE
- pkix_ClassTable_Entry *ctEntry = NULL;
+ 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);
+ 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 (pkixErrorResult) {
+ PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY);
+ }
- if ((ctEntry == NULL) || (ctEntry->duplicateFunction == NULL)) {
- PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK);
- } else {
- func = ctEntry->duplicateFunction;
- }
+ if ((ctEntry == NULL) || (ctEntry->duplicateFunction == NULL)) {
+ PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK);
+ } else {
+ func = ctEntry->duplicateFunction;
+ }
#else
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- } else {
- entry = systemClasses[objType];
- func = entry.duplicateFunction;
- if (!func){
- PKIX_ERROR_FATAL(PKIX_UNDEFINEDDUPLICATEFUNCTION);
- }
- }
+ } else {
+ entry = systemClasses[objType];
+ func = entry.duplicateFunction;
+ if (!func) {
+ PKIX_ERROR_FATAL(PKIX_UNDEFINEDDUPLICATEFUNCTION);
+ }
+ }
- PKIX_CHECK(func(firstObject, pNewObject, plContext),
- PKIX_OBJECTSPECIFICFUNCTIONFAILED);
+ PKIX_CHECK(func(firstObject, pNewObject, plContext),
+ PKIX_OBJECTSPECIFICFUNCTIONFAILED);
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_Hashcode (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_Hashcode(
- PKIX_PL_Object *object,
- PKIX_UInt32 *pValue,
- void *plContext)
-{
- PKIX_PL_Object *objectHeader = NULL;
- PKIX_PL_HashcodeCallback func = NULL;
- pkix_ClassTable_Entry entry;
- PKIX_UInt32 objectHash;
+PKIX_Error *PKIX_PL_Object_Hashcode(PKIX_PL_Object *object, PKIX_UInt32 *pValue,
+ void *plContext) {
+ PKIX_PL_Object *objectHeader = NULL;
+ PKIX_PL_HashcodeCallback func = NULL;
+ pkix_ClassTable_Entry entry;
+ PKIX_UInt32 objectHash;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_Hashcode");
- PKIX_NULLCHECK_TWO(object, pValue);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_Hashcode");
+ PKIX_NULLCHECK_TWO(object, pValue);
- /* Shift pointer from user data to object header */
- PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ /* Shift pointer from user data to object header */
+ PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- /* if we don't have a cached copy from before, we create one */
- if (!objectHeader->hashcodeCached){
+ /* if we don't have a cached copy from before, we create one */
+ if (!objectHeader->hashcodeCached) {
- PKIX_UInt32 objType = objectHeader->type;
+ PKIX_UInt32 objType = objectHeader->type;
- /* first, special handling for system types */
- if (objType >= PKIX_NUMTYPES){
-#ifdef PKIX_USER_OBJECT_TYPE
- pkix_ClassTable_Entry *ctEntry = NULL;
+ /* first, special handling for system types */
+ 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);
+ 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 (pkixErrorResult) {
+ PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY);
+ }
- if ((ctEntry == NULL) ||
- (ctEntry->hashcodeFunction == NULL)) {
- PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK);
- }
+ if ((ctEntry == NULL) || (ctEntry->hashcodeFunction == NULL)) {
+ PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK);
+ }
- func = ctEntry->hashcodeFunction;
+ func = ctEntry->hashcodeFunction;
#else
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- } else {
- entry = systemClasses[objType];
- func = entry.hashcodeFunction;
- if (func == NULL){
- func = pkix_pl_Object_Hashcode_Default;
- }
- }
+ } else {
+ entry = systemClasses[objType];
+ func = entry.hashcodeFunction;
+ if (func == NULL) {
+ func = pkix_pl_Object_Hashcode_Default;
+ }
+ }
- PKIX_CHECK(func(object, &objectHash, plContext),
- PKIX_OBJECTSPECIFICFUNCTIONFAILED);
+ PKIX_CHECK(func(object, &objectHash, plContext),
+ PKIX_OBJECTSPECIFICFUNCTIONFAILED);
- if (!objectHeader->hashcodeCached){
+ if (!objectHeader->hashcodeCached) {
- PKIX_CHECK(pkix_LockObject(object, plContext),
- PKIX_ERRORLOCKINGOBJECT);
+ PKIX_CHECK(pkix_LockObject(object, plContext), PKIX_ERRORLOCKINGOBJECT);
- if (!objectHeader->hashcodeCached){
- /* save cached copy in case we need it again */
- objectHeader->hashcode = objectHash;
- objectHeader->hashcodeCached = PKIX_TRUE;
- }
+ if (!objectHeader->hashcodeCached) {
+ /* save cached copy in case we need it again */
+ objectHeader->hashcode = objectHash;
+ objectHeader->hashcodeCached = PKIX_TRUE;
+ }
- PKIX_CHECK(pkix_UnlockObject(object, plContext),
- PKIX_ERRORUNLOCKINGOBJECT);
- }
- }
+ PKIX_CHECK(pkix_UnlockObject(object, plContext),
+ PKIX_ERRORUNLOCKINGOBJECT);
+ }
+ }
- *pValue = objectHeader->hashcode;
+ *pValue = objectHeader->hashcode;
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_ToString (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_ToString(
- PKIX_PL_Object *object,
- PKIX_PL_String **pString,
- void *plContext)
-{
- PKIX_PL_Object *objectHeader = NULL;
- PKIX_PL_ToStringCallback func = NULL;
- pkix_ClassTable_Entry entry;
- PKIX_PL_String *objectString = NULL;
+PKIX_Error *PKIX_PL_Object_ToString(PKIX_PL_Object *object,
+ PKIX_PL_String **pString, void *plContext) {
+ PKIX_PL_Object *objectHeader = NULL;
+ PKIX_PL_ToStringCallback func = NULL;
+ pkix_ClassTable_Entry entry;
+ PKIX_PL_String *objectString = NULL;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_ToString");
- PKIX_NULLCHECK_TWO(object, pString);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_ToString");
+ PKIX_NULLCHECK_TWO(object, pString);
- /* Shift pointer from user data to object header */
- PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ /* Shift pointer from user data to object header */
+ PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- /* if we don't have a cached copy from before, we create one */
- if (!objectHeader->stringRep){
+ /* if we don't have a cached copy from before, we create one */
+ if (!objectHeader->stringRep) {
- PKIX_UInt32 objType = objectHeader->type;
+ PKIX_UInt32 objType = objectHeader->type;
- if (objType >= PKIX_NUMTYPES){
+ if (objType >= PKIX_NUMTYPES) {
#ifdef PKIX_USER_OBJECT_TYPE
- pkix_ClassTable_Entry *ctEntry = NULL;
+ 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);
- }
+ 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) ||
- (ctEntry->toStringFunction == NULL)) {
- PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK);
- }
+ if ((ctEntry == NULL) || (ctEntry->toStringFunction == NULL)) {
+ PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK);
+ }
- func = ctEntry->toStringFunction;
+ func = ctEntry->toStringFunction;
#else
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- } else {
- entry = systemClasses[objType];
- func = entry.toStringFunction;
- if (func == NULL){
- func = pkix_pl_Object_ToString_Default;
- }
- }
+ } else {
+ entry = systemClasses[objType];
+ func = entry.toStringFunction;
+ if (func == NULL) {
+ func = pkix_pl_Object_ToString_Default;
+ }
+ }
- PKIX_CHECK(func(object, &objectString, plContext),
- PKIX_OBJECTSPECIFICFUNCTIONFAILED);
+ PKIX_CHECK(func(object, &objectString, plContext),
+ PKIX_OBJECTSPECIFICFUNCTIONFAILED);
- if (!objectHeader->stringRep){
+ if (!objectHeader->stringRep) {
- PKIX_CHECK(pkix_LockObject(object, plContext),
- PKIX_ERRORLOCKINGOBJECT);
+ PKIX_CHECK(pkix_LockObject(object, plContext), PKIX_ERRORLOCKINGOBJECT);
- if (!objectHeader->stringRep){
- /* save a cached copy */
- objectHeader->stringRep = objectString;
- objectString = NULL;
- }
+ if (!objectHeader->stringRep) {
+ /* save a cached copy */
+ objectHeader->stringRep = objectString;
+ objectString = NULL;
+ }
- PKIX_CHECK(pkix_UnlockObject(object, plContext),
- PKIX_ERRORUNLOCKINGOBJECT);
- }
- }
+ PKIX_CHECK(pkix_UnlockObject(object, plContext),
+ PKIX_ERRORUNLOCKINGOBJECT);
+ }
+ }
-
- *pString = objectHeader->stringRep;
- objectHeader->stringRep = NULL;
+ *pString = objectHeader->stringRep;
+ objectHeader->stringRep = NULL;
cleanup:
- if (objectHeader) {
- PKIX_DECREF(objectHeader->stringRep);
- }
- PKIX_DECREF(objectString);
+ if (objectHeader) {
+ PKIX_DECREF(objectHeader->stringRep);
+ }
+ PKIX_DECREF(objectString);
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_InvalidateCache (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_InvalidateCache(
- PKIX_PL_Object *object,
- void *plContext)
-{
- PKIX_PL_Object *objectHeader = NULL;
+PKIX_Error *PKIX_PL_Object_InvalidateCache(PKIX_PL_Object *object,
+ void *plContext) {
+ PKIX_PL_Object *objectHeader = NULL;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_InvalidateCache");
- PKIX_NULLCHECK_ONE(object);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_InvalidateCache");
+ PKIX_NULLCHECK_ONE(object);
- /* Shift pointer from user data to object header */
- PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ /* Shift pointer from user data to object header */
+ PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- PKIX_CHECK(pkix_LockObject(object, plContext),
- PKIX_ERRORLOCKINGOBJECT);
+ PKIX_CHECK(pkix_LockObject(object, plContext), PKIX_ERRORLOCKINGOBJECT);
- /* invalidate hashcode */
- objectHeader->hashcode = 0;
- objectHeader->hashcodeCached = PKIX_FALSE;
+ /* invalidate hashcode */
+ objectHeader->hashcode = 0;
+ objectHeader->hashcodeCached = PKIX_FALSE;
- PKIX_DECREF(objectHeader->stringRep);
+ PKIX_DECREF(objectHeader->stringRep);
- PKIX_CHECK(pkix_UnlockObject(object, plContext),
- PKIX_ERRORUNLOCKINGOBJECT);
+ PKIX_CHECK(pkix_UnlockObject(object, plContext), PKIX_ERRORUNLOCKINGOBJECT);
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_Compare (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_Compare(
- PKIX_PL_Object *firstObject,
- PKIX_PL_Object *secondObject,
- PKIX_Int32 *pResult,
- void *plContext)
-{
- PKIX_PL_Object *firstObjectHeader = NULL;
- PKIX_PL_Object *secondObjectHeader = NULL;
- PKIX_PL_ComparatorCallback func = NULL;
- pkix_ClassTable_Entry entry;
- PKIX_UInt32 objType;
+PKIX_Error *PKIX_PL_Object_Compare(PKIX_PL_Object *firstObject,
+ PKIX_PL_Object *secondObject,
+ PKIX_Int32 *pResult, void *plContext) {
+ PKIX_PL_Object *firstObjectHeader = NULL;
+ PKIX_PL_Object *secondObjectHeader = NULL;
+ PKIX_PL_ComparatorCallback func = NULL;
+ pkix_ClassTable_Entry entry;
+ PKIX_UInt32 objType;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_Compare");
- PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_Compare");
+ PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
- /* Shift pointer from user data to object header */
- PKIX_CHECK(pkix_pl_Object_GetHeader
- (firstObject, &firstObjectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ /* Shift pointer from user data to object header */
+ PKIX_CHECK(
+ pkix_pl_Object_GetHeader(firstObject, &firstObjectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- /* Shift pointer from user data to object header */
- PKIX_CHECK(pkix_pl_Object_GetHeader
- (secondObject, &secondObjectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ /* Shift pointer from user data to object header */
+ PKIX_CHECK(
+ pkix_pl_Object_GetHeader(secondObject, &secondObjectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- objType = firstObjectHeader->type;
+ objType = firstObjectHeader->type;
- if (objType >= PKIX_NUMTYPES){
+ if (objType >= PKIX_NUMTYPES) {
#ifdef PKIX_USER_OBJECT_TYPE
- pkix_ClassTable_Entry *ctEntry = NULL;
+ 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);
- }
+ 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) || (ctEntry->comparator == NULL)) {
- PKIX_ERROR_FATAL(PKIX_UNDEFINEDCOMPARATOR);
- }
+ if ((ctEntry == NULL) || (ctEntry->comparator == NULL)) {
+ PKIX_ERROR_FATAL(PKIX_UNDEFINEDCOMPARATOR);
+ }
- func = ctEntry->comparator;
+ func = ctEntry->comparator;
#else
- PORT_Assert (0);
- pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
- pkixErrorClass = PKIX_FATAL_ERROR;
- goto cleanup;
+ PORT_Assert(0);
+ pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
+ pkixErrorClass = PKIX_FATAL_ERROR;
+ goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
- } else {
- /* special handling for system types */
- entry = systemClasses[objType];
- func = entry.comparator;
- if (!func){
- PKIX_ERROR(PKIX_UNDEFINEDCOMPARATOR);
- }
- }
+ } else {
+ /* special handling for system types */
+ entry = systemClasses[objType];
+ func = entry.comparator;
+ if (!func) {
+ PKIX_ERROR(PKIX_UNDEFINEDCOMPARATOR);
+ }
+ }
- PKIX_CHECK(func(firstObject, secondObject, pResult, plContext),
- PKIX_OBJECTSPECIFICFUNCTIONFAILED);
+ PKIX_CHECK(func(firstObject, secondObject, pResult, plContext),
+ PKIX_OBJECTSPECIFICFUNCTIONFAILED);
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_Lock (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_Lock(
- PKIX_PL_Object *object,
- void *plContext)
-{
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_Lock");
- PKIX_NULLCHECK_ONE(object);
+PKIX_Error *PKIX_PL_Object_Lock(PKIX_PL_Object *object, void *plContext) {
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_Lock");
+ PKIX_NULLCHECK_ONE(object);
- PKIX_CHECK(pkix_LockObject(object, plContext),
- PKIX_LOCKOBJECTFAILED);
+ PKIX_CHECK(pkix_LockObject(object, plContext), PKIX_LOCKOBJECTFAILED);
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_Unlock (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_Unlock(
- PKIX_PL_Object *object,
- void *plContext)
-{
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_Unlock");
- PKIX_NULLCHECK_ONE(object);
+PKIX_Error *PKIX_PL_Object_Unlock(PKIX_PL_Object *object, void *plContext) {
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_Unlock");
+ PKIX_NULLCHECK_ONE(object);
- PKIX_CHECK(pkix_UnlockObject(object, plContext),
- PKIX_UNLOCKOBJECTFAILED);
+ PKIX_CHECK(pkix_UnlockObject(object, plContext), PKIX_UNLOCKOBJECTFAILED);
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
-
/*
* FUNCTION: PKIX_PL_Object_GetType (see comments in pkix_pl_system.h)
*/
-PKIX_Error *
-PKIX_PL_Object_GetType(
- PKIX_PL_Object *object,
- PKIX_UInt32 *pType,
- void *plContext)
-{
- PKIX_PL_Object *objectHeader = NULL;
+PKIX_Error *PKIX_PL_Object_GetType(PKIX_PL_Object *object, PKIX_UInt32 *pType,
+ void *plContext) {
+ PKIX_PL_Object *objectHeader = NULL;
- PKIX_ENTER(OBJECT, "PKIX_PL_Object_GetType");
- PKIX_NULLCHECK_TWO(object, pType);
+ PKIX_ENTER(OBJECT, "PKIX_PL_Object_GetType");
+ PKIX_NULLCHECK_TWO(object, pType);
- /* Shift pointer from user data to object header */
- PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
- PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
+ /* Shift pointer from user data to object header */
+ PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),
+ PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT);
- *pType = objectHeader->type;
+ *pType = objectHeader->type;
cleanup:
- PKIX_RETURN(OBJECT);
+ PKIX_RETURN(OBJECT);
}
« no previous file with comments | « lib/libpkix/pkix_pl_nss/system/pkix_pl_object.h ('k') | lib/libpkix/pkix_pl_nss/system/pkix_pl_oid.h » ('j') | no next file with comments »

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b