Bug Summary

File:s/lib/libpkix/pkix/util/pkix_logger.c
Warning:line 227, column 17
Value stored to 'error' is never read

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_logger.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=/var/lib/jenkins/workspace/nss-scan-build/nss/lib/libpkix/pkix/util -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/var/lib/jenkins/workspace/nss-scan-build/nss/lib/libpkix/pkix/util -resource-dir /usr/lib/llvm-18/lib/clang/18 -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/Linux4.19_x86_64_gcc_glibc_PTH_64_DBG.OBJ/include -I ../../../../../dist/public/nss -I ../../../../../dist/private/nss -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../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 -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-05-18-082241-28900-1 -x c pkix_logger.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_logger.c
6 *
7 * Logger Object Functions
8 *
9 */
10
11#include "pkix_logger.h"
12#ifndef PKIX_ERROR_DESCRIPTION
13#include "prprf.h"
14#endif
15
16/* Global variable to keep PKIX_Logger List */
17PKIX_List *pkixLoggers = NULL((void*)0);
18
19/*
20 * Once the Logger has been set, for any logging related operations, we have
21 * to go through the List to find a match, and if found, issue the
22 * corresponding callback. The overhead to check for DEBUG and TRACE in each
23 * PKIX function entering and exiting is very expensive (400X), and redundant
24 * if they are not the interest of the Logger. Therefore, the PKIX_Logger List
25 * pkixLoggers is separated into two lists based on its Loggers' trace level.
26 *
27 * Whenever the pkixLoggers List is updated by PKIX_Logger_AddLogger() or
28 * PKIX_Logger_SetLoggers(), we destroy and reconstruct pkixLoggersErrors
29 * and pkixLoggersDebugTrace Logger Lists. The ERROR, FATAL_ERROR and
30 * WARNING goes to pkixLoggersErrors and the DEBUG and TRACE goes to
31 * pkixLoggersDebugTrace.
32 *
33 * Currently we provide five logging levels and the default setting are by:
34 *
35 * PKIX_FATAL_ERROR() macro invokes pkix_Logger_Check of FATAL_ERROR level
36 * PKIX_ERROR() macro invokes pkix_Logger_Check of ERROR level
37 * WARNING is not invoked as default
38 * PKIX_DEBUG() macro invokes pkix_Logger_Check of DEBUG level. This needs
39 * compilation -DPKIX_<component>DEBUG flag to turn on
40 * PKIX_ENTER() and PKIX_RETURN() macros invoke pkix_Logger_Check of TRACE
41 * level. TRACE provides duplicate information of DEBUG, but needs no
42 * recompilation and cannot choose component. To allow application
43 * to use DEBUG level, TRACE is put as last.
44 *
45 */
46PKIX_List *pkixLoggersErrors = NULL((void*)0);
47PKIX_List *pkixLoggersDebugTrace = NULL((void*)0);
48
49/* To ensure atomic update on pkixLoggers lists */
50PKIX_PL_MonitorLock *pkixLoggerLock = NULL((void*)0);
51
52/* --Private-Functions-------------------------------------------- */
53
54/*
55 * FUNCTION: pkix_Logger_CheckErrors
56 * DESCRIPTION:
57 *
58 * This function goes through each PKIX_Logger at "pkixLoggersList" and
59 * checks if "maxLevel" and "logComponent" satisfies what is specified in the
60 * PKIX_Logger. If satisfies, it invokes the callback in PKIX_Logger and
61 * passes a PKIX_PL_String that is the concatenation of "message" and
62 * "message2" to the application for processing.
63 * Since this call is inserted into a handful of PKIX macros, no macros are
64 * applied in this function, to avoid infinite recursion.
65 * If an error occurs, this call is aborted.
66 *
67 * PARAMETERS:
68 * "pkixLoggersList"
69 * A list of PKIX_Loggers to be examined for invoking callback. Must be
70 * non-NULL.
71 * "message"
72 * Address of "message" to be logged. Must be non-NULL.
73 * "message2"
74 * Address of "message2" to be concatenated and logged. May be NULL.
75 * "logComponent"
76 * A PKIX_UInt32 that indicates the component the message is from.
77 * "maxLevel"
78 * A PKIX_UInt32 that represents the level of severity of the message.
79 * "plContext"
80 * Platform-specific context pointer.
81 * THREAD SAFETY:
82 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
83 * RETURNS:
84 * Returns NULL if the function succeeds
85 * Returns a Fatal Error if the function fails in an unrecoverable way
86 */
87PKIX_Error *
88pkix_Logger_Check(
89 PKIX_List *pkixLoggersList,
90 const char *message,
91 const char *message2,
92 PKIX_ERRORCLASS logComponent,
93 PKIX_UInt32 currentLevel,
94 void *plContext)
95{
96 PKIX_Logger *logger = NULL((void*)0);
97 PKIX_List *savedPkixLoggersErrors = NULL((void*)0);
98 PKIX_List *savedPkixLoggersDebugTrace = NULL((void*)0);
99 PKIX_PL_String *formatString = NULL((void*)0);
100 PKIX_PL_String *messageString = NULL((void*)0);
101 PKIX_PL_String *message2String = NULL((void*)0);
102 PKIX_PL_String *msgString = NULL((void*)0);
103 PKIX_Error *error = NULL((void*)0);
104 PKIX_Boolean needLogging = PKIX_FALSE((PKIX_Boolean) 0);
105 PKIX_UInt32 i, length;
106
107 /*
108 * We cannot use any the PKIX_ macros here, since this function is
109 * called from some of these macros. It can create infinite recursion.
110 */
111
112 if ((pkixLoggersList == NULL((void*)0)) || (message == NULL((void*)0))) {
113 return(NULL((void*)0));
114 }
115
116 /*
117 * Disable all subsequent loggings to avoid recursion. The result is
118 * if other thread is calling this function at the same time, there
119 * won't be any logging because the pkixLoggersErrors and
120 * pkixLoggersDebugTrace are set to null.
121 * It would be nice if we provide control per thread (e.g. make
122 * plContext threadable) then we can avoid the recursion by setting
123 * flag at plContext. Then other thread's logging won't be affected.
124 *
125 * Also we need to use a reentrant Lock. Although we avoid recursion
126 * for TRACE. When there is an ERROR occurs in subsequent call, this
127 * function will be called.
128 */
129
130 error = PKIX_PL_MonitorLock_Enter(pkixLoggerLock, plContext);
131 if (error) { return(NULL((void*)0)); }
132
133 savedPkixLoggersDebugTrace = pkixLoggersDebugTrace;
134 pkixLoggersDebugTrace = NULL((void*)0);
135 savedPkixLoggersErrors = pkixLoggersErrors;
136 pkixLoggersErrors = NULL((void*)0);
137
138 /* Convert message and message2 to String */
139 error = PKIX_PL_String_Create
140 (PKIX_ESCASCII0, message, 0, &messageString, plContext);
141 if (error) { goto cleanup; }
142
143 if (message2) {
144 error = PKIX_PL_String_Create
145 (PKIX_ESCASCII0, message2, 0, &message2String, plContext);
146 if (error) { goto cleanup; }
147 error = PKIX_PL_String_Create
148 (PKIX_ESCASCII0, "%s %s", 0, &formatString, plContext);
149 if (error) { goto cleanup; }
150
151 } else {
152 error = PKIX_PL_String_Create
153 (PKIX_ESCASCII0, "%s", 0, &formatString, plContext);
154 if (error) { goto cleanup; }
155
156 }
157
158 error = PKIX_PL_Sprintf
159 (&msgString,
160 plContext,
161 formatString,
162 messageString,
163 message2String);
164 if (error) { goto cleanup; }
165
166 /* Go through the Logger list */
167
168 error = PKIX_List_GetLength(pkixLoggersList, &length, plContext);
169 if (error) { goto cleanup; }
170
171 for (i = 0; i < length; i++) {
172
173 error = PKIX_List_GetItem
174 (pkixLoggersList,
175 i,
176 (PKIX_PL_Object **) &logger,
177 plContext);
178 if (error) { goto cleanup; }
179
180 /* Intended logging level less or equal than the max */
181 needLogging = (currentLevel <= logger->maxLevel);
182
183 if (needLogging && (logger->callback)) {
184
185 /*
186 * We separate Logger into two lists based on log level
187 * but log level is not modified. We need to check here to
188 * avoid logging the higher log level (lower value) twice.
189 */
190 if (pkixLoggersList == pkixLoggersErrors) {
191 needLogging = needLogging &&
192 (currentLevel <= PKIX_LOGGER_LEVEL_WARNING3);
193 } else if (pkixLoggersList == pkixLoggersDebugTrace) {
194 needLogging = needLogging &&
195 (currentLevel > PKIX_LOGGER_LEVEL_WARNING3);
196 }
197
198 if (needLogging) {
199 if (logComponent == logger->logComponent) {
200 needLogging = PKIX_TRUE((PKIX_Boolean) 1);
201 } else {
202 needLogging = PKIX_FALSE((PKIX_Boolean) 0);
203 }
204 }
205
206 if (needLogging) {
207 error = logger->callback
208 (logger,
209 msgString,
210 currentLevel,
211 logComponent,
212 plContext);
213 if (error) { goto cleanup; }
214 }
215 }
216
217 error = PKIX_PL_Object_DecRef
218 ((PKIX_PL_Object *)logger, plContext);
219 logger = NULL((void*)0);
220 if (error) { goto cleanup; }
221
222 }
223
224cleanup:
225
226 if (formatString) {
227 error = PKIX_PL_Object_DecRef
Value stored to 'error' is never read
228 ((PKIX_PL_Object *)formatString, plContext);
229 }
230
231 if (messageString) {
232 error = PKIX_PL_Object_DecRef
233 ((PKIX_PL_Object *)messageString, plContext);
234 }
235
236 if (message2String) {
237 error = PKIX_PL_Object_DecRef
238 ((PKIX_PL_Object *)message2String, plContext);
239 }
240
241 if (msgString) {
242 error = PKIX_PL_Object_DecRef
243 ((PKIX_PL_Object *)msgString, plContext);
244 }
245
246 if (logger) {
247 error = PKIX_PL_Object_DecRef
248 ((PKIX_PL_Object *)logger, plContext);
249 }
250
251 if (pkixLoggersErrors == NULL((void*)0) && savedPkixLoggersErrors != NULL((void*)0)) {
252 pkixLoggersErrors = savedPkixLoggersErrors;
253 }
254
255 if (pkixLoggersDebugTrace == NULL((void*)0) &&
256 savedPkixLoggersDebugTrace != NULL((void*)0)) {
257 pkixLoggersDebugTrace = savedPkixLoggersDebugTrace;
258 }
259
260 error = PKIX_PL_MonitorLock_Exit(pkixLoggerLock, plContext);
261 if (error) { return(NULL((void*)0)); }
262
263 return(NULL((void*)0));
264}
265
266PKIX_Error *
267pkix_Logger_CheckWithCode(
268 PKIX_List *pkixLoggersList,
269 PKIX_UInt32 errorCode,
270 const char *message2,
271 PKIX_ERRORCLASS logComponent,
272 PKIX_UInt32 currentLevel,
273 void *plContext)
274{
275 char error[32];
276 char *errorString = NULL((void*)0);
277
278 PKIX_ENTER(LOGGER, "pkix_Logger_CheckWithCode")static const char cMyFuncName[] = {"pkix_Logger_CheckWithCode"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
279#if defined PKIX_ERROR_DESCRIPTION
280 errorString = PKIX_ErrorText[errorCode];
281#else
282 PR_snprintf(error, 32, "Error code: %d", errorCode);
283 errorString = error;
284#endif /* PKIX_ERROR_DESCRIPTION */
285
286 pkixErrorResultstdVars.aPkixErrorResult = pkix_Logger_Check(pkixLoggersList, errorString,
287 message2, logComponent,
288 currentLevel, plContext);
289 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
290}
291
292/*
293 * FUNCTION: pkix_Logger_Destroy
294 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
295 */
296static PKIX_Error *
297pkix_Logger_Destroy(
298 PKIX_PL_Object *object,
299 void *plContext)
300{
301 PKIX_Logger *logger = NULL((void*)0);
302
303 PKIX_ENTER(LOGGER, "pkix_Logger_Destroy")static const char cMyFuncName[] = {"pkix_Logger_Destroy"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
304 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);
305
306 /* Check that this object is a logger */
307 PKIX_CHECK(pkix_CheckType(object, PKIX_LOGGER_TYPE, plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType(object, PKIX_LOGGER_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTLOGGER; goto cleanup; } } while (0)
308 PKIX_OBJECTNOTLOGGER)do { stdVars.aPkixErrorResult = (pkix_CheckType(object, PKIX_LOGGER_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTLOGGER; goto cleanup; } } while (0);
309
310 logger = (PKIX_Logger *)object;
311
312 /* We have a valid logger. DecRef its item and recurse on next */
313
314 logger->callback = NULL((void*)0);
315 PKIX_DECREF(logger->context)do { if (logger->context){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(logger->context), plContext); if (stdVars
.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult
, plContext); stdVars.aPkixTempResult = ((void*)0); } logger->
context = ((void*)0); } } while (0);
316 logger->logComponent = (PKIX_ERRORCLASS)0;
317
318cleanup:
319
320 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
321}
322
323/*
324 * FUNCTION: pkix_Logger_ToString
325 * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
326 */
327static PKIX_Error *
328pkix_Logger_ToString(
329 PKIX_PL_Object *object,
330 PKIX_PL_String **pString,
331 void *plContext)
332{
333 PKIX_Logger *logger = NULL((void*)0);
334 char *asciiFormat = NULL((void*)0);
335 PKIX_PL_String *formatString = NULL((void*)0);
336 PKIX_PL_String *contextString = NULL((void*)0);
337 PKIX_PL_String *componentString = NULL((void*)0);
338 PKIX_PL_String *loggerString = NULL((void*)0);
339
340 PKIX_ENTER(LOGGER, "pkix_Logger_ToString_Helper")static const char cMyFuncName[] = {"pkix_Logger_ToString_Helper"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
341 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);
342
343 /* Check that this object is a logger */
344 PKIX_CHECK(pkix_CheckType(object, PKIX_LOGGER_TYPE, plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType(object, PKIX_LOGGER_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTLOGGER; goto cleanup; } } while (0)
345 PKIX_OBJECTNOTLOGGER)do { stdVars.aPkixErrorResult = (pkix_CheckType(object, PKIX_LOGGER_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTLOGGER; goto cleanup; } } while (0);
346
347 logger = (PKIX_Logger *)object;
348
349 asciiFormat =
350 "[\n"
351 "\tLogger: \n"
352 "\tContext: %s\n"
353 "\tMaximum Level: %d\n"
354 "\tComponent Name: %s\n"
355 "]\n";
356
357 PKIX_CHECK(PKIX_PL_String_Createdo { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, asciiFormat
, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
358 (PKIX_ESCASCII,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, asciiFormat
, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
359 asciiFormat,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, asciiFormat
, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
360 0,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, asciiFormat
, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
361 &formatString,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, asciiFormat
, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
362 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, asciiFormat
, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0)
363 PKIX_STRINGCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, asciiFormat
, 0, &formatString, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_STRINGCREATEFAILED; goto cleanup
; } } while (0);
364
365 PKIX_TOSTRING(logger->context, &contextString, plContext,do { int descNum; if ((logger->context) != ((void*)0)) { stdVars
.aPkixErrorResult = PKIX_PL_Object_ToString((PKIX_PL_Object *
)(logger->context), (&contextString), (plContext)); descNum
= (PKIX_OBJECTTOSTRINGFAILED); } else { stdVars.aPkixErrorResult
= PKIX_PL_String_Create(0, "(null)", 0, (&contextString)
, (plContext)); descNum = PKIX_STRINGCREATEFAILED; } do { stdVars
.aPkixErrorResult = (stdVars.aPkixErrorResult); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = descNum; goto cleanup; } } while (
0); } while (0)
366 PKIX_OBJECTTOSTRINGFAILED)do { int descNum; if ((logger->context) != ((void*)0)) { stdVars
.aPkixErrorResult = PKIX_PL_Object_ToString((PKIX_PL_Object *
)(logger->context), (&contextString), (plContext)); descNum
= (PKIX_OBJECTTOSTRINGFAILED); } else { stdVars.aPkixErrorResult
= PKIX_PL_String_Create(0, "(null)", 0, (&contextString)
, (plContext)); descNum = PKIX_STRINGCREATEFAILED; } do { stdVars
.aPkixErrorResult = (stdVars.aPkixErrorResult); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = descNum; goto cleanup; } } while (
0); } while (0);
367
368 PKIX_CHECK(PKIX_PL_String_Createdo { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)PKIX_ERRORCLASSNAMES[logger->logComponent], 0, &componentString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_STRINGCREATEFAILED; goto cleanup; } } while (0)
369 (PKIX_ESCASCII,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)PKIX_ERRORCLASSNAMES[logger->logComponent], 0, &componentString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_STRINGCREATEFAILED; goto cleanup; } } while (0)
370 (void *)PKIX_ERRORCLASSNAMES[logger->logComponent],do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)PKIX_ERRORCLASSNAMES[logger->logComponent], 0, &componentString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_STRINGCREATEFAILED; goto cleanup; } } while (0)
371 0,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)PKIX_ERRORCLASSNAMES[logger->logComponent], 0, &componentString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_STRINGCREATEFAILED; goto cleanup; } } while (0)
372 &componentString,do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)PKIX_ERRORCLASSNAMES[logger->logComponent], 0, &componentString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_STRINGCREATEFAILED; goto cleanup; } } while (0)
373 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)PKIX_ERRORCLASSNAMES[logger->logComponent], 0, &componentString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_STRINGCREATEFAILED; goto cleanup; } } while (0)
374 PKIX_STRINGCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_String_Create (0, (void
*)PKIX_ERRORCLASSNAMES[logger->logComponent], 0, &componentString
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_STRINGCREATEFAILED; goto cleanup; } } while (0);
375
376 PKIX_CHECK(PKIX_PL_Sprintfdo { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (&loggerString
, plContext, formatString, contextString, logger->maxLevel
, componentString)); if (stdVars.aPkixErrorResult) { stdVars.
aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; } } while
(0)
377 (&loggerString,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (&loggerString
, plContext, formatString, contextString, logger->maxLevel
, componentString)); if (stdVars.aPkixErrorResult) { stdVars.
aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; } } while
(0)
378 plContext,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (&loggerString
, plContext, formatString, contextString, logger->maxLevel
, componentString)); if (stdVars.aPkixErrorResult) { stdVars.
aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; } } while
(0)
379 formatString,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (&loggerString
, plContext, formatString, contextString, logger->maxLevel
, componentString)); if (stdVars.aPkixErrorResult) { stdVars.
aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; } } while
(0)
380 contextString,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (&loggerString
, plContext, formatString, contextString, logger->maxLevel
, componentString)); if (stdVars.aPkixErrorResult) { stdVars.
aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; } } while
(0)
381 logger->maxLevel,do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (&loggerString
, plContext, formatString, contextString, logger->maxLevel
, componentString)); if (stdVars.aPkixErrorResult) { stdVars.
aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; } } while
(0)
382 componentString),do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (&loggerString
, plContext, formatString, contextString, logger->maxLevel
, componentString)); if (stdVars.aPkixErrorResult) { stdVars.
aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; } } while
(0)
383 PKIX_SPRINTFFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Sprintf (&loggerString
, plContext, formatString, contextString, logger->maxLevel
, componentString)); if (stdVars.aPkixErrorResult) { stdVars.
aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_SPRINTFFAILED; goto cleanup; } } while
(0);
384
385 *pString = loggerString;
386
387cleanup:
388
389 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);
390 PKIX_DECREF(contextString)do { if (contextString){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(contextString), plContext); if (stdVars.
aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult
, plContext); stdVars.aPkixTempResult = ((void*)0); } contextString
= ((void*)0); } } while (0);
391 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
392}
393
394/*
395 * FUNCTION: pkix_Logger_Equals
396 * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
397 */
398static PKIX_Error *
399pkix_Logger_Equals(
400 PKIX_PL_Object *first,
401 PKIX_PL_Object *second,
402 PKIX_Boolean *pResult,
403 void *plContext)
404{
405 PKIX_UInt32 secondType;
406 PKIX_Boolean cmpResult;
407 PKIX_Logger *firstLogger = NULL((void*)0);
408 PKIX_Logger *secondLogger = NULL((void*)0);
409
410 PKIX_ENTER(LOGGER, "pkix_Logger_Equals")static const char cMyFuncName[] = {"pkix_Logger_Equals"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
411 PKIX_NULLCHECK_THREE(first, second, pResult)do { if (((first) == ((void*)0)) || ((second) == ((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);
412
413 /* test that first is a Logger */
414 PKIX_CHECK(pkix_CheckType(first, PKIX_LOGGER_TYPE, plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType(first, PKIX_LOGGER_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_FIRSTOBJECTNOTLOGGER; goto cleanup; } } while (0)
415 PKIX_FIRSTOBJECTNOTLOGGER)do { stdVars.aPkixErrorResult = (pkix_CheckType(first, PKIX_LOGGER_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_FIRSTOBJECTNOTLOGGER; goto cleanup; } } while (0);
416
417 /*
418 * Since we know first is a Logger, if both references are
419 * identical, they must be equal
420 */
421 if (first == second){
422 *pResult = PKIX_TRUE((PKIX_Boolean) 1);
423 goto cleanup;
424 }
425
426 /*
427 * If second isn't a Logger, we don't throw an error.
428 * We simply return a Boolean result of FALSE
429 */
430 *pResult = PKIX_FALSE((PKIX_Boolean) 0);
431 PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_GetType(second
, &secondType, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_COULDNOTGETTYPEOFSECONDARGUMENT
; goto cleanup; } } while (0)
432 PKIX_COULDNOTGETTYPEOFSECONDARGUMENT)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_GetType(second
, &secondType, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_COULDNOTGETTYPEOFSECONDARGUMENT
; goto cleanup; } } while (0);
433 if (secondType != PKIX_LOGGER_TYPE) goto cleanup;
434
435 firstLogger = (PKIX_Logger *)first;
436 secondLogger = (PKIX_Logger *)second;
437
438 cmpResult = PKIX_FALSE((PKIX_Boolean) 0);
439
440 if (firstLogger->callback != secondLogger->callback) {
441 goto cleanup;
442 }
443
444 if (firstLogger->logComponent != secondLogger->logComponent) {
445 goto cleanup;
446 }
447
448 PKIX_EQUALSdo { if ((firstLogger->context) != ((void*)0) && (
secondLogger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Equals ((PKIX_PL_Object *)(firstLogger->
context), (PKIX_PL_Object*)(secondLogger->context), (&
cmpResult), (plContext))); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = (PKIX_OBJECTEQUALSFAILED); goto cleanup; } }
while (0); } else if ((firstLogger->context) == ((void*)0
) && (secondLogger->context) == ((void*)0)) { *(&
cmpResult) = ((PKIX_Boolean) 1); } else { *(&cmpResult) =
((PKIX_Boolean) 0); } } while (0)
449 (firstLogger->context,do { if ((firstLogger->context) != ((void*)0) && (
secondLogger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Equals ((PKIX_PL_Object *)(firstLogger->
context), (PKIX_PL_Object*)(secondLogger->context), (&
cmpResult), (plContext))); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = (PKIX_OBJECTEQUALSFAILED); goto cleanup; } }
while (0); } else if ((firstLogger->context) == ((void*)0
) && (secondLogger->context) == ((void*)0)) { *(&
cmpResult) = ((PKIX_Boolean) 1); } else { *(&cmpResult) =
((PKIX_Boolean) 0); } } while (0)
450 secondLogger->context,do { if ((firstLogger->context) != ((void*)0) && (
secondLogger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Equals ((PKIX_PL_Object *)(firstLogger->
context), (PKIX_PL_Object*)(secondLogger->context), (&
cmpResult), (plContext))); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = (PKIX_OBJECTEQUALSFAILED); goto cleanup; } }
while (0); } else if ((firstLogger->context) == ((void*)0
) && (secondLogger->context) == ((void*)0)) { *(&
cmpResult) = ((PKIX_Boolean) 1); } else { *(&cmpResult) =
((PKIX_Boolean) 0); } } while (0)
451 &cmpResult,do { if ((firstLogger->context) != ((void*)0) && (
secondLogger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Equals ((PKIX_PL_Object *)(firstLogger->
context), (PKIX_PL_Object*)(secondLogger->context), (&
cmpResult), (plContext))); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = (PKIX_OBJECTEQUALSFAILED); goto cleanup; } }
while (0); } else if ((firstLogger->context) == ((void*)0
) && (secondLogger->context) == ((void*)0)) { *(&
cmpResult) = ((PKIX_Boolean) 1); } else { *(&cmpResult) =
((PKIX_Boolean) 0); } } while (0)
452 plContext,do { if ((firstLogger->context) != ((void*)0) && (
secondLogger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Equals ((PKIX_PL_Object *)(firstLogger->
context), (PKIX_PL_Object*)(secondLogger->context), (&
cmpResult), (plContext))); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = (PKIX_OBJECTEQUALSFAILED); goto cleanup; } }
while (0); } else if ((firstLogger->context) == ((void*)0
) && (secondLogger->context) == ((void*)0)) { *(&
cmpResult) = ((PKIX_Boolean) 1); } else { *(&cmpResult) =
((PKIX_Boolean) 0); } } while (0)
453 PKIX_OBJECTEQUALSFAILED)do { if ((firstLogger->context) != ((void*)0) && (
secondLogger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Equals ((PKIX_PL_Object *)(firstLogger->
context), (PKIX_PL_Object*)(secondLogger->context), (&
cmpResult), (plContext))); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = (PKIX_OBJECTEQUALSFAILED); goto cleanup; } }
while (0); } else if ((firstLogger->context) == ((void*)0
) && (secondLogger->context) == ((void*)0)) { *(&
cmpResult) = ((PKIX_Boolean) 1); } else { *(&cmpResult) =
((PKIX_Boolean) 0); } } while (0);
454
455 if (cmpResult == PKIX_FALSE((PKIX_Boolean) 0)) {
456 goto cleanup;
457 }
458
459 if (firstLogger->maxLevel != secondLogger->maxLevel) {
460 goto cleanup;
461 }
462
463 *pResult = cmpResult;
464
465cleanup:
466
467 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
468}
469
470/*
471 * FUNCTION: pkix_Logger_Hashcode
472 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
473 */
474static PKIX_Error *
475pkix_Logger_Hashcode(
476 PKIX_PL_Object *object,
477 PKIX_UInt32 *pHashcode,
478 void *plContext)
479{
480 PKIX_Logger *logger = NULL((void*)0);
481 PKIX_UInt32 hash = 0;
482 PKIX_UInt32 tempHash = 0;
483
484 PKIX_ENTER(LOGGER, "pkix_Logger_Hashcode")static const char cMyFuncName[] = {"pkix_Logger_Hashcode"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
485 PKIX_NULLCHECK_TWO(object, pHashcode)do { if (((object) == ((void*)0)) || ((pHashcode) == ((void*)
0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
486
487 PKIX_CHECK(pkix_CheckType(object, PKIX_LOGGER_TYPE, plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType(object, PKIX_LOGGER_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTLOGGER; goto cleanup; } } while (0)
488 PKIX_OBJECTNOTLOGGER)do { stdVars.aPkixErrorResult = (pkix_CheckType(object, PKIX_LOGGER_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTLOGGER; goto cleanup; } } while (0);
489
490 logger = (PKIX_Logger *)object;
491
492 PKIX_HASHCODE(logger->context, &tempHash, plContext,do { if ((logger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Hashcode ((PKIX_PL_Object *)(logger->context
), (&tempHash), (plContext))); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = (PKIX_OBJECTHASHCODEFAILED); goto cleanup
; } } while (0); } else { *(&tempHash) = 0; } } while (0)
493 PKIX_OBJECTHASHCODEFAILED)do { if ((logger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Hashcode ((PKIX_PL_Object *)(logger->context
), (&tempHash), (plContext))); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = (PKIX_OBJECTHASHCODEFAILED); goto cleanup
; } } while (0); } else { *(&tempHash) = 0; } } while (0);
494
495 hash = (((((PKIX_UInt32)((char *)logger->callback - (char *)NULL((void*)0)) + tempHash) << 7) +
496 logger->maxLevel) << 7) + (PKIX_UInt32)logger->logComponent;
497
498 *pHashcode = hash;
499
500cleanup:
501
502 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
503}
504
505
506/*
507 * FUNCTION: pkix_Logger_Duplicate
508 * (see comments for PKIX_PL_DuplicateCallback in pkix_pl_system.h)
509 */
510static PKIX_Error *
511pkix_Logger_Duplicate(
512 PKIX_PL_Object *object,
513 PKIX_PL_Object **pNewObject,
514 void *plContext)
515{
516 PKIX_Logger *logger = NULL((void*)0);
517 PKIX_Logger *dupLogger = NULL((void*)0);
518
519 PKIX_ENTER(LOGGER, "pkix_Logger_Duplicate")static const char cMyFuncName[] = {"pkix_Logger_Duplicate"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
520 PKIX_NULLCHECK_TWO(object, pNewObject)do { if (((object) == ((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);
521
522 PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)object, PKIX_LOGGER_TYPE, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTNOTLOGGER; goto cleanup
; } } while (0)
523 ((PKIX_PL_Object *)object, PKIX_LOGGER_TYPE, plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)object, PKIX_LOGGER_TYPE, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTNOTLOGGER; goto cleanup
; } } while (0)
524 PKIX_OBJECTNOTLOGGER)do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)object, PKIX_LOGGER_TYPE, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTNOTLOGGER; goto cleanup
; } } while (0);
525
526 logger = (PKIX_Logger *) object;
527
528 PKIX_CHECK(PKIX_PL_Object_Allocdo { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&dupLogger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
529 (PKIX_LOGGER_TYPE,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&dupLogger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
530 sizeof (PKIX_Logger),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&dupLogger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
531 (PKIX_PL_Object **)&dupLogger,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&dupLogger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
532 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&dupLogger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
533 PKIX_COULDNOTCREATELOGGEROBJECT)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&dupLogger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0);
534
535 dupLogger->callback = logger->callback;
536 dupLogger->maxLevel = logger->maxLevel;
537
538 PKIX_DUPLICATEdo { if ((logger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Duplicate ((PKIX_PL_Object *)(logger->context
), (PKIX_PL_Object **)(&dupLogger->context), (plContext
))); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= (PKIX_OBJECTDUPLICATEFAILED); goto cleanup; } } while (0);
} else { *(&dupLogger->context) = (logger->context
); } } while (0)
539 (logger->context,do { if ((logger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Duplicate ((PKIX_PL_Object *)(logger->context
), (PKIX_PL_Object **)(&dupLogger->context), (plContext
))); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= (PKIX_OBJECTDUPLICATEFAILED); goto cleanup; } } while (0);
} else { *(&dupLogger->context) = (logger->context
); } } while (0)
540 &dupLogger->context,do { if ((logger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Duplicate ((PKIX_PL_Object *)(logger->context
), (PKIX_PL_Object **)(&dupLogger->context), (plContext
))); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= (PKIX_OBJECTDUPLICATEFAILED); goto cleanup; } } while (0);
} else { *(&dupLogger->context) = (logger->context
); } } while (0)
541 plContext,do { if ((logger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Duplicate ((PKIX_PL_Object *)(logger->context
), (PKIX_PL_Object **)(&dupLogger->context), (plContext
))); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= (PKIX_OBJECTDUPLICATEFAILED); goto cleanup; } } while (0);
} else { *(&dupLogger->context) = (logger->context
); } } while (0)
542 PKIX_OBJECTDUPLICATEFAILED)do { if ((logger->context) != ((void*)0)) { do { stdVars.aPkixErrorResult
= (PKIX_PL_Object_Duplicate ((PKIX_PL_Object *)(logger->context
), (PKIX_PL_Object **)(&dupLogger->context), (plContext
))); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= (PKIX_OBJECTDUPLICATEFAILED); goto cleanup; } } while (0);
} else { *(&dupLogger->context) = (logger->context
); } } while (0);
543
544 dupLogger->logComponent = logger->logComponent;
545
546 *pNewObject = (PKIX_PL_Object *) dupLogger;
547
548cleanup:
549
550 if (PKIX_ERROR_RECEIVED(stdVars.aPkixErrorReceived || stdVars.aPkixErrorResult || stdVars
.aPkixTempErrorReceived || stdVars.aPkixErrorList)){
551 PKIX_DECREF(dupLogger)do { if (dupLogger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(dupLogger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } dupLogger = ((void
*)0); } } while (0);
552 }
553
554 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
555}
556
557/*
558 * FUNCTION: pkix_Logger_RegisterSelf
559 * DESCRIPTION:
560 * Registers PKIX_LOGGER_TYPE and its related functions with systemClasses[]
561 * THREAD SAFETY:
562 * Not Thread Safe - for performance and complexity reasons
563 *
564 * Since this function is only called by PKIX_PL_Initialize, which should
565 * only be called once, it is acceptable that this function is not
566 * thread-safe.
567 */
568PKIX_Error *
569pkix_Logger_RegisterSelf(void *plContext)
570{
571 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
572 pkix_ClassTable_Entry entry;
573
574 PKIX_ENTER(LOGGER, "pkix_Logger_RegisterSelf")static const char cMyFuncName[] = {"pkix_Logger_RegisterSelf"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
575
576 entry.description = "Logger";
577 entry.objCounter = 0;
578 entry.typeObjectSize = sizeof(PKIX_Logger);
579 entry.destructor = pkix_Logger_Destroy;
580 entry.equalsFunction = pkix_Logger_Equals;
581 entry.hashcodeFunction = pkix_Logger_Hashcode;
582 entry.toStringFunction = pkix_Logger_ToString;
583 entry.comparator = NULL((void*)0);
584 entry.duplicateFunction = pkix_Logger_Duplicate;
585
586 systemClasses[PKIX_LOGGER_TYPE] = entry;
587
588 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
589}
590
591/* --Public-Logger-Functions--------------------------------------------- */
592
593/*
594 * FUNCTION: PKIX_Logger_Create (see comments in pkix_util.h)
595 */
596PKIX_Error *
597PKIX_Logger_Create(
598 PKIX_Logger_LogCallback callback,
599 PKIX_PL_Object *loggerContext,
600 PKIX_Logger **pLogger,
601 void *plContext)
602{
603 PKIX_Logger *logger = NULL((void*)0);
604
605 PKIX_ENTER(LOGGER, "PKIX_Logger_Create")static const char cMyFuncName[] = {"PKIX_Logger_Create"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
606 PKIX_NULLCHECK_ONE(pLogger)do { if ((pLogger) == ((void*)0)){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
607
608 PKIX_CHECK(PKIX_PL_Object_Allocdo { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&logger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
609 (PKIX_LOGGER_TYPE,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&logger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
610 sizeof (PKIX_Logger),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&logger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
611 (PKIX_PL_Object **)&logger,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&logger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
612 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&logger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0)
613 PKIX_COULDNOTCREATELOGGEROBJECT)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LOGGER_TYPE
, sizeof (PKIX_Logger), (PKIX_PL_Object **)&logger, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_COULDNOTCREATELOGGEROBJECT; goto cleanup; } } while (
0);
614
615 logger->callback = callback;
616 logger->maxLevel = 0;
617 logger->logComponent = (PKIX_ERRORCLASS)0;
618
619 PKIX_INCREF(loggerContext)do { if (loggerContext){ stdVars.aPkixTempResult = PKIX_PL_Object_IncRef
((PKIX_PL_Object *)(loggerContext), plContext); if (stdVars.
aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult
, plContext); stdVars.aPkixTempResult = ((void*)0); goto cleanup
; } } } while (0);
620 logger->context = loggerContext;
621
622 *pLogger = logger;
623 logger = NULL((void*)0);
624
625cleanup:
626
627 PKIX_DECREF(logger)do { if (logger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(logger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } logger = ((void*)0
); } } while (0);
628
629 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
630}
631
632/*
633 * FUNCTION: PKIX_Logger_GetLogCallback (see comments in pkix_util.h)
634 */
635PKIX_Error *
636PKIX_Logger_GetLogCallback(
637 PKIX_Logger *logger,
638 PKIX_Logger_LogCallback *pCallback,
639 void *plContext)
640{
641 PKIX_ENTER(LOGGER, "PKIX_Logger_GetLogCallback")static const char cMyFuncName[] = {"PKIX_Logger_GetLogCallback"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
642 PKIX_NULLCHECK_TWO(logger, pCallback)do { if (((logger) == ((void*)0)) || ((pCallback) == ((void*)
0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
643
644 *pCallback = logger->callback;
645
646 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
647}
648
649/*
650 * FUNCTION: PKIX_Logger_GetLoggerContext (see comments in pkix_util.h)
651 */
652PKIX_Error *
653PKIX_Logger_GetLoggerContext(
654 PKIX_Logger *logger,
655 PKIX_PL_Object **pLoggerContext,
656 void *plContext)
657{
658 PKIX_ENTER(LOGGER, "PKIX_Logger_GetLoggerContex")static const char cMyFuncName[] = {"PKIX_Logger_GetLoggerContex"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
659 PKIX_NULLCHECK_TWO(logger, pLoggerContext)do { if (((logger) == ((void*)0)) || ((pLoggerContext) == ((void
*)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
660
661 PKIX_INCREF(logger->context)do { if (logger->context){ stdVars.aPkixTempResult = PKIX_PL_Object_IncRef
((PKIX_PL_Object *)(logger->context), plContext); if (stdVars
.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult
, plContext); stdVars.aPkixTempResult = ((void*)0); goto cleanup
; } } } while (0);
662 *pLoggerContext = logger->context;
663
664cleanup:
665 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
666}
667
668/*
669 * FUNCTION: PKIX_Logger_GetMaxLoggingLevel (see comments in pkix_util.h)
670 */
671PKIX_Error *
672PKIX_Logger_GetMaxLoggingLevel(
673 PKIX_Logger *logger,
674 PKIX_UInt32 *pLevel,
675 void *plContext)
676{
677 PKIX_ENTER(LOGGER, "PKIX_Logger_GetMaxLoggingLevel")static const char cMyFuncName[] = {"PKIX_Logger_GetMaxLoggingLevel"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
678 PKIX_NULLCHECK_TWO(logger, pLevel)do { if (((logger) == ((void*)0)) || ((pLevel) == ((void*)0))
){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_NULLARGUMENT; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR
), ((PKIX_Boolean) 1), plContext);; } } while (0);
679
680 *pLevel = logger->maxLevel;
681
682 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
683}
684
685/*
686 * FUNCTION: PKIX_Logger_SetMaxLoggingLevel (see comments in pkix_util.h)
687 */
688PKIX_Error *
689PKIX_Logger_SetMaxLoggingLevel(
690 PKIX_Logger *logger,
691 PKIX_UInt32 level,
692 void *plContext)
693{
694 PKIX_ENTER(LOGGER, "PKIX_Logger_SetMaxLoggingLevel")static const char cMyFuncName[] = {"PKIX_Logger_SetMaxLoggingLevel"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
695 PKIX_NULLCHECK_ONE(logger)do { if ((logger) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
696
697 if (level > PKIX_LOGGER_LEVEL_MAX5) {
698 PKIX_ERROR(PKIX_LOGGINGLEVELEXCEEDSMAXIMUM){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_LOGGINGLEVELEXCEEDSMAXIMUM, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_LOGGINGLEVELEXCEEDSMAXIMUM
; goto cleanup; };
699 } else {
700 logger->maxLevel = level;
701 }
702
703cleanup:
704
705 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
706}
707
708/*
709 * FUNCTION: PKIX_Logger_GetLoggingComponent (see comments in pkix_util.h)
710 */
711PKIX_Error *
712PKIX_Logger_GetLoggingComponent(
713 PKIX_Logger *logger,
714 PKIX_ERRORCLASS *pComponent,
715 void *plContext)
716{
717 PKIX_ENTER(LOGGER, "PKIX_Logger_GetLoggingComponent")static const char cMyFuncName[] = {"PKIX_Logger_GetLoggingComponent"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
718 PKIX_NULLCHECK_TWO(logger, pComponent)do { if (((logger) == ((void*)0)) || ((pComponent) == ((void*
)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
719
720 *pComponent = logger->logComponent;
721
722 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
723}
724
725/*
726 * FUNCTION: PKIX_Logger_SetLoggingComponent (see comments in pkix_util.h)
727 */
728PKIX_Error *
729PKIX_Logger_SetLoggingComponent(
730 PKIX_Logger *logger,
731 PKIX_ERRORCLASS component,
732 void *plContext)
733{
734 PKIX_ENTER(LOGGER, "PKIX_Logger_SetLoggingComponent")static const char cMyFuncName[] = {"PKIX_Logger_SetLoggingComponent"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
735 PKIX_NULLCHECK_ONE(logger)do { if ((logger) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
736
737 logger->logComponent = component;
738
739 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
740}
741
742
743/*
744 * Following PKIX_GetLoggers(), PKIX_SetLoggers() and PKIX_AddLogger() are
745 * documented as not thread-safe. However they are thread-safe now. We need
746 * the lock when accessing the logger lists.
747 */
748
749/*
750 * FUNCTION: PKIX_Logger_GetLoggers (see comments in pkix_util.h)
751 */
752PKIX_Error *
753PKIX_GetLoggers(
754 PKIX_List **pLoggers, /* list of PKIX_Logger */
755 void *plContext)
756{
757 PKIX_List *list = NULL((void*)0);
758 PKIX_List *savedPkixLoggersDebugTrace = NULL((void*)0);
759 PKIX_List *savedPkixLoggersErrors = NULL((void*)0);
760 PKIX_Logger *logger = NULL((void*)0);
761 PKIX_Logger *dupLogger = NULL((void*)0);
762 PKIX_UInt32 i, length;
763 PKIX_Boolean locked = PKIX_FALSE((PKIX_Boolean) 0);
764
765 PKIX_ENTER(LOGGER, "PKIX_Logger_GetLoggers")static const char cMyFuncName[] = {"PKIX_Logger_GetLoggers"};
PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
766 PKIX_NULLCHECK_ONE(pLoggers)do { if ((pLoggers) == ((void*)0)){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
767
768 PKIX_CHECK(PKIX_PL_MonitorLock_Enter(pkixLoggerLock, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Enter(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKENTERFAILED; goto cleanup; } } while (0)
769 PKIX_MONITORLOCKENTERFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Enter(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKENTERFAILED; goto cleanup; } } while (0);
770 locked = PKIX_TRUE((PKIX_Boolean) 1);
771
772 /*
773 * Temporarily disable DEBUG/TRACE Logging to avoid possible
774 * deadlock:
775 * When the Logger List is being accessed, e.g. by PKIX_ENTER or
776 * PKIX_DECREF, pkix_Logger_Check may check whether logging
777 * is requested, creating a deadlock situation.
778 */
779 savedPkixLoggersDebugTrace = pkixLoggersDebugTrace;
780 pkixLoggersDebugTrace = NULL((void*)0);
781 savedPkixLoggersErrors = pkixLoggersErrors;
782 pkixLoggersErrors = NULL((void*)0);
783
784 if (pkixLoggers == NULL((void*)0)) {
785 length = 0;
786 } else {
787 PKIX_CHECK(PKIX_List_GetLengthdo { stdVars.aPkixErrorResult = (PKIX_List_GetLength (pkixLoggers
, &length, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LISTGETLENGTHFAILED; goto cleanup; } }
while (0)
788 (pkixLoggers, &length, plContext),do { stdVars.aPkixErrorResult = (PKIX_List_GetLength (pkixLoggers
, &length, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LISTGETLENGTHFAILED; goto cleanup; } }
while (0)
789 PKIX_LISTGETLENGTHFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_GetLength (pkixLoggers
, &length, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LISTGETLENGTHFAILED; goto cleanup; } }
while (0);
790 }
791
792 /* Create a list and copy the pkixLoggers item to the list */
793 PKIX_CHECK(PKIX_List_Create(&list, plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create(&list, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
794 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create(&list, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0);
795
796 for (i = 0; i < length; i++) {
797
798 PKIX_CHECK(PKIX_List_GetItemdo { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &logger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
799 (pkixLoggers,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &logger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
800 i,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &logger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
801 (PKIX_PL_Object **) &logger,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &logger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
802 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &logger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
803 PKIX_LISTGETITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &logger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0);
804
805 PKIX_CHECK(pkix_Logger_Duplicatedo { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
806 ((PKIX_PL_Object *)logger,do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
807 (PKIX_PL_Object **)&dupLogger,do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
808 plContext),do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
809 PKIX_LOGGERDUPLICATEFAILED)do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0);
810
811 PKIX_CHECK(PKIX_List_AppendItemdo { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
812 (list,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
813 (PKIX_PL_Object *) dupLogger,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
814 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
815 PKIX_LISTAPPENDITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0);
816
817 PKIX_DECREF(logger)do { if (logger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(logger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } logger = ((void*)0
); } } while (0);
818 PKIX_DECREF(dupLogger)do { if (dupLogger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(dupLogger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } dupLogger = ((void
*)0); } } while (0);
819 }
820
821 /* Set the list to be immutable */
822 PKIX_CHECK(PKIX_List_SetImmutable(list, plContext),do { stdVars.aPkixErrorResult = (PKIX_List_SetImmutable(list,
plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTSETIMMUTABLEFAILED; goto cleanup; } } while (0)
823 PKIX_LISTSETIMMUTABLEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_SetImmutable(list,
plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTSETIMMUTABLEFAILED; goto cleanup; } } while (0);
824
825 *pLoggers = list;
826
827cleanup:
828
829 PKIX_DECREF(logger)do { if (logger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(logger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } logger = ((void*)0
); } } while (0);
830
831 /* Restore logging capability */
832 pkixLoggersDebugTrace = savedPkixLoggersDebugTrace;
833 pkixLoggersErrors = savedPkixLoggersErrors;
834
835 if (locked) {
836 PKIX_CHECK(PKIX_PL_MonitorLock_Exit(pkixLoggerLock, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Exit(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKEXITFAILED; goto cleanup; } } while (0)
837 PKIX_MONITORLOCKEXITFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Exit(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKEXITFAILED; goto cleanup; } } while (0);
838 }
839
840 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
841}
842
843/*
844 * FUNCTION: PKIX_Logger_SetLoggers (see comments in pkix_util.h)
845 */
846PKIX_Error *
847PKIX_SetLoggers(
848 PKIX_List *loggers, /* list of PKIX_Logger */
849 void *plContext)
850{
851 PKIX_List *list = NULL((void*)0);
852 PKIX_List *savedPkixLoggersErrors = NULL((void*)0);
853 PKIX_List *savedPkixLoggersDebugTrace = NULL((void*)0);
854 PKIX_Logger *logger = NULL((void*)0);
855 PKIX_Logger *dupLogger = NULL((void*)0);
856 PKIX_Boolean locked = PKIX_FALSE((PKIX_Boolean) 0);
857 PKIX_UInt32 i, length;
858
859 PKIX_ENTER(LOGGER, "PKIX_SetLoggers")static const char cMyFuncName[] = {"PKIX_SetLoggers"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
860
861 PKIX_CHECK(PKIX_PL_MonitorLock_Enter(pkixLoggerLock, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Enter(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKENTERFAILED; goto cleanup; } } while (0)
862 PKIX_MONITORLOCKENTERFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Enter(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKENTERFAILED; goto cleanup; } } while (0);
863 locked = PKIX_TRUE((PKIX_Boolean) 1);
864
865 /* Disable tracing, etc. to avoid recursion and deadlock */
866 savedPkixLoggersDebugTrace = pkixLoggersDebugTrace;
867 pkixLoggersDebugTrace = NULL((void*)0);
868 savedPkixLoggersErrors = pkixLoggersErrors;
869 pkixLoggersErrors = NULL((void*)0);
870
871 /* discard any prior loggers */
872 PKIX_DECREF(pkixLoggers)do { if (pkixLoggers){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(pkixLoggers), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } pkixLoggers = ((void
*)0); } } while (0);
873 PKIX_DECREF(savedPkixLoggersErrors)do { if (savedPkixLoggersErrors){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(savedPkixLoggersErrors), plContext); if (
stdVars.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars
.aPkixTempResult, plContext); stdVars.aPkixTempResult = ((void
*)0); } savedPkixLoggersErrors = ((void*)0); } } while (0);
874 PKIX_DECREF(savedPkixLoggersDebugTrace)do { if (savedPkixLoggersDebugTrace){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(savedPkixLoggersDebugTrace
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } savedPkixLoggersDebugTrace = ((void*)0); } }
while (0);
875
876 if (loggers != NULL((void*)0)) {
877
878 PKIX_CHECK(PKIX_List_Create(&list, plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create(&list, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
879 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create(&list, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0);
880
881 PKIX_CHECK(PKIX_List_GetLength(loggers, &length, plContext),do { stdVars.aPkixErrorResult = (PKIX_List_GetLength(loggers,
&length, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LISTGETLENGTHFAILED; goto cleanup; } }
while (0)
882 PKIX_LISTGETLENGTHFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_GetLength(loggers,
&length, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LISTGETLENGTHFAILED; goto cleanup; } }
while (0);
883
884 for (i = 0; i < length; i++) {
885
886 PKIX_CHECK(PKIX_List_GetItemdo { stdVars.aPkixErrorResult = (PKIX_List_GetItem (loggers, i
, (PKIX_PL_Object **) &logger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED; goto cleanup
; } } while (0)
887 (loggers,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (loggers, i
, (PKIX_PL_Object **) &logger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED; goto cleanup
; } } while (0)
888 i,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (loggers, i
, (PKIX_PL_Object **) &logger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED; goto cleanup
; } } while (0)
889 (PKIX_PL_Object **) &logger,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (loggers, i
, (PKIX_PL_Object **) &logger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED; goto cleanup
; } } while (0)
890 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (loggers, i
, (PKIX_PL_Object **) &logger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED; goto cleanup
; } } while (0)
891 PKIX_LISTGETITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (loggers, i
, (PKIX_PL_Object **) &logger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED; goto cleanup
; } } while (0);
892
893 PKIX_CHECK(pkix_Logger_Duplicatedo { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
894 ((PKIX_PL_Object *)logger,do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
895 (PKIX_PL_Object **)&dupLogger,do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
896 plContext),do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
897 PKIX_LOGGERDUPLICATEFAILED)do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0);
898
899 PKIX_CHECK(PKIX_List_AppendItemdo { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
900 (list,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
901 (PKIX_PL_Object *) dupLogger,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
902 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
903 PKIX_LISTAPPENDITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (list, (
PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0);
904
905 /* Make two lists */
906
907 /* Put in pkixLoggersErrors in any case*/
908
909 if (savedPkixLoggersErrors == NULL((void*)0)) {
910
911 PKIX_CHECK(PKIX_List_Createdo { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersErrors
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
912 (&savedPkixLoggersErrors,do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersErrors
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
913 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersErrors
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
914 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersErrors
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0);
915 }
916
917 PKIX_CHECK(PKIX_List_AppendItemdo { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
918 (savedPkixLoggersErrors,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
919 (PKIX_PL_Object *) dupLogger,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
920 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
921 PKIX_LISTAPPENDITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0);
922
923 if (logger->maxLevel > PKIX_LOGGER_LEVEL_WARNING3) {
924
925 /* Put in pkixLoggersDebugTrace */
926
927 if (savedPkixLoggersDebugTrace == NULL((void*)0)) {
928
929 PKIX_CHECK(PKIX_List_Createdo { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersDebugTrace
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
930 (&savedPkixLoggersDebugTrace,do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersDebugTrace
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
931 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersDebugTrace
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
932 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersDebugTrace
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0);
933 }
934
935 PKIX_CHECK(PKIX_List_AppendItemdo { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
936 (savedPkixLoggersDebugTrace,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
937 (PKIX_PL_Object *) dupLogger,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
938 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
939 PKIX_LISTAPPENDITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0);
940 }
941 PKIX_DECREF(logger)do { if (logger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(logger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } logger = ((void*)0
); } } while (0);
942 PKIX_DECREF(dupLogger)do { if (dupLogger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(dupLogger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } dupLogger = ((void
*)0); } } while (0);
943
944 }
945
946 pkixLoggers = list;
947 }
948
949cleanup:
950
951 if (PKIX_ERROR_RECEIVED(stdVars.aPkixErrorReceived || stdVars.aPkixErrorResult || stdVars
.aPkixTempErrorReceived || stdVars.aPkixErrorList)){
952 PKIX_DECREF(list)do { if (list){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(list), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } list = ((void*)0);
} } while (0);
953 PKIX_DECREF(savedPkixLoggersErrors)do { if (savedPkixLoggersErrors){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(savedPkixLoggersErrors), plContext); if (
stdVars.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars
.aPkixTempResult, plContext); stdVars.aPkixTempResult = ((void
*)0); } savedPkixLoggersErrors = ((void*)0); } } while (0);
954 PKIX_DECREF(savedPkixLoggersDebugTrace)do { if (savedPkixLoggersDebugTrace){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(savedPkixLoggersDebugTrace
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } savedPkixLoggersDebugTrace = ((void*)0); } }
while (0);
955 pkixLoggers = NULL((void*)0);
956 }
957
958 PKIX_DECREF(logger)do { if (logger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(logger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } logger = ((void*)0
); } } while (0);
959
960 /* Reenable logging capability with new lists */
961 pkixLoggersErrors = savedPkixLoggersErrors;
962 pkixLoggersDebugTrace = savedPkixLoggersDebugTrace;
963
964 if (locked) {
965 PKIX_CHECK(PKIX_PL_MonitorLock_Exit(pkixLoggerLock, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Exit(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKEXITFAILED; goto cleanup; } } while (0)
966 PKIX_MONITORLOCKEXITFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Exit(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKEXITFAILED; goto cleanup; } } while (0);
967 }
968
969 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
970}
971
972/*
973 * FUNCTION: PKIX_Logger_AddLogger (see comments in pkix_util.h)
974 */
975PKIX_Error *
976PKIX_AddLogger(
977 PKIX_Logger *logger,
978 void *plContext)
979{
980 PKIX_Logger *dupLogger = NULL((void*)0);
981 PKIX_Logger *addLogger = NULL((void*)0);
982 PKIX_List *savedPkixLoggersErrors = NULL((void*)0);
983 PKIX_List *savedPkixLoggersDebugTrace = NULL((void*)0);
984 PKIX_Boolean locked = PKIX_FALSE((PKIX_Boolean) 0);
985 PKIX_UInt32 i, length;
986
987 PKIX_ENTER(LOGGER, "PKIX_Logger_AddLogger")static const char cMyFuncName[] = {"PKIX_Logger_AddLogger"}; PKIX_StdVars
stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName; stdVars
.aPkixType = PKIX_LOGGER_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
988 PKIX_NULLCHECK_ONE(logger)do { if ((logger) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
989
990 PKIX_CHECK(PKIX_PL_MonitorLock_Enter(pkixLoggerLock, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Enter(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKENTERFAILED; goto cleanup; } } while (0)
991 PKIX_MONITORLOCKENTERFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Enter(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKENTERFAILED; goto cleanup; } } while (0);
992 locked = PKIX_TRUE((PKIX_Boolean) 1);
993
994 savedPkixLoggersDebugTrace = pkixLoggersDebugTrace;
995 pkixLoggersDebugTrace = NULL((void*)0);
996 savedPkixLoggersErrors = pkixLoggersErrors;
997 pkixLoggersErrors = NULL((void*)0);
998
999 PKIX_DECREF(savedPkixLoggersErrors)do { if (savedPkixLoggersErrors){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(savedPkixLoggersErrors), plContext); if (
stdVars.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars
.aPkixTempResult, plContext); stdVars.aPkixTempResult = ((void
*)0); } savedPkixLoggersErrors = ((void*)0); } } while (0);
1000 PKIX_DECREF(savedPkixLoggersDebugTrace)do { if (savedPkixLoggersDebugTrace){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(savedPkixLoggersDebugTrace
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } savedPkixLoggersDebugTrace = ((void*)0); } }
while (0);
1001
1002 if (pkixLoggers == NULL((void*)0)) {
1003
1004 PKIX_CHECK(PKIX_List_Create(&pkixLoggers, plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create(&pkixLoggers
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
1005 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create(&pkixLoggers
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0);
1006 }
1007
1008 PKIX_CHECK(pkix_Logger_Duplicatedo { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
1009 ((PKIX_PL_Object *)logger,do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
1010 (PKIX_PL_Object **)&dupLogger,do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
1011 plContext),do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0)
1012 PKIX_LOGGERDUPLICATEFAILED)do { stdVars.aPkixErrorResult = (pkix_Logger_Duplicate ((PKIX_PL_Object
*)logger, (PKIX_PL_Object **)&dupLogger, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LOGGERDUPLICATEFAILED
; goto cleanup; } } while (0);
1013
1014 PKIX_CHECK(PKIX_List_AppendItemdo { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (pkixLoggers
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1015 (pkixLoggers,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (pkixLoggers
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1016 (PKIX_PL_Object *) dupLogger,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (pkixLoggers
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1017 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (pkixLoggers
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1018 PKIX_LISTAPPENDITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (pkixLoggers
, (PKIX_PL_Object *) dupLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0);
1019
1020 PKIX_CHECK(PKIX_List_GetLength(pkixLoggers, &length, plContext),do { stdVars.aPkixErrorResult = (PKIX_List_GetLength(pkixLoggers
, &length, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LISTGETLENGTHFAILED; goto cleanup; } }
while (0)
1021 PKIX_LISTGETLENGTHFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_GetLength(pkixLoggers
, &length, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LISTGETLENGTHFAILED; goto cleanup; } }
while (0);
1022
1023 /* Reconstruct pkixLoggersErrors and pkixLoggersDebugTrace */
1024 for (i = 0; i < length; i++) {
1025
1026 PKIX_CHECK(PKIX_List_GetItemdo { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &addLogger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
1027 (pkixLoggers,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &addLogger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
1028 i,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &addLogger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
1029 (PKIX_PL_Object **) &addLogger,do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &addLogger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
1030 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &addLogger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0)
1031 PKIX_LISTGETITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_GetItem (pkixLoggers
, i, (PKIX_PL_Object **) &addLogger, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LISTGETITEMFAILED
; goto cleanup; } } while (0);
1032
1033
1034 /* Put in pkixLoggersErrors */
1035
1036 if (savedPkixLoggersErrors == NULL((void*)0)) {
1037
1038 PKIX_CHECK(PKIX_List_Createdo { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersErrors
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
1039 (&savedPkixLoggersErrors,do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersErrors
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
1040 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersErrors
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
1041 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersErrors
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0);
1042 }
1043
1044 PKIX_CHECK(PKIX_List_AppendItemdo { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1045 (savedPkixLoggersErrors,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1046 (PKIX_PL_Object *) addLogger,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1047 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1048 PKIX_LISTAPPENDITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersErrors
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0);
1049
1050 if (addLogger->maxLevel > PKIX_LOGGER_LEVEL_WARNING3) {
1051
1052 /* Put in pkixLoggersDebugTrace */
1053
1054 if (savedPkixLoggersDebugTrace == NULL((void*)0)) {
1055
1056 PKIX_CHECK(PKIX_List_Createdo { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersDebugTrace
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
1057 (&savedPkixLoggersDebugTrace,do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersDebugTrace
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
1058 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersDebugTrace
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0)
1059 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create (&savedPkixLoggersDebugTrace
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTCREATEFAILED; goto cleanup; } } while (0);
1060 }
1061
1062 PKIX_CHECK(PKIX_List_AppendItemdo { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1063 (savedPkixLoggersDebugTrace,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1064 (PKIX_PL_Object *) addLogger,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1065 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0)
1066 PKIX_LISTAPPENDITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (savedPkixLoggersDebugTrace
, (PKIX_PL_Object *) addLogger, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTAPPENDITEMFAILED; goto cleanup
; } } while (0);
1067 }
1068
1069 PKIX_DECREF(addLogger)do { if (addLogger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(addLogger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } addLogger = ((void
*)0); } } while (0);
1070
1071 }
1072
1073cleanup:
1074
1075 PKIX_DECREF(dupLogger)do { if (dupLogger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(dupLogger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } dupLogger = ((void
*)0); } } while (0);
1076 PKIX_DECREF(addLogger)do { if (addLogger){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(addLogger), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } addLogger = ((void
*)0); } } while (0);
1077
1078 /* Restore logging capability */
1079 pkixLoggersErrors = savedPkixLoggersErrors;
1080 pkixLoggersDebugTrace = savedPkixLoggersDebugTrace;
1081
1082 if (locked) {
1083 PKIX_CHECK(PKIX_PL_MonitorLock_Exit(pkixLoggerLock, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Exit(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKEXITFAILED; goto cleanup; } } while (0)
1084 PKIX_MONITORLOCKEXITFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_MonitorLock_Exit(pkixLoggerLock
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_MONITORLOCKEXITFAILED; goto cleanup; } } while (0);
1085 }
1086
1087 PKIX_RETURN(LOGGER)return PKIX_DoReturn(&stdVars, (PKIX_LOGGER_ERROR), ((PKIX_Boolean
) 1), plContext);;
1088}