Bug Summary

File:s/lib/libpkix/pkix_pl_nss/system/pkix_pl_object.c
Warning:line 274, column 21
The left operand of '>=' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pkix_pl_object.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/nss/lib/libpkix/pkix_pl_nss/system -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/nss/lib/libpkix/pkix_pl_nss/system -resource-dir /usr/lib/llvm-22/lib/clang/22 -D HAVE_STRERROR -D LINUX -D linux -D XP_UNIX -D XP_UNIX -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D NSS_DISABLE_SSE3 -D NSS_NO_INIT_SUPPORT -D USE_UTIL_DIRECTLY -D NO_NSPR_10_SUPPORT -D SSL_DISABLE_DEPRECATED_CIPHER_SUITE_NAMES -I ../../../../../dist/Linux6.1_x86_64_gcc_glibc_PTH_64_DBG.OBJ/include -I ../../../../../dist/public/nss -I ../../../../../dist/private/nss -internal-isystem /usr/lib/llvm-22/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=c99 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-11-18-221358-3012168-1 -x c pkix_pl_object.c
1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4/*
5 * pkix_pl_object.c
6 *
7 * Object Construction, Destruction and Callback Functions
8 *
9 */
10
11#include "pkix_pl_object.h"
12
13#ifdef PKIX_USER_OBJECT_TYPE
14/* --Class-Table-Initializers------------------------------------ */
15
16/*
17 * Create storage space for 20 Class Table buckets.
18 * These are only for user-defined types. System types are registered
19 * separately by PKIX_PL_Initialize.
20 */
21
22static pkix_pl_HT_Elem*
23pkix_Raw_ClassTable_Buckets[] = {
24 NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0),
25 NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)
26};
27
28/*
29 * Allocate static memory for a ClassTable.
30 * XXX This assumes the bucket pointer will fit into a PKIX_UInt32
31 */
32static pkix_pl_PrimHashTable pkix_Raw_ClassTable = {
33 (void *)pkix_Raw_ClassTable_Buckets, /* Buckets */
34 20 /* Number of Buckets */
35};
36static pkix_pl_PrimHashTable * classTable = &pkix_Raw_ClassTable;
37#endif /* PKIX_USER_OBJECT_TYPE */
38
39/* --Private-Functions-------------------------------------------- */
40
41/*
42 * FUNCTION: pkix_pl_Object_GetHeader
43 * DESCRIPTION:
44 *
45 * Shifts Object pointed to by "object" by the sizeof(PKIX_PL_Object) and
46 * stores the value at "pObjectHeader".
47 *
48 * PARAMETERS:
49 * "object"
50 * Address of Object to shift. Must be non-NULL.
51 * "pObjectHeader"
52 * Address where object pointer will be stored. Must be non-NULL.
53 * "plContext"
54 * Platform-specific context pointer.
55 * THREAD SAFETY:
56 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
57 * RETURNS:
58 * Returns NULL if the function succeeds.
59 * Returns a Fatal Error if the function fails in an unrecoverable way.
60 */
61static PKIX_Error *
62pkix_pl_Object_GetHeader(
63 PKIX_PL_Object *object,
64 PKIX_PL_Object **pObjectHeader,
65 void *plContext)
66{
67 PKIX_PL_Object *header = NULL((void*)0);
68 PKIX_UInt32 objType;
69
70 PKIX_ENTER(OBJECT, "pkix_pl_Object_GetHeader")static const char cMyFuncName[] = {"pkix_pl_Object_GetHeader"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
71 PKIX_NULLCHECK_TWO(object, pObjectHeader)do { if (((object) == ((void*)0)) || ((pObjectHeader) == ((void
*)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
72
73 PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");
74
75 /* The header is sizeof(PKIX_PL_Object) before the object pointer */
76 header = (PKIX_PL_Object *)((char *)object - sizeof(PKIX_PL_Object));
77
78 objType = header->type;
79
80 if (objType >= PKIX_NUMTYPES) { /* if this is a user-defined type */
81#ifdef PKIX_USER_OBJECT_TYPE
82 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
83
84 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
85 PR_Lock(classTableLock);
86
87 PKIX_CHECK(pkix_pl_PrimHashTable_Lookupdo { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY; goto
cleanup; } } while (0)
88 (classTable,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY; goto
cleanup; } } while (0)
89 (void *)&objType,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY; goto
cleanup; } } while (0)
90 objType,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY; goto
cleanup; } } while (0)
91 NULL,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY; goto
cleanup; } } while (0)
92 (void **)&ctEntry,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY; goto
cleanup; } } while (0)
93 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY; goto
cleanup; } } while (0)
94 PKIX_ERRORGETTINGCLASSTABLEENTRY)do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY; goto
cleanup; } } while (0);
95
96 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
97 PR_Unlock(classTableLock);
98
99 if (ctEntry == NULL((void*)0)) {
100 PKIX_ERROR_FATAL(PKIX_UNKNOWNOBJECTTYPE){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNKNOWNOBJECTTYPE; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
101 }
102#else
103 PORT_Assert(objType < PKIX_NUMTYPES)((objType < PKIX_NUMTYPES)?((void)0):PR_Assert("objType < PKIX_NUMTYPES"
,"pkix_pl_object.c",103));
104 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
105 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
106 goto cleanup;
107#endif /* PKIX_USER_OBJECT_TYPE */
108 }
109
110#ifdef PKIX_OBJECT_LEAK_TEST
111 PORT_Assert(header && header->magicHeader == PKIX_MAGIC_HEADER)((header && header->magicHeader == 0xFEEDC0FFEEFACADEUL
)?((void)0):PR_Assert("header && header->magicHeader == PKIX_MAGIC_HEADER"
,"pkix_pl_object.c",111));
112#endif /* PKIX_OBJECT_LEAK_TEST */
113
114 if ((header == NULL((void*)0))||
115 (header->magicHeader != PKIX_MAGIC_HEADER0xFEEDC0FFEEFACADEUL)) {
116 PKIX_ERROR_ALLOC_ERROR(){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_ALLOCERROR, ((void*)0), stdVars.aPkixType, 2, plContext
); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorResult = PKIX_ALLOC_ERROR(); goto cleanup; };
117 }
118
119 *pObjectHeader = header;
120
121cleanup:
122
123 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
124}
125
126/*
127 * FUNCTION: pkix_Destroy_Object
128 * DESCRIPTION:
129 *
130 * Destroys and deallocates Object pointed to by "object". The caller is
131 * assumed to hold the Object's lock, which is acquired in
132 * PKIX_PL_Object_DecRef().
133 *
134 * PARAMETERS:
135 * "object"
136 * Address of Object to destroy. Must be non-NULL.
137 * "plContext"
138 * Platform-specific context pointer.
139 * THREAD SAFETY:
140 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
141 * RETURNS:
142 * Returns NULL if the function succeeds.
143 * Returns a Fatal Error if the function fails in an unrecoverable way.
144 */
145static PKIX_Error *
146pkix_pl_Object_Destroy(
147 PKIX_PL_Object *object,
148 void *plContext)
149{
150 PKIX_PL_Object *objectHeader = NULL((void*)0);
151
152 PKIX_ENTER(OBJECT, "pkix_pl_Object_Destroy")static const char cMyFuncName[] = {"pkix_pl_Object_Destroy"};
PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
153 PKIX_NULLCHECK_ONE(object)do { if ((object) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
154
155#ifdef PKIX_OBJECT_LEAK_TEST
156 PKIX_CHECK_FATAL(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.
aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT; stdVars
.aPkixErrorClass = PKIX_FATAL_ERROR; { if (pkixLoggersErrors)
{ pkix_Logger_CheckWithCode(pkixLoggersErrors, stdVars.aPkixErrorCode
, ((void*)0), stdVars.aPkixType, 1, plContext); } }; goto fatal
; } } while (0)
157 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.
aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT; stdVars
.aPkixErrorClass = PKIX_FATAL_ERROR; { if (pkixLoggersErrors)
{ pkix_Logger_CheckWithCode(pkixLoggersErrors, stdVars.aPkixErrorCode
, ((void*)0), stdVars.aPkixType, 1, plContext); } }; goto fatal
; } } while (0);
158#else
159 PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
160 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
161#endif /* PKIX_OBJECT_LEAK_TEST */
162
163 /* Attempt to delete an object still being used */
164 if (objectHeader->references != 0) {
165 PKIX_ERROR_FATAL(PKIX_OBJECTSTILLREFERENCED){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_OBJECTSTILLREFERENCED; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
166 }
167
168 PKIX_DECREF(objectHeader->stringRep)do { if (objectHeader->stringRep){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(objectHeader->
stringRep), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } objectHeader->stringRep = ((void*)0); } }
while (0);
169
170 /* Destroy this object's lock */
171 PKIX_OBJECT_DEBUG("\tCalling PR_DestroyLock).\n");
172 PR_DestroyLock(objectHeader->lock);
173 objectHeader->lock = NULL((void*)0);
174 object = NULL((void*)0);
175
176 objectHeader->magicHeader = PKIX_MAGIC_HEADER_DESTROYED0xBAADF00DDEADBEEFUL;
177
178#ifdef PKIX_OBJECT_LEAK_TEST
179 memset(objectHeader, 0xbf, systemClasses[PKIX_OBJECT_TYPE].typeObjectSize);
180#endif
181
182 PKIX_FREE(objectHeader)do { if (objectHeader) { stdVars.aPkixTempResult = PKIX_PL_Free
((objectHeader), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } objectHeader = ((void*)0); } } while (0);
183
184cleanup:
185#ifdef PKIX_OBJECT_LEAK_TEST
186fatal:
187#endif
188
189 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
190}
191
192/* --Default-Callbacks-------------------------------------------- */
193
194/*
195 * FUNCTION: pkix_pl_Object_Equals_Default
196 * DESCRIPTION:
197 *
198 * Default Object_Equals callback: Compares the address of the Object pointed
199 * to by "firstObject" with the address of the Object pointed to by
200 * "secondObject" and stores the Boolean result at "pResult".
201 *
202 * PARAMETERS:
203 * "firstObject"
204 * Address of first Object to compare. Must be non-NULL.
205 * "secondObject"
206 * Address of second Object to compare. Must be non-NULL.
207 * "pResult"
208 * Address where Boolean result will be stored. Must be non-NULL.
209 * "plContext"
210 * Platform-specific context pointer.
211 * THREAD SAFETY:
212 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
213 * RETURNS:
214 * Returns NULL if the function succeeds.
215 * Returns a Fatal Error if the function fails in an unrecoverable way.
216 */
217static PKIX_Error *
218pkix_pl_Object_Equals_Default(
219 PKIX_PL_Object *firstObject,
220 PKIX_PL_Object *secondObject,
221 PKIX_Boolean *pResult,
222 void *plContext)
223{
224 PKIX_ENTER(OBJECT, "pkix_pl_Object_Equals_Default")static const char cMyFuncName[] = {"pkix_pl_Object_Equals_Default"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
225 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult)do { if (((firstObject) == ((void*)0)) || ((secondObject) == (
(void*)0)) || ((pResult) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
226
227 /* Just compare pointer values */
228 *pResult = (firstObject == secondObject)?PKIX_TRUE((PKIX_Boolean) 1):PKIX_FALSE((PKIX_Boolean) 0);
229
230 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
231}
232
233/*
234 * FUNCTION: pkix_pl_Object_ToString_Default
235 * DESCRIPTION:
236 *
237 * Default Object_ToString callback: Creates a string consisting of the
238 * typename and address of the Object pointed to by "object" and stores
239 * the result at "pString". The format for the string is
240 * "TypeName@Address: <address>", where the default typename is "Object".
241 *
242 * PARAMETERS:
243 * "object"
244 * Address of Object to convert to a string. Must be non-NULL.
245 * "pString"
246 * Address where object pointer will be stored. Must be non-NULL.
247 * "plContext"
248 * Platform-specific context pointer.
249 * THREAD SAFETY:
250 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
251 * RETURNS:
252 * Returns NULL if the function succeeds.
253 * Returns an Object Error if the function fails in a non-fatal way.
254 * Returns a Fatal Error if the function fails in an unrecoverable way.
255 */
256static PKIX_Error *
257pkix_pl_Object_ToString_Default(
258 PKIX_PL_Object *object,
259 PKIX_PL_String **pString,
260 void *plContext)
261{
262 PKIX_PL_String *formatString = NULL((void*)0);
263 PKIX_PL_String *descString = NULL((void*)0);
264 char *format = "%s@Address: %x";
265 char *description = NULL((void*)0);
266 PKIX_UInt32 objType;
18
←
'objType' declared without an initial value
→
267
268 PKIX_ENTER(OBJECT, "pkix_pl_Object_ToString_Default")static const char cMyFuncName[] = {"pkix_pl_Object_ToString_Default"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
19
←
Assuming 'pkixLoggersDebugTrace' is null
→
20
←
Taking false branch
→
269 PKIX_NULLCHECK_TWO(object, pString)do { if (((object) == ((void*)0)) || ((pString) == ((void*)0)
)){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.
aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
21
←
Loop condition is false. Exiting loop
→
22
←
Taking false branch
→
23
←
Loop condition is false. Exiting loop
→
270
271 PKIX_CHECK(PKIX_PL_Object_GetType(object, &objType, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_GetType(object
, &objType, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_OBJECTGETTYPEFAILED; goto cleanup; } }
while (0)
24
←
Calling 'PKIX_PL_Object_GetType'
→
34
←
Returning from 'PKIX_PL_Object_GetType'
→
35
←
Assuming field 'aPkixErrorResult' is null
→
36
←
Taking false branch
→
37
←
Loop condition is false. Exiting loop
→
272 PKIX_OBJECTGETTYPEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_GetType(object
, &objType, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_OBJECTGETTYPEFAILED; goto cleanup; } }
while (0);
273
274 if (objType >= PKIX_NUMTYPES){
38
←
The left operand of '>=' is a garbage value
275#ifdef PKIX_USER_OBJECT_TYPE
276 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
277
278 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
279 PR_Lock(classTableLock);
280 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
281 (classTable,
282 (void *)&objType,
283 objType,
284 NULL((void*)0),
285 (void **)&ctEntry,
286 plContext);
287 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
288 PR_Unlock(classTableLock);
289 if (pkixErrorResultstdVars.aPkixErrorResult){
290 PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORGETTINGCLASSTABLEENTRY; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; };
291 }
292
293 if (ctEntry == NULL((void*)0)){
294 PKIX_ERROR_FATAL(PKIX_UNDEFINEDCLASSTABLEENTRY){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNDEFINEDCLASSTABLEENTRY; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
295 } else {
296 description = ctEntry->description;
297 if (description == NULL((void*)0)) {
298 description = "User Type Object";
299 }
300 }
301#else
302 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",302));
303 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
304 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
305 goto cleanup;
306#endif /* PKIX_USER_OBJECT_TYPE */
307 } else {
308 description = systemClasses[objType].description;
309 }
310 PKIX_CHECK(PKIX_PL_String_Createdo { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)format, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
311 (PKIX_ESCASCII,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)format, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
312 (void *)format,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)format, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
313 0,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)format, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
314 &formatString,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)format, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
315 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)format, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
316 PKIX_STRINGCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)format, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0);
317
318 PKIX_CHECK(PKIX_PL_String_Createdo { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)description, 0, &descString, plContext)); if (stdVars.
aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED
; goto cleanup; } } while (0)
319 (PKIX_ESCASCII,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)description, 0, &descString, plContext)); if (stdVars.
aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED
; goto cleanup; } } while (0)
320 (void *)description,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)description, 0, &descString, plContext)); if (stdVars.
aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED
; goto cleanup; } } while (0)
321 0,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)description, 0, &descString, plContext)); if (stdVars.
aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED
; goto cleanup; } } while (0)
322 &descString,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)description, 0, &descString, plContext)); if (stdVars.
aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED
; goto cleanup; } } while (0)
323 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)description, 0, &descString, plContext)); if (stdVars.
aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED
; goto cleanup; } } while (0)
324 PKIX_STRINGCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)description, 0, &descString, plContext)); if (stdVars.
aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED
; goto cleanup; } } while (0);
325
326 PKIX_CHECK(PKIX_PL_Sprintfdo { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (pString, plContext
, formatString, descString, object)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; }
} while (0)
327 (pString,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (pString, plContext
, formatString, descString, object)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; }
} while (0)
328 plContext,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (pString, plContext
, formatString, descString, object)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; }
} while (0)
329 formatString,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (pString, plContext
, formatString, descString, object)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; }
} while (0)
330 descString,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (pString, plContext
, formatString, descString, object)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; }
} while (0)
331 object),do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (pString, plContext
, formatString, descString, object)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; }
} while (0)
332 PKIX_SPRINTFFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (pString, plContext
, formatString, descString, object)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; }
} while (0);
333
334cleanup:
335
336 PKIX_DECREF(formatString)do { if (formatString){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(formatString), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } formatString = ((void
*)0); } } while (0);
337 PKIX_DECREF(descString)do { if (descString){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(descString), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } descString = ((void
*)0); } } while (0);
338
339 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
340}
341
342/*
343 * FUNCTION: pkix_pl_Object_Hashcode_Default
344 * DESCRIPTION:
345 *
346 * Default Object_Hashcode callback. Creates the a hashcode value using the
347 * address of the Object pointed to by "object" and stores the result at
348 * "pValue".
349 *
350 * XXX This isn't great since addresses are not uniformly distributed.
351 *
352 * PARAMETERS:
353 * "object"
354 * Address of Object to compute hashcode for. Must be non-NULL.
355 * "pValue"
356 * Address where PKIX_UInt32 will be stored. Must be non-NULL.
357 * "plContext"
358 * Platform-specific context pointer.
359 * THREAD SAFETY:
360 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
361 * RETURNS:
362 * Returns NULL if the function succeeds.
363 * Returns a Fatal Error if the function fails in an unrecoverable way.
364 */
365static PKIX_Error *
366pkix_pl_Object_Hashcode_Default(
367 PKIX_PL_Object *object,
368 PKIX_UInt32 *pValue,
369 void *plContext)
370{
371 PKIX_ENTER(OBJECT, "pkix_pl_Object_Hashcode_Default")static const char cMyFuncName[] = {"pkix_pl_Object_Hashcode_Default"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
372 PKIX_NULLCHECK_TWO(object, pValue)do { if (((object) == ((void*)0)) || ((pValue) == ((void*)0))
){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_NULLARGUMENT; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR
), ((PKIX_Boolean) 1), plContext);; } } while (0);
373
374 *pValue = (PKIX_UInt32)((char *)object - (char *)NULL((void*)0));
375
376 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
377}
378
379/*
380 * FUNCTION: pkix_pl_Object_RetrieveEqualsCallback
381 * DESCRIPTION:
382 *
383 * Retrieves Equals callback function of Object pointed to by "object and
384 * stores it at "pEqualsCallback". If the object's type is one of the system
385 * types, its callback function is retrieved from the systemClasses array;
386 * otherwise, its callback function is retrieve from the classTable hash
387 * table where user-defined types are stored.
388 *
389 * PARAMETERS:
390 * "object"
391 * Address of Object whose equals callback is desired. Must be non-NULL.
392 * "pEqualsCallback"
393 * Address where EqualsCallback function pointer will be stored.
394 * Must be non-NULL.
395 * "plContext"
396 * Platform-specific context pointer.
397 * THREAD SAFETY:
398 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
399 * RETURNS:
400 * Returns NULL if the function succeeds.
401 * Returns an Object Error if the function fails in a non-fatal way.
402 * Returns a Fatal Error if the function fails in an unrecoverable way.
403 */
404PKIX_Error *
405pkix_pl_Object_RetrieveEqualsCallback(
406 PKIX_PL_Object *object,
407 PKIX_PL_EqualsCallback *pEqualsCallback,
408 void *plContext)
409{
410 PKIX_PL_Object *objectHeader = NULL((void*)0);
411 PKIX_PL_EqualsCallback func = NULL((void*)0);
412 pkix_ClassTable_Entry entry;
413 PKIX_UInt32 objType;
414
415 PKIX_ENTER(OBJECT, "pkix_pl_Object_RetrieveEqualsCallback")static const char cMyFuncName[] = {"pkix_pl_Object_RetrieveEqualsCallback"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
416 PKIX_NULLCHECK_TWO(object, pEqualsCallback)do { if (((object) == ((void*)0)) || ((pEqualsCallback) == ((
void*)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
417
418 PKIX_CHECK(pkix_pl_Object_GetHeaderdo { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
419 (object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
420 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
421
422 objType = objectHeader->type;
423
424 if (objType >= PKIX_NUMTYPES){
425#ifdef PKIX_USER_OBJECT_TYPE
426 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
427
428 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
429 PR_Lock(classTableLock);
430 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
431 (classTable,
432 (void *)&objType,
433 objType,
434 NULL((void*)0),
435 (void **)&ctEntry,
436 plContext);
437 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
438 PR_Unlock(classTableLock);
439 if (pkixErrorResultstdVars.aPkixErrorResult){
440 PKIX_ERROR(PKIX_ERRORGETTINGCLASSTABLEENTRY){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_ERRORGETTINGCLASSTABLEENTRY, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_ERRORGETTINGCLASSTABLEENTRY
; goto cleanup; };
441 }
442
443 if ((ctEntry == NULL((void*)0)) || (ctEntry->equalsFunction == NULL((void*)0))) {
444 PKIX_ERROR(PKIX_UNDEFINEDEQUALSCALLBACK){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_UNDEFINEDEQUALSCALLBACK, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_UNDEFINEDEQUALSCALLBACK; goto
cleanup; };
445 } else {
446 *pEqualsCallback = ctEntry->equalsFunction;
447 }
448#else
449 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",449));
450 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
451 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
452 goto cleanup;
453#endif /* PKIX_USER_OBJECT_TYPE */
454 } else {
455 entry = systemClasses[objType];
456 func = entry.equalsFunction;
457 if (func == NULL((void*)0)){
458 func = pkix_pl_Object_Equals_Default;
459 }
460 *pEqualsCallback = func;
461 }
462
463cleanup:
464
465 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
466}
467
468/*
469 * FUNCTION: pkix_pl_Object_RegisterSelf
470 * DESCRIPTION:
471 * Registers PKIX_OBJECT_TYPE and its related functions with systemClasses[]
472 * THREAD SAFETY:
473 * Not Thread Safe - for performance and complexity reasons
474 *
475 * Since this function is only called by PKIX_PL_Initialize, which should
476 * only be called once, it is acceptable that this function is not
477 * thread-safe.
478 *
479 * PKIX_PL_Object should have all function pointes to be to NULL: they
480 * work as proxy function to a real objects.
481 *
482 */
483PKIX_Error *
484pkix_pl_Object_RegisterSelf(void *plContext)
485{
486 pkix_ClassTable_Entry entry;
487
488 PKIX_ENTER(ERROR, "pkix_pl_Object_RegisterSelf")static const char cMyFuncName[] = {"pkix_pl_Object_RegisterSelf"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_ERROR_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
489
490 entry.description = "Object";
491 entry.objCounter = 0;
492 entry.typeObjectSize = sizeof(PKIX_PL_Object);
493 entry.destructor = NULL((void*)0);
494 entry.equalsFunction = NULL((void*)0);
495 entry.hashcodeFunction = NULL((void*)0);
496 entry.toStringFunction = NULL((void*)0);
497 entry.comparator = NULL((void*)0);
498 entry.duplicateFunction = NULL((void*)0);
499
500 systemClasses[PKIX_OBJECT_TYPE] = entry;
501
502 PKIX_RETURN(ERROR)return PKIX_DoReturn(&stdVars, (PKIX_ERROR_ERROR), ((PKIX_Boolean
) 1), plContext);;
503}
504
505/* --Public-Functions------------------------------------------------------- */
506
507/*
508 * FUNCTION: PKIX_PL_Object_Alloc (see comments in pkix_pl_system.h)
509 */
510PKIX_Error *
511PKIX_PL_Object_Alloc(
512 PKIX_TYPENUM objType,
513 PKIX_UInt32 size,
514 PKIX_PL_Object **pObject,
515 void *plContext)
516{
517 PKIX_PL_Object *object = NULL((void*)0);
518 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
519
520 PKIX_ENTER(OBJECT, "PKIX_PL_Object_Alloc")static const char cMyFuncName[] = {"PKIX_PL_Object_Alloc"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
521 PKIX_NULLCHECK_ONE(pObject)do { if ((pObject) == ((void*)0)){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
522
523 /*
524 * We need to ensure that user-defined types have been registered.
525 * All system types have already been registered by PKIX_PL_Initialize.
526 */
527
528 if (objType >= PKIX_NUMTYPES) { /* i.e. if this is a user-defined type */
529#ifdef PKIX_USER_OBJECT_TYPE
530 PKIX_Boolean typeRegistered;
531 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
532 PR_Lock(classTableLock);
533 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
534 (classTable,
535 (void *)&objType,
536 objType,
537 NULL((void*)0),
538 (void **)&ctEntry,
539 plContext);
540 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
541 PR_Unlock(classTableLock);
542 if (pkixErrorResultstdVars.aPkixErrorResult){
543 PKIX_ERROR_FATAL(PKIX_COULDNOTLOOKUPINHASHTABLE){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_COULDNOTLOOKUPINHASHTABLE; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
544 }
545
546 typeRegistered = (ctEntry != NULL((void*)0));
547
548 if (!typeRegistered) {
549 PKIX_ERROR_FATAL(PKIX_UNKNOWNTYPEARGUMENT){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNKNOWNTYPEARGUMENT; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
550 }
551#else
552 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",552));
553 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
554 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
555 goto cleanup;
556#endif /* PKIX_USER_OBJECT_TYPE */
557 } else {
558 ctEntry = &systemClasses[objType];
559 }
560
561 PORT_Assert(size == ctEntry->typeObjectSize)((size == ctEntry->typeObjectSize)?((void)0):PR_Assert("size == ctEntry->typeObjectSize"
,"pkix_pl_object.c",561));
562
563 /* Allocate space for the object header and the requested size */
564#ifdef PKIX_OBJECT_LEAK_TEST
565 PKIX_CHECK(PKIX_PL_Callocdo { stdVars.aPkixErrorResult = (PKIX_PL_Calloc (1, ((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
566 (1,do { stdVars.aPkixErrorResult = (PKIX_PL_Calloc (1, ((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
567 ((PKIX_UInt32)sizeof (PKIX_PL_Object))+size,do { stdVars.aPkixErrorResult = (PKIX_PL_Calloc (1, ((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
568 (void **)&object,do { stdVars.aPkixErrorResult = (PKIX_PL_Calloc (1, ((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
569 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Calloc (1, ((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
570 PKIX_MALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Calloc (1, ((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0);
571#else
572 PKIX_CHECK(PKIX_PL_Mallocdo { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
573 (((PKIX_UInt32)sizeof (PKIX_PL_Object))+size,do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
574 (void **)&object,do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
575 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
576 PKIX_MALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (PKIX_PL_Object))+size, (void **)&object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0);
577#endif /* PKIX_OBJECT_LEAK_TEST */
578
579 /* Initialize all object fields */
580 object->magicHeader = PKIX_MAGIC_HEADER0xFEEDC0FFEEFACADEUL;
581 object->type = objType;
582 object->references = 1; /* Default to a single reference */
583 object->stringRep = NULL((void*)0);
584 object->hashcode = 0;
585 object->hashcodeCached = 0;
586
587 /* Cannot use PKIX_PL_Mutex because it depends on Object */
588 /* Using NSPR Locks instead */
589 PKIX_OBJECT_DEBUG("\tCalling PR_NewLock).\n");
590 object->lock = PR_NewLock();
591 if (object->lock == NULL((void*)0)) {
592 PKIX_ERROR_ALLOC_ERROR(){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_ALLOCERROR, ((void*)0), stdVars.aPkixType, 2, plContext
); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorResult = PKIX_ALLOC_ERROR(); goto cleanup; };
593 }
594
595 PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");
596
597
598 /* Return a pointer to the user data. Need to offset by object size */
599 *pObject = object + 1;
600 object = NULL((void*)0);
601
602 /* Atomically increment object counter */
603 PR_ATOMIC_INCREMENT((PRInt32*)&ctEntry->objCounter)__sync_add_and_fetch((PRInt32*)&ctEntry->objCounter, 1
);
604
605cleanup:
606
607 PKIX_FREE(object)do { if (object) { stdVars.aPkixTempResult = PKIX_PL_Free((object
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } object = ((void*)0); } } while (0);
608
609 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
610}
611
612/*
613 * FUNCTION: PKIX_PL_Object_IsTypeRegistered (see comments in pkix_pl_system.h)
614 */
615PKIX_Error *
616PKIX_PL_Object_IsTypeRegistered(
617 PKIX_UInt32 objType,
618 PKIX_Boolean *pBool,
619 void *plContext)
620{
621#ifdef PKIX_USER_OBJECT_TYPE
622 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
623#endif
624
625 PKIX_ENTER(OBJECT, "PKIX_PL_Object_IsTypeRegistered")static const char cMyFuncName[] = {"PKIX_PL_Object_IsTypeRegistered"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
626 PKIX_NULLCHECK_ONE(pBool)do { if ((pBool) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
627
628 /* first, we handle the system types */
629 if (objType < PKIX_NUMTYPES) {
630 *pBool = PKIX_TRUE((PKIX_Boolean) 1);
631 goto cleanup;
632 }
633
634#ifndef PKIX_USER_OBJECT_TYPE
635 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",635));
636 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
637 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
638#else
639 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
640 PR_Lock(classTableLock);
641 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
642 (classTable,
643 (void *)&objType,
644 objType,
645 NULL((void*)0),
646 (void **)&ctEntry,
647 plContext);
648 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
649 PR_Unlock(classTableLock);
650
651 if (pkixErrorResultstdVars.aPkixErrorResult){
652 PKIX_ERROR_FATAL(PKIX_COULDNOTLOOKUPINHASHTABLE){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_COULDNOTLOOKUPINHASHTABLE; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
653 }
654
655 *pBool = (ctEntry != NULL((void*)0));
656#endif /* PKIX_USER_OBJECT_TYPE */
657
658cleanup:
659
660 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
661}
662
663#ifdef PKIX_USER_OBJECT_TYPE
664/*
665 * FUNCTION: PKIX_PL_Object_RegisterType (see comments in pkix_pl_system.h)
666 */
667PKIX_Error *
668PKIX_PL_Object_RegisterType(
669 PKIX_UInt32 objType,
670 char *description,
671 PKIX_PL_DestructorCallback destructor,
672 PKIX_PL_EqualsCallback equalsFunction,
673 PKIX_PL_HashcodeCallback hashcodeFunction,
674 PKIX_PL_ToStringCallback toStringFunction,
675 PKIX_PL_ComparatorCallback comparator,
676 PKIX_PL_DuplicateCallback duplicateFunction,
677 void *plContext)
678{
679 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
680 pkix_pl_Integer *key = NULL((void*)0);
681
682 PKIX_ENTER(OBJECT, "PKIX_PL_Object_RegisterType")static const char cMyFuncName[] = {"PKIX_PL_Object_RegisterType"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
683
684 /*
685 * System types are registered on startup by PKIX_PL_Initialize.
686 * These can not be overwritten.
687 */
688
689 if (objType < PKIX_NUMTYPES) { /* if this is a system type */
690 PKIX_ERROR(PKIX_CANTREREGISTERSYSTEMTYPE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_CANTREREGISTERSYSTEMTYPE, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_CANTREREGISTERSYSTEMTYPE;
goto cleanup; };
691 }
692
693 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
694 PR_Lock(classTableLock);
695 PKIX_CHECK(pkix_pl_PrimHashTable_Lookupdo { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_PRIMHASHTABLELOOKUPFAILED; goto
cleanup; } } while (0)
696 (classTable,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_PRIMHASHTABLELOOKUPFAILED; goto
cleanup; } } while (0)
697 (void *)&objType,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_PRIMHASHTABLELOOKUPFAILED; goto
cleanup; } } while (0)
698 objType,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_PRIMHASHTABLELOOKUPFAILED; goto
cleanup; } } while (0)
699 NULL,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_PRIMHASHTABLELOOKUPFAILED; goto
cleanup; } } while (0)
700 (void **)&ctEntry,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_PRIMHASHTABLELOOKUPFAILED; goto
cleanup; } } while (0)
701 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_PRIMHASHTABLELOOKUPFAILED; goto
cleanup; } } while (0)
702 PKIX_PRIMHASHTABLELOOKUPFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Lookup
(classTable, (void *)&objType, objType, ((void*)0), (void
**)&ctEntry, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_PRIMHASHTABLELOOKUPFAILED; goto
cleanup; } } while (0);
703
704 /* If the type is already registered, throw an error */
705 if (ctEntry) {
706 PKIX_ERROR(PKIX_TYPEALREADYREGISTERED){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_TYPEALREADYREGISTERED, ((void*)0), stdVars.aPkixType, 2
, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_TYPEALREADYREGISTERED; goto
cleanup; };
707 }
708
709 PKIX_CHECK(PKIX_PL_Mallocdo { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_ClassTable_Entry)), (void **)&ctEntry, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
710 (((PKIX_UInt32)sizeof (pkix_ClassTable_Entry)),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_ClassTable_Entry)), (void **)&ctEntry, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
711 (void **)&ctEntry,do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_ClassTable_Entry)), (void **)&ctEntry, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
712 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_ClassTable_Entry)), (void **)&ctEntry, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0)
713 PKIX_MALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_ClassTable_Entry)), (void **)&ctEntry, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MALLOCFAILED; goto cleanup; } } while (0);
714
715 /* Set Default Values if none specified */
716
717 if (description == NULL((void*)0)){
718 description = "Object";
719 }
720
721 if (equalsFunction == NULL((void*)0)) {
722 equalsFunction = pkix_pl_Object_Equals_Default;
723 }
724
725 if (toStringFunction == NULL((void*)0)) {
726 toStringFunction = pkix_pl_Object_ToString_Default;
727 }
728
729 if (hashcodeFunction == NULL((void*)0)) {
730 hashcodeFunction = pkix_pl_Object_Hashcode_Default;
731 }
732
733 ctEntry->destructor = destructor;
734 ctEntry->equalsFunction = equalsFunction;
735 ctEntry->toStringFunction = toStringFunction;
736 ctEntry->hashcodeFunction = hashcodeFunction;
737 ctEntry->comparator = comparator;
738 ctEntry->duplicateFunction = duplicateFunction;
739 ctEntry->description = description;
740
741 PKIX_CHECK(PKIX_PL_Mallocdo { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_pl_Integer)), (void **)&key, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_COULDNOTMALLOCNEWKEY
; goto cleanup; } } while (0)
742 (((PKIX_UInt32)sizeof (pkix_pl_Integer)),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_pl_Integer)), (void **)&key, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_COULDNOTMALLOCNEWKEY
; goto cleanup; } } while (0)
743 (void **)&key,do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_pl_Integer)), (void **)&key, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_COULDNOTMALLOCNEWKEY
; goto cleanup; } } while (0)
744 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_pl_Integer)), (void **)&key, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_COULDNOTMALLOCNEWKEY
; goto cleanup; } } while (0)
745 PKIX_COULDNOTMALLOCNEWKEY)do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (((PKIX_UInt32
)sizeof (pkix_pl_Integer)), (void **)&key, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_COULDNOTMALLOCNEWKEY
; goto cleanup; } } while (0);
746
747 key->ht_int = objType;
748
749 PKIX_CHECK(pkix_pl_PrimHashTable_Adddo { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Add (classTable
, (void *)key, (void *)ctEntry, objType, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_PRIMHASHTABLEADDFAILED; goto cleanup; } } while (0)
750 (classTable,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Add (classTable
, (void *)key, (void *)ctEntry, objType, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_PRIMHASHTABLEADDFAILED; goto cleanup; } } while (0)
751 (void *)key,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Add (classTable
, (void *)key, (void *)ctEntry, objType, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_PRIMHASHTABLEADDFAILED; goto cleanup; } } while (0)
752 (void *)ctEntry,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Add (classTable
, (void *)key, (void *)ctEntry, objType, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_PRIMHASHTABLEADDFAILED; goto cleanup; } } while (0)
753 objType,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Add (classTable
, (void *)key, (void *)ctEntry, objType, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_PRIMHASHTABLEADDFAILED; goto cleanup; } } while (0)
754 NULL,do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Add (classTable
, (void *)key, (void *)ctEntry, objType, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_PRIMHASHTABLEADDFAILED; goto cleanup; } } while (0)
755 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Add (classTable
, (void *)key, (void *)ctEntry, objType, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_PRIMHASHTABLEADDFAILED; goto cleanup; } } while (0)
756 PKIX_PRIMHASHTABLEADDFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_PrimHashTable_Add (classTable
, (void *)key, (void *)ctEntry, objType, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_PRIMHASHTABLEADDFAILED; goto cleanup; } } while (0);
757
758cleanup:
759 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
760 PR_Unlock(classTableLock);
761
762 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
763}
764#endif /* PKIX_USER_OBJECT_TYPE */
765
766/*
767 * FUNCTION: PKIX_PL_Object_IncRef (see comments in pkix_pl_system.h)
768 */
769PKIX_Error *
770PKIX_PL_Object_IncRef(
771 PKIX_PL_Object *object,
772 void *plContext)
773{
774 PKIX_PL_Object *objectHeader = NULL((void*)0);
775 PKIX_PL_NssContext *context = NULL((void*)0);
776 PKIX_Int32 refCount = 0;
777
778 PKIX_ENTER(OBJECT, "PKIX_PL_Object_IncRef")static const char cMyFuncName[] = {"PKIX_PL_Object_IncRef"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
779 PKIX_NULLCHECK_ONE(object)do { if ((object) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
780
781 if (plContext){
782 /*
783 * PKIX_PL_NssContext is not a complete PKIX Type, it doesn't
784 * have a header therefore we cannot verify its type before
785 * casting.
786 */
787 context = (PKIX_PL_NssContext *) plContext;
788 if (context->arena != NULL((void*)0)) {
789 goto cleanup;
790 }
791 }
792
793 if (object == (PKIX_PL_Object*)PKIX_ALLOC_ERROR()) {
794 goto cleanup;
795 }
796
797 /* Shift pointer from user data to object header */
798 PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
799 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
800
801 /* This object should never have zero references */
802 refCount = PR_ATOMIC_INCREMENT(&objectHeader->references)__sync_add_and_fetch(&objectHeader->references, 1);
803
804 if (refCount <= 1) {
805 PKIX_THROW(FATAL, PKIX_OBJECTWITHNONPOSITIVEREFERENCES)return PKIX_DoThrow(&stdVars, (PKIX_FATAL_ERROR), PKIX_OBJECTWITHNONPOSITIVEREFERENCES
, stdVars.aPkixErrorClass, plContext);;
806 }
807
808cleanup:
809
810 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
811}
812
813/*
814 * FUNCTION: PKIX_PL_Object_DecRef (see comments in pkix_pl_system.h)
815 */
816PKIX_Error *
817PKIX_PL_Object_DecRef(
818 PKIX_PL_Object *object,
819 void *plContext)
820{
821 PKIX_Int32 refCount = 0;
822 PKIX_PL_Object *objectHeader = NULL((void*)0);
823 PKIX_PL_NssContext *context = NULL((void*)0);
824
825 PKIX_ENTER(OBJECT, "PKIX_PL_Object_DecRef")static const char cMyFuncName[] = {"PKIX_PL_Object_DecRef"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
826 PKIX_NULLCHECK_ONE(object)do { if ((object) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
827
828 if (plContext){
829 /*
830 * PKIX_PL_NssContext is not a complete PKIX Type, it doesn't
831 * have a header therefore we cannot verify its type before
832 * casting.
833 */
834 context = (PKIX_PL_NssContext *) plContext;
835 if (context->arena != NULL((void*)0)) {
836 goto cleanup;
837 }
838 }
839
840 if (object == (PKIX_PL_Object*)PKIX_ALLOC_ERROR()) {
841 goto cleanup;
842 }
843
844 /* Shift pointer from user data to object header */
845 PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
846 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
847
848 refCount = PR_ATOMIC_DECREMENT(&objectHeader->references)__sync_sub_and_fetch(&objectHeader->references, 1);
849
850 if (refCount == 0) {
851 PKIX_PL_DestructorCallback destructor = NULL((void*)0);
852 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
853 PKIX_UInt32 objType = objectHeader->type;
854
855 /* first, special handling for system types */
856 if (objType >= PKIX_NUMTYPES){
857#ifdef PKIX_USER_OBJECT_TYPE
858 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
859 PR_Lock(classTableLock);
860 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
861 (classTable,
862 (void *)&objType,
863 objType,
864 NULL((void*)0),
865 (void **)&ctEntry,
866 plContext);
867 PKIX_OBJECT_DEBUG
868 ("\tCalling PR_Unlock).\n");
869 PR_Unlock(classTableLock);
870 if (pkixErrorResultstdVars.aPkixErrorResult){
871 PKIX_ERROR_FATAL{ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORINGETTINGDESTRUCTOR; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; }
872 (PKIX_ERRORINGETTINGDESTRUCTOR){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORINGETTINGDESTRUCTOR; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
873 }
874
875 if (ctEntry != NULL((void*)0)){
876 destructor = ctEntry->destructor;
877 }
878#else
879 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",879));
880 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
881 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
882 goto cleanup;
883#endif /* PKIX_USER_OBJECT_TYPE */
884 } else {
885 ctEntry = &systemClasses[objType];
886 destructor = ctEntry->destructor;
887 }
888
889 if (destructor != NULL((void*)0)){
890 /* Call destructor on user data if necessary */
891 pkixErrorResultstdVars.aPkixErrorResult = destructor(object, plContext);
892 if (pkixErrorResultstdVars.aPkixErrorResult) {
893 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
894 PKIX_DoAddError(stdVarsPtr&stdVars, pkixErrorResultstdVars.aPkixErrorResult, plContext);
895 pkixErrorResultstdVars.aPkixErrorResult = NULL((void*)0);
896 }
897 }
898
899 /* Atomically decrement object counter */
900 PR_ATOMIC_DECREMENT((PRInt32*)&ctEntry->objCounter)__sync_sub_and_fetch((PRInt32*)&ctEntry->objCounter, 1
);
901
902 /* pkix_pl_Object_Destroy assumes the lock is held */
903 /* It will call unlock and destroy the object */
904 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_Object_Destroy(object, plContext);
905 goto cleanup;
906 }
907
908 if (refCount < 0) {
909 PKIX_ERROR_ALLOC_ERROR(){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_ALLOCERROR, ((void*)0), stdVars.aPkixType, 2, plContext
); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorResult = PKIX_ALLOC_ERROR(); goto cleanup; };
910 }
911
912cleanup:
913
914 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
915}
916
917
918
919/*
920 * FUNCTION: PKIX_PL_Object_Equals (see comments in pkix_pl_system.h)
921 */
922PKIX_Error *
923PKIX_PL_Object_Equals(
924 PKIX_PL_Object *firstObject,
925 PKIX_PL_Object *secondObject,
926 PKIX_Boolean *pResult,
927 void *plContext)
928{
929 PKIX_PL_Object *firstObjectHeader = NULL((void*)0);
930 PKIX_PL_Object *secondObjectHeader = NULL((void*)0);
931 PKIX_PL_EqualsCallback func = NULL((void*)0);
932 pkix_ClassTable_Entry entry;
933 PKIX_UInt32 objType;
934
935 PKIX_ENTER(OBJECT, "PKIX_PL_Object_Equals")static const char cMyFuncName[] = {"PKIX_PL_Object_Equals"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
936 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult)do { if (((firstObject) == ((void*)0)) || ((secondObject) == (
(void*)0)) || ((pResult) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
937
938 PKIX_CHECK(pkix_pl_Object_GetHeaderdo { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
939 (firstObject, &firstObjectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
940 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
941
942 PKIX_CHECK(pkix_pl_Object_GetHeaderdo { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (secondObject
, &secondObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
943 (secondObject, &secondObjectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (secondObject
, &secondObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
944 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (secondObject
, &secondObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
945
946 /* if hashcodes are cached but not equal, objects can't be equal */
947 if (firstObjectHeader->hashcodeCached &&
948 secondObjectHeader->hashcodeCached){
949 if (firstObjectHeader->hashcode !=
950 secondObjectHeader->hashcode){
951 *pResult = PKIX_FALSE((PKIX_Boolean) 0);
952 goto cleanup;
953 }
954 }
955
956 objType = firstObjectHeader->type;
957
958 if (objType >= PKIX_NUMTYPES) {
959#ifdef PKIX_USER_OBJECT_TYPE
960 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
961 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
962 PR_Lock(classTableLock);
963 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
964 (classTable,
965 (void *)&firstObjectHeader->type,
966 firstObjectHeader->type,
967 NULL((void*)0),
968 (void **)&ctEntry,
969 plContext);
970 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
971 PR_Unlock(classTableLock);
972
973 if (pkixErrorResultstdVars.aPkixErrorResult){
974 PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORGETTINGCLASSTABLEENTRY; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; };
975 }
976
977 if ((ctEntry == NULL((void*)0)) || (ctEntry->equalsFunction == NULL((void*)0))) {
978 PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNDEFINEDCALLBACK; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
979 } else {
980 func = ctEntry->equalsFunction;
981 }
982#else
983 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",983));
984 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
985 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
986 goto cleanup;
987#endif /* PKIX_USER_OBJECT_TYPE */
988 } else {
989 entry = systemClasses[objType];
990 func = entry.equalsFunction;
991 if (func == NULL((void*)0)){
992 func = pkix_pl_Object_Equals_Default;
993 }
994 }
995
996 PKIX_CHECK(func(firstObject, secondObject, pResult, plContext),do { stdVars.aPkixErrorResult = (func(firstObject, secondObject
, pResult, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup
; } } while (0)
997 PKIX_OBJECTSPECIFICFUNCTIONFAILED)do { stdVars.aPkixErrorResult = (func(firstObject, secondObject
, pResult, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup
; } } while (0);
998
999cleanup:
1000
1001 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
1002}
1003
1004/*
1005 * FUNCTION: PKIX_PL_Object_Duplicate (see comments in pkix_pl_system.h)
1006 */
1007PKIX_Error *
1008PKIX_PL_Object_Duplicate(
1009 PKIX_PL_Object *firstObject,
1010 PKIX_PL_Object **pNewObject,
1011 void *plContext)
1012{
1013 PKIX_PL_Object *firstObjectHeader = NULL((void*)0);
1014 PKIX_PL_DuplicateCallback func = NULL((void*)0);
1015 pkix_ClassTable_Entry entry;
1016 PKIX_UInt32 objType;
1017
1018 PKIX_ENTER(OBJECT, "PKIX_PL_Object_Duplicate")static const char cMyFuncName[] = {"PKIX_PL_Object_Duplicate"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
1019 PKIX_NULLCHECK_TWO(firstObject, pNewObject)do { if (((firstObject) == ((void*)0)) || ((pNewObject) == ((
void*)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
1020
1021 PKIX_CHECK(pkix_pl_Object_GetHeaderdo { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
1022 (firstObject, &firstObjectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
1023 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
1024
1025 objType = firstObjectHeader->type;
1026
1027 if (objType >= PKIX_NUMTYPES) {
1028#ifdef PKIX_USER_OBJECT_TYPE
1029 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
1030
1031 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
1032 PR_Lock(classTableLock);
1033 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
1034 (classTable,
1035 (void *)&objType,
1036 objType,
1037 NULL((void*)0),
1038 (void **)&ctEntry,
1039 plContext);
1040 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
1041 PR_Unlock(classTableLock);
1042
1043 if (pkixErrorResultstdVars.aPkixErrorResult){
1044 PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORGETTINGCLASSTABLEENTRY; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; };
1045 }
1046
1047 if ((ctEntry == NULL((void*)0)) || (ctEntry->duplicateFunction == NULL((void*)0))) {
1048 PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNDEFINEDCALLBACK; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
1049 } else {
1050 func = ctEntry->duplicateFunction;
1051 }
1052#else
1053 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",1053));
1054 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
1055 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
1056 goto cleanup;
1057#endif /* PKIX_USER_OBJECT_TYPE */
1058 } else {
1059 entry = systemClasses[objType];
1060 func = entry.duplicateFunction;
1061 if (!func){
1062 PKIX_ERROR_FATAL(PKIX_UNDEFINEDDUPLICATEFUNCTION){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNDEFINEDDUPLICATEFUNCTION; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; };
1063 }
1064 }
1065
1066 PKIX_CHECK(func(firstObject, pNewObject, plContext),do { stdVars.aPkixErrorResult = (func(firstObject, pNewObject
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup; } } while
(0)
1067 PKIX_OBJECTSPECIFICFUNCTIONFAILED)do { stdVars.aPkixErrorResult = (func(firstObject, pNewObject
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup; } } while
(0);
1068
1069cleanup:
1070
1071 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
1072}
1073
1074/*
1075 * FUNCTION: PKIX_PL_Object_Hashcode (see comments in pkix_pl_system.h)
1076 */
1077PKIX_Error *
1078PKIX_PL_Object_Hashcode(
1079 PKIX_PL_Object *object,
1080 PKIX_UInt32 *pValue,
1081 void *plContext)
1082{
1083 PKIX_PL_Object *objectHeader = NULL((void*)0);
1084 PKIX_PL_HashcodeCallback func = NULL((void*)0);
1085 pkix_ClassTable_Entry entry;
1086 PKIX_UInt32 objectHash;
1087
1088 PKIX_ENTER(OBJECT, "PKIX_PL_Object_Hashcode")static const char cMyFuncName[] = {"PKIX_PL_Object_Hashcode"}
; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
1089 PKIX_NULLCHECK_TWO(object, pValue)do { if (((object) == ((void*)0)) || ((pValue) == ((void*)0))
){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_NULLARGUMENT; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR
), ((PKIX_Boolean) 1), plContext);; } } while (0);
1090
1091 /* Shift pointer from user data to object header */
1092 PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
1093 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
1094
1095 /* if we don't have a cached copy from before, we create one */
1096 if (!objectHeader->hashcodeCached){
1097
1098 PKIX_UInt32 objType = objectHeader->type;
1099
1100 /* first, special handling for system types */
1101 if (objType >= PKIX_NUMTYPES){
1102#ifdef PKIX_USER_OBJECT_TYPE
1103 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
1104
1105 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
1106 PR_Lock(classTableLock);
1107 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
1108 (classTable,
1109 (void *)&objType,
1110 objType,
1111 NULL((void*)0),
1112 (void **)&ctEntry,
1113 plContext);
1114 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
1115 PR_Unlock(classTableLock);
1116
1117 if (pkixErrorResultstdVars.aPkixErrorResult){
1118 PKIX_ERROR_FATAL{ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORGETTINGCLASSTABLEENTRY; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; }
1119 (PKIX_ERRORGETTINGCLASSTABLEENTRY){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORGETTINGCLASSTABLEENTRY; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; };
1120 }
1121
1122 if ((ctEntry == NULL((void*)0)) ||
1123 (ctEntry->hashcodeFunction == NULL((void*)0))) {
1124 PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNDEFINEDCALLBACK; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
1125 }
1126
1127 func = ctEntry->hashcodeFunction;
1128#else
1129 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",1129));
1130 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
1131 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
1132 goto cleanup;
1133#endif /* PKIX_USER_OBJECT_TYPE */
1134 } else {
1135 entry = systemClasses[objType];
1136 func = entry.hashcodeFunction;
1137 if (func == NULL((void*)0)){
1138 func = pkix_pl_Object_Hashcode_Default;
1139 }
1140 }
1141
1142 PKIX_CHECK(func(object, &objectHash, plContext),do { stdVars.aPkixErrorResult = (func(object, &objectHash
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup; } } while
(0)
1143 PKIX_OBJECTSPECIFICFUNCTIONFAILED)do { stdVars.aPkixErrorResult = (func(object, &objectHash
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup; } } while
(0);
1144
1145 if (!objectHeader->hashcodeCached){
1146
1147 PKIX_CHECK(pkix_LockObject(object, plContext),do { stdVars.aPkixErrorResult = (pkix_LockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORLOCKINGOBJECT; goto cleanup; } } while (0)
1148 PKIX_ERRORLOCKINGOBJECT)do { stdVars.aPkixErrorResult = (pkix_LockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORLOCKINGOBJECT; goto cleanup; } } while (0);
1149
1150 if (!objectHeader->hashcodeCached){
1151 /* save cached copy in case we need it again */
1152 objectHeader->hashcode = objectHash;
1153 objectHeader->hashcodeCached = PKIX_TRUE((PKIX_Boolean) 1);
1154 }
1155
1156 PKIX_CHECK(pkix_UnlockObject(object, plContext),do { stdVars.aPkixErrorResult = (pkix_UnlockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORUNLOCKINGOBJECT; goto cleanup; } } while (0)
1157 PKIX_ERRORUNLOCKINGOBJECT)do { stdVars.aPkixErrorResult = (pkix_UnlockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORUNLOCKINGOBJECT; goto cleanup; } } while (0);
1158 }
1159 }
1160
1161 *pValue = objectHeader->hashcode;
1162
1163cleanup:
1164
1165 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
1166}
1167
1168/*
1169 * FUNCTION: PKIX_PL_Object_ToString (see comments in pkix_pl_system.h)
1170 */
1171PKIX_Error *
1172PKIX_PL_Object_ToString(
1173 PKIX_PL_Object *object,
1174 PKIX_PL_String **pString,
1175 void *plContext)
1176{
1177 PKIX_PL_Object *objectHeader = NULL((void*)0);
1178 PKIX_PL_ToStringCallback func = NULL((void*)0);
1179 pkix_ClassTable_Entry entry;
1180 PKIX_PL_String *objectString = NULL((void*)0);
1181
1182 PKIX_ENTER(OBJECT, "PKIX_PL_Object_ToString")static const char cMyFuncName[] = {"PKIX_PL_Object_ToString"}
; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
1
Assuming 'pkixLoggersDebugTrace' is null
→
2
←
Taking false branch
→
1183 PKIX_NULLCHECK_TWO(object, pString)do { if (((object) == ((void*)0)) || ((pString) == ((void*)0)
)){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.
aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
3
←
Loop condition is false. Exiting loop
→
4
←
Assuming 'object' is not equal to null
→
5
←
Assuming 'pString' is not equal to null
→
6
←
Taking false branch
→
7
←
Loop condition is false. Exiting loop
→
1184
1185 /* Shift pointer from user data to object header */
1186 PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
8
←
Assuming field 'aPkixErrorResult' is null
→
9
←
Taking false branch
→
10
←
Loop condition is false. Exiting loop
→
1187 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
1188
1189 /* if we don't have a cached copy from before, we create one */
1190 if (!objectHeader->stringRep){
11
←
Assuming field 'stringRep' is null
→
12
←
Taking true branch
→
1191
1192 PKIX_UInt32 objType = objectHeader->type;
1193
1194 if (objType >= PKIX_NUMTYPES){
13
←
Assuming 'objType' is < PKIX_NUMTYPES
→
14
←
Taking false branch
→
1195#ifdef PKIX_USER_OBJECT_TYPE
1196 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
1197
1198 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
1199 PR_Lock(classTableLock);
1200 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
1201 (classTable,
1202 (void *)&objType,
1203 objType,
1204 NULL((void*)0),
1205 (void **)&ctEntry,
1206 plContext);
1207 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
1208 PR_Unlock(classTableLock);
1209 if (pkixErrorResultstdVars.aPkixErrorResult){
1210 PKIX_ERROR_FATAL{ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORGETTINGCLASSTABLEENTRY; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; }
1211 (PKIX_ERRORGETTINGCLASSTABLEENTRY){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORGETTINGCLASSTABLEENTRY; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; };
1212 }
1213
1214 if ((ctEntry == NULL((void*)0)) ||
1215 (ctEntry->toStringFunction == NULL((void*)0))) {
1216 PKIX_ERROR_FATAL(PKIX_UNDEFINEDCALLBACK){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNDEFINEDCALLBACK; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
1217 }
1218
1219 func = ctEntry->toStringFunction;
1220#else
1221 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",1221));
1222 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
1223 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
1224 goto cleanup;
1225#endif /* PKIX_USER_OBJECT_TYPE */
1226 } else {
1227 entry = systemClasses[objType];
1228 func = entry.toStringFunction;
1229 if (func == NULL((void*)0)){
15
←
Assuming 'func' is equal to NULL
→
16
←
Taking true branch
→
1230 func = pkix_pl_Object_ToString_Default;
1231 }
1232 }
1233
1234 PKIX_CHECK(func(object, &objectString, plContext),do { stdVars.aPkixErrorResult = (func(object, &objectString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup; } } while
(0)
17
←
Calling 'pkix_pl_Object_ToString_Default'
→
1235 PKIX_OBJECTSPECIFICFUNCTIONFAILED)do { stdVars.aPkixErrorResult = (func(object, &objectString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup; } } while
(0);
1236
1237 if (!objectHeader->stringRep){
1238
1239 PKIX_CHECK(pkix_LockObject(object, plContext),do { stdVars.aPkixErrorResult = (pkix_LockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORLOCKINGOBJECT; goto cleanup; } } while (0)
1240 PKIX_ERRORLOCKINGOBJECT)do { stdVars.aPkixErrorResult = (pkix_LockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORLOCKINGOBJECT; goto cleanup; } } while (0);
1241
1242 if (!objectHeader->stringRep){
1243 /* save a cached copy */
1244 objectHeader->stringRep = objectString;
1245 objectString = NULL((void*)0);
1246 }
1247
1248 PKIX_CHECK(pkix_UnlockObject(object, plContext),do { stdVars.aPkixErrorResult = (pkix_UnlockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORUNLOCKINGOBJECT; goto cleanup; } } while (0)
1249 PKIX_ERRORUNLOCKINGOBJECT)do { stdVars.aPkixErrorResult = (pkix_UnlockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORUNLOCKINGOBJECT; goto cleanup; } } while (0);
1250 }
1251 }
1252
1253
1254 *pString = objectHeader->stringRep;
1255 objectHeader->stringRep = NULL((void*)0);
1256
1257cleanup:
1258 if (objectHeader) {
1259 PKIX_DECREF(objectHeader->stringRep)do { if (objectHeader->stringRep){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(objectHeader->
stringRep), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } objectHeader->stringRep = ((void*)0); } }
while (0);
1260 }
1261 PKIX_DECREF(objectString)do { if (objectString){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(objectString), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } objectString = ((void
*)0); } } while (0);
1262
1263 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
1264}
1265
1266/*
1267 * FUNCTION: PKIX_PL_Object_InvalidateCache (see comments in pkix_pl_system.h)
1268 */
1269PKIX_Error *
1270PKIX_PL_Object_InvalidateCache(
1271 PKIX_PL_Object *object,
1272 void *plContext)
1273{
1274 PKIX_PL_Object *objectHeader = NULL((void*)0);
1275
1276 PKIX_ENTER(OBJECT, "PKIX_PL_Object_InvalidateCache")static const char cMyFuncName[] = {"PKIX_PL_Object_InvalidateCache"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
1277 PKIX_NULLCHECK_ONE(object)do { if ((object) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1278
1279 /* Shift pointer from user data to object header */
1280 PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
1281 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
1282
1283 PKIX_CHECK(pkix_LockObject(object, plContext),do { stdVars.aPkixErrorResult = (pkix_LockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORLOCKINGOBJECT; goto cleanup; } } while (0)
1284 PKIX_ERRORLOCKINGOBJECT)do { stdVars.aPkixErrorResult = (pkix_LockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORLOCKINGOBJECT; goto cleanup; } } while (0);
1285
1286 /* invalidate hashcode */
1287 objectHeader->hashcode = 0;
1288 objectHeader->hashcodeCached = PKIX_FALSE((PKIX_Boolean) 0);
1289
1290 PKIX_DECREF(objectHeader->stringRep)do { if (objectHeader->stringRep){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(objectHeader->
stringRep), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } objectHeader->stringRep = ((void*)0); } }
while (0);
1291
1292 PKIX_CHECK(pkix_UnlockObject(object, plContext),do { stdVars.aPkixErrorResult = (pkix_UnlockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORUNLOCKINGOBJECT; goto cleanup; } } while (0)
1293 PKIX_ERRORUNLOCKINGOBJECT)do { stdVars.aPkixErrorResult = (pkix_UnlockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_ERRORUNLOCKINGOBJECT; goto cleanup; } } while (0);
1294
1295cleanup:
1296
1297 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
1298}
1299
1300/*
1301 * FUNCTION: PKIX_PL_Object_Compare (see comments in pkix_pl_system.h)
1302 */
1303PKIX_Error *
1304PKIX_PL_Object_Compare(
1305 PKIX_PL_Object *firstObject,
1306 PKIX_PL_Object *secondObject,
1307 PKIX_Int32 *pResult,
1308 void *plContext)
1309{
1310 PKIX_PL_Object *firstObjectHeader = NULL((void*)0);
1311 PKIX_PL_Object *secondObjectHeader = NULL((void*)0);
1312 PKIX_PL_ComparatorCallback func = NULL((void*)0);
1313 pkix_ClassTable_Entry entry;
1314 PKIX_UInt32 objType;
1315
1316 PKIX_ENTER(OBJECT, "PKIX_PL_Object_Compare")static const char cMyFuncName[] = {"PKIX_PL_Object_Compare"};
PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
1317 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult)do { if (((firstObject) == ((void*)0)) || ((secondObject) == (
(void*)0)) || ((pResult) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1318
1319 /* Shift pointer from user data to object header */
1320 PKIX_CHECK(pkix_pl_Object_GetHeaderdo { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
1321 (firstObject, &firstObjectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
1322 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (firstObject
, &firstObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
1323
1324 /* Shift pointer from user data to object header */
1325 PKIX_CHECK(pkix_pl_Object_GetHeaderdo { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (secondObject
, &secondObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
1326 (secondObject, &secondObjectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (secondObject
, &secondObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
1327 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader (secondObject
, &secondObjectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
1328
1329 objType = firstObjectHeader->type;
1330
1331 if (objType >= PKIX_NUMTYPES){
1332#ifdef PKIX_USER_OBJECT_TYPE
1333 pkix_ClassTable_Entry *ctEntry = NULL((void*)0);
1334
1335 PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
1336 PR_Lock(classTableLock);
1337 pkixErrorResultstdVars.aPkixErrorResult = pkix_pl_PrimHashTable_Lookup
1338 (classTable,
1339 (void *)&objType,
1340 objType,
1341 NULL((void*)0),
1342 (void **)&ctEntry,
1343 plContext);
1344 PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
1345 PR_Unlock(classTableLock);
1346 if (pkixErrorResultstdVars.aPkixErrorResult){
1347 PKIX_ERROR_FATAL(PKIX_ERRORGETTINGCLASSTABLEENTRY){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_ERRORGETTINGCLASSTABLEENTRY; stdVars.aPkixErrorClass =
PKIX_FATAL_ERROR; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode
(pkixLoggersErrors, stdVars.aPkixErrorCode, ((void*)0), stdVars
.aPkixType, 1, plContext); } }; goto cleanup; };
1348 }
1349
1350 if ((ctEntry == NULL((void*)0)) || (ctEntry->comparator == NULL((void*)0))) {
1351 PKIX_ERROR_FATAL(PKIX_UNDEFINEDCOMPARATOR){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_UNDEFINEDCOMPARATOR; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
1352 }
1353
1354 func = ctEntry->comparator;
1355#else
1356 PORT_Assert (0)((0)?((void)0):PR_Assert("0","pkix_pl_object.c",1356));
1357 pkixErrorCodestdVars.aPkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
1358 pkixErrorClassstdVars.aPkixErrorClass = PKIX_FATAL_ERROR;
1359 goto cleanup;
1360#endif /* PKIX_USER_OBJECT_TYPE */
1361 } else {
1362 /* special handling for system types */
1363 entry = systemClasses[objType];
1364 func = entry.comparator;
1365 if (!func){
1366 PKIX_ERROR(PKIX_UNDEFINEDCOMPARATOR){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_UNDEFINEDCOMPARATOR, ((void*)0), stdVars.aPkixType, 2,
plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean)
1); stdVars.aPkixErrorCode = PKIX_UNDEFINEDCOMPARATOR; goto cleanup
; };
1367 }
1368 }
1369
1370 PKIX_CHECK(func(firstObject, secondObject, pResult, plContext),do { stdVars.aPkixErrorResult = (func(firstObject, secondObject
, pResult, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup
; } } while (0)
1371 PKIX_OBJECTSPECIFICFUNCTIONFAILED)do { stdVars.aPkixErrorResult = (func(firstObject, secondObject
, pResult, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_OBJECTSPECIFICFUNCTIONFAILED; goto cleanup
; } } while (0);
1372
1373cleanup:
1374
1375 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
1376}
1377
1378/*
1379 * FUNCTION: PKIX_PL_Object_Lock (see comments in pkix_pl_system.h)
1380 */
1381PKIX_Error *
1382PKIX_PL_Object_Lock(
1383 PKIX_PL_Object *object,
1384 void *plContext)
1385{
1386 PKIX_ENTER(OBJECT, "PKIX_PL_Object_Lock")static const char cMyFuncName[] = {"PKIX_PL_Object_Lock"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
1387 PKIX_NULLCHECK_ONE(object)do { if ((object) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1388
1389 PKIX_CHECK(pkix_LockObject(object, plContext),do { stdVars.aPkixErrorResult = (pkix_LockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LOCKOBJECTFAILED; goto cleanup; } } while (0)
1390 PKIX_LOCKOBJECTFAILED)do { stdVars.aPkixErrorResult = (pkix_LockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LOCKOBJECTFAILED; goto cleanup; } } while (0);
1391
1392cleanup:
1393
1394 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
1395}
1396
1397/*
1398 * FUNCTION: PKIX_PL_Object_Unlock (see comments in pkix_pl_system.h)
1399 */
1400PKIX_Error *
1401PKIX_PL_Object_Unlock(
1402 PKIX_PL_Object *object,
1403 void *plContext)
1404{
1405 PKIX_ENTER(OBJECT, "PKIX_PL_Object_Unlock")static const char cMyFuncName[] = {"PKIX_PL_Object_Unlock"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
1406 PKIX_NULLCHECK_ONE(object)do { if ((object) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1407
1408 PKIX_CHECK(pkix_UnlockObject(object, plContext),do { stdVars.aPkixErrorResult = (pkix_UnlockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_UNLOCKOBJECTFAILED; goto cleanup; } } while (0)
1409 PKIX_UNLOCKOBJECTFAILED)do { stdVars.aPkixErrorResult = (pkix_UnlockObject(object, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_UNLOCKOBJECTFAILED; goto cleanup; } } while (0);
1410
1411cleanup:
1412
1413 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
1414}
1415
1416
1417/*
1418 * FUNCTION: PKIX_PL_Object_GetType (see comments in pkix_pl_system.h)
1419 */
1420PKIX_Error *
1421PKIX_PL_Object_GetType(
1422 PKIX_PL_Object *object,
1423 PKIX_UInt32 *pType,
1424 void *plContext)
1425{
1426 PKIX_PL_Object *objectHeader = NULL((void*)0);
1427
1428 PKIX_ENTER(OBJECT, "PKIX_PL_Object_GetType")static const char cMyFuncName[] = {"PKIX_PL_Object_GetType"};
PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_OBJECT_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
25
←
Taking false branch
→
1429 PKIX_NULLCHECK_TWO(object, pType)do { if (((object) == ((void*)0)) || ((pType) == ((void*)0)))
{ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_NULLARGUMENT; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR
), ((PKIX_Boolean) 1), plContext);; } } while (0);
26
←
Loop condition is false. Exiting loop
→
27
←
Taking false branch
→
28
←
Loop condition is false. Exiting loop
→
1430
1431 /* Shift pointer from user data to object header */
1432 PKIX_CHECK(pkix_pl_Object_GetHeader(object, &objectHeader, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0)
29
←
Assuming field 'aPkixErrorResult' is non-null
→
30
←
Taking true branch
→
31
←
Control jumps to line 1439
→
1433 PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT)do { stdVars.aPkixErrorResult = (pkix_pl_Object_GetHeader(object
, &objectHeader, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_RECEIVEDCORRUPTEDOBJECTARGUMENT
; goto cleanup; } } while (0);
1434
1435 *pType = objectHeader->type;
1436
1437cleanup:
1438
1439 PKIX_RETURN(OBJECT)return PKIX_DoReturn(&stdVars, (PKIX_OBJECT_ERROR), ((PKIX_Boolean
) 1), plContext);;
32
←
Returning without writing to '*pType'
→
33
←
Returning pointer, which participates in a condition later
→
1440}