Bug Summary

File:s/lib/libpkix/pkix_pl_nss/module/pkix_pl_ldapdefaultclient.c
Warning:line 2470, column 17
Access to field 'data' results in a dereference of a null pointer (loaded from variable 'encoded')

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pkix_pl_ldapdefaultclient.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_pl_nss/module -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/var/lib/jenkins/workspace/nss-scan-build/nss/lib/libpkix/pkix_pl_nss/module -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_STRERROR -D LINUX -D linux -D XP_UNIX -D XP_UNIX -D SHLIB_SUFFIX="so" -D SHLIB_PREFIX="lib" -D SHLIB_VERSION="" -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D NSS_DISABLE_SSE3 -D NSS_NO_INIT_SUPPORT -D USE_UTIL_DIRECTLY -D NO_NSPR_10_SUPPORT -D SSL_DISABLE_DEPRECATED_CIPHER_SUITE_NAMES -I ../../../../../dist/Linux6.12_x86_64_gcc_glibc_PTH_64_DBG.OBJ/include -I ../../../../../dist/public/nss -I ../../../../../dist/private/nss -internal-isystem /usr/lib/llvm-19/lib/clang/19/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 -fskip-odr-check-in-gmf -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-01-06-222215-268153-1 -x c pkix_pl_ldapdefaultclient.c
1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4/*
5 * pkix_pl_ldapdefaultclient.c
6 *
7 * LDAPDefaultClient Function Definitions
8 *
9 */
10
11/* We can't decode the length of a message without at least this many bytes */
12#define MINIMUM_MSG_LENGTH5 5
13
14#include "pkix_pl_ldapdefaultclient.h"
15
16/* --Private-LdapDefaultClient-Message-Building-Functions---------------- */
17
18/*
19 * FUNCTION: pkix_pl_LdapDefaultClient_MakeBind
20 * DESCRIPTION:
21 *
22 * This function creates and encodes a Bind message, using the arena pointed
23 * to by "arena", the version number contained in "versionData", the
24 * LDAPBindAPI pointed to by "bindAPI", and the messageID contained in
25 * "msgNum", and stores a pointer to the encoded string at "pBindMsg".
26 *
27 * See pkix_pl_ldaptemplates.c for the ASN.1 description of a Bind message.
28 *
29 * This code is not used if the DefaultClient was created with a NULL pointer
30 * supplied for the LDAPBindAPI structure. (Bind and Unbind do not seem to be
31 * expected for anonymous Search requests.)
32 *
33 * PARAMETERS:
34 * "arena"
35 * The address of the PLArenaPool used in encoding the message. Must be
36 * non-NULL.
37 * "versionData"
38 * The Int32 containing the version number to be encoded in the Bind
39 * message.
40 * "bindAPI"
41 * The address of the LDAPBindAPI to be encoded in the Bind message. Must
42 * be non-NULL.
43 * "msgNum"
44 * The Int32 containing the MessageID to be encoded in the Bind message.
45 * "pBindMsg"
46 * The address at which the encoded Bind message will be stored. Must be
47 * non-NULL.
48 * "plContext"
49 * Platform-specific context pointer.
50 * THREAD SAFETY:
51 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
52 * RETURNS:
53 * Returns NULL if the function succeeds.
54 * Returns a LdapDefaultClient Error if the function fails in a
55 * non-fatal way.
56 * Returns a Fatal Error if the function fails in an unrecoverable way.
57 */
58static PKIX_Error *
59pkix_pl_LdapDefaultClient_MakeBind(
60 PLArenaPool *arena,
61 PKIX_Int32 versionData,
62 LDAPBindAPI *bindAPI,
63 PKIX_UInt32 msgNum,
64 SECItem **pBindMsg,
65 void *plContext)
66{
67 LDAPMessage msg;
68 char version = '\0';
69 SECItem *encoded = NULL((void*)0);
70 PKIX_UInt32 len = 0;
71
72 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_MakeBind")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_MakeBind"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
73 PKIX_NULLCHECK_TWO(arena, pBindMsg)do { if (((arena) == ((void*)0)) || ((pBindMsg) == ((void*)0)
)){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.
aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
74
75 PKIX_PL_NSSCALL(LDAPDEFAULTCLIENT, PORT_Memset,; (memset (&msg, 0, sizeof (LDAPMessage)))
76 (&msg, 0, sizeof (LDAPMessage))); (memset (&msg, 0, sizeof (LDAPMessage)));
77
78 version = (char)versionData;
79
80 msg.messageID.type = siUnsignedInteger;
81 msg.messageID.data = (void*)&msgNum;
82 msg.messageID.len = sizeof (msgNum);
83
84 msg.protocolOp.selector = LDAP_BIND_TYPE;
85
86 msg.protocolOp.op.bindMsg.version.type = siUnsignedInteger;
87 msg.protocolOp.op.bindMsg.version.data = (void *)&version;
88 msg.protocolOp.op.bindMsg.version.len = sizeof (char);
89
90 /*
91 * XXX At present we only know how to handle anonymous requests (no
92 * authentication), and we are guessing how to do simple authentication.
93 * This section will need to be revised and extended when other
94 * authentication is needed.
95 */
96 if (bindAPI->selector == SIMPLE_AUTH) {
97 msg.protocolOp.op.bindMsg.bindName.type = siAsciiString;
98 msg.protocolOp.op.bindMsg.bindName.data =
99 (void *)bindAPI->chooser.simple.bindName;
100 len = PL_strlen(bindAPI->chooser.simple.bindName);
101 msg.protocolOp.op.bindMsg.bindName.len = len;
102
103 msg.protocolOp.op.bindMsg.authentication.type = siAsciiString;
104 msg.protocolOp.op.bindMsg.authentication.data =
105 (void *)bindAPI->chooser.simple.authentication;
106 len = PL_strlen(bindAPI->chooser.simple.authentication);
107 msg.protocolOp.op.bindMsg.authentication.len = len;
108 }
109
110 PKIX_PL_NSSCALLRV(LDAPDEFAULTCLIENT, encoded, SEC_ASN1EncodeItem,; encoded = (SEC_ASN1EncodeItem_Util (arena, ((void*)0), (void
*)&msg, PKIX_PL_LDAPMessageTemplate))
111 (arena, NULL, (void *)&msg, PKIX_PL_LDAPMessageTemplate)); encoded = (SEC_ASN1EncodeItem_Util (arena, ((void*)0), (void
*)&msg, PKIX_PL_LDAPMessageTemplate));
112 if (!encoded) {
113 PKIX_ERROR(PKIX_SECASN1ENCODEITEMFAILED){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_SECASN1ENCODEITEMFAILED, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_SECASN1ENCODEITEMFAILED; goto
cleanup; };
114 }
115
116 *pBindMsg = encoded;
117cleanup:
118
119 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
120}
121
122/*
123 * FUNCTION: pkix_pl_LdapDefaultClient_MakeUnbind
124 * DESCRIPTION:
125 *
126 * This function creates and encodes a Unbind message, using the arena pointed
127 * to by "arena" and the messageID contained in "msgNum", and stores a pointer
128 * to the encoded string at "pUnbindMsg".
129 *
130 * See pkix_pl_ldaptemplates.c for the ASN.1 description of an Unbind message.
131 *
132 * This code is not used if the DefaultClient was created with a NULL pointer
133 * supplied for the LDAPBindAPI structure. (Bind and Unbind do not seem to be
134 * expected for anonymous Search requests.)
135 *
136 * PARAMETERS:
137 * "arena"
138 * The address of the PLArenaPool used in encoding the message. Must be
139 * non-NULL.
140 * "msgNum"
141 * The Int32 containing the MessageID to be encoded in the Unbind message.
142 * "pUnbindMsg"
143 * The address at which the encoded Unbind message will be stored. Must
144 * be non-NULL.
145 * "plContext"
146 * Platform-specific context pointer.
147 * THREAD SAFETY:
148 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
149 * RETURNS:
150 * Returns NULL if the function succeeds.
151 * Returns a LdapDefaultClient Error if the function fails in a
152 * non-fatal way.
153 * Returns a Fatal Error if the function fails in an unrecoverable way.
154 */
155static PKIX_Error *
156pkix_pl_LdapDefaultClient_MakeUnbind(
157 PLArenaPool *arena,
158 PKIX_UInt32 msgNum,
159 SECItem **pUnbindMsg,
160 void *plContext)
161{
162 LDAPMessage msg;
163 SECItem *encoded = NULL((void*)0);
164
165 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_MakeUnbind")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_MakeUnbind"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
166 PKIX_NULLCHECK_TWO(arena, pUnbindMsg)do { if (((arena) == ((void*)0)) || ((pUnbindMsg) == ((void*)
0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
167
168 PKIX_PL_NSSCALL(LDAPDEFAULTCLIENT, PORT_Memset,; (memset (&msg, 0, sizeof (LDAPMessage)))
169 (&msg, 0, sizeof (LDAPMessage))); (memset (&msg, 0, sizeof (LDAPMessage)));
170
171 msg.messageID.type = siUnsignedInteger;
172 msg.messageID.data = (void*)&msgNum;
173 msg.messageID.len = sizeof (msgNum);
174
175 msg.protocolOp.selector = LDAP_UNBIND_TYPE;
176
177 msg.protocolOp.op.unbindMsg.dummy.type = siBuffer;
178 msg.protocolOp.op.unbindMsg.dummy.data = NULL((void*)0);
179 msg.protocolOp.op.unbindMsg.dummy.len = 0;
180
181 PKIX_PL_NSSCALLRV(LDAPDEFAULTCLIENT, encoded, SEC_ASN1EncodeItem,; encoded = (SEC_ASN1EncodeItem_Util (arena, ((void*)0), (void
*)&msg, PKIX_PL_LDAPMessageTemplate))
182 (arena, NULL, (void *)&msg, PKIX_PL_LDAPMessageTemplate)); encoded = (SEC_ASN1EncodeItem_Util (arena, ((void*)0), (void
*)&msg, PKIX_PL_LDAPMessageTemplate));
183 if (!encoded) {
184 PKIX_ERROR(PKIX_SECASN1ENCODEITEMFAILED){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_SECASN1ENCODEITEMFAILED, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_SECASN1ENCODEITEMFAILED; goto
cleanup; };
185 }
186
187 *pUnbindMsg = encoded;
188cleanup:
189
190 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
191}
192
193/*
194 * FUNCTION: pkix_pl_LdapDefaultClient_MakeAbandon
195 * DESCRIPTION:
196 *
197 * This function creates and encodes a Abandon message, using the arena pointed
198 * to by "arena" and the messageID contained in "msgNum", and stores a pointer
199 * to the encoded string at "pAbandonMsg".
200 *
201 * See pkix_pl_ldaptemplates.c for the ASN.1 description of an Abandon message.
202 *
203 * PARAMETERS:
204 * "arena"
205 * The address of the PLArenaPool used in encoding the message. Must be
206 * non-NULL.
207 * "msgNum"
208 * The Int32 containing the MessageID to be encoded in the Abandon message.
209 * "pAbandonMsg"
210 * The address at which the encoded Abandon message will be stored. Must
211 * be non-NULL.
212 * "plContext"
213 * Platform-specific context pointer.
214 * THREAD SAFETY:
215 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
216 * RETURNS:
217 * Returns NULL if the function succeeds.
218 * Returns a LdapDefaultClient Error if the function fails in a
219 * non-fatal way.
220 * Returns a Fatal Error if the function fails in an unrecoverable way.
221 */
222static PKIX_Error *
223pkix_pl_LdapDefaultClient_MakeAbandon(
224 PLArenaPool *arena,
225 PKIX_UInt32 msgNum,
226 SECItem **pAbandonMsg,
227 void *plContext)
228{
229 LDAPMessage msg;
230 SECItem *encoded = NULL((void*)0);
231
232 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_MakeAbandon")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_MakeAbandon"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
11
←
Taking false branch
→
233 PKIX_NULLCHECK_TWO(arena, pAbandonMsg)do { if (((arena) == ((void*)0)) || ((pAbandonMsg) == ((void*
)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
12
←
Loop condition is false. Exiting loop
→
13
←
Assuming 'arena' is equal to null
→
14
←
Returning without writing to '*pAbandonMsg'
→
15
←
Returning pointer, which participates in a condition later
→
234
235 PKIX_PL_NSSCALL(LDAPDEFAULTCLIENT, PORT_Memset,; (memset (&msg, 0, sizeof (LDAPMessage)))
236 (&msg, 0, sizeof (LDAPMessage))); (memset (&msg, 0, sizeof (LDAPMessage)));
237
238 msg.messageID.type = siUnsignedInteger;
239 msg.messageID.data = (void*)&msgNum;
240 msg.messageID.len = sizeof (msgNum);
241
242 msg.protocolOp.selector = LDAP_ABANDONREQUEST_TYPE;
243
244 msg.protocolOp.op.abandonRequestMsg.messageID.type = siBuffer;
245 msg.protocolOp.op.abandonRequestMsg.messageID.data = (void*)&msgNum;
246 msg.protocolOp.op.abandonRequestMsg.messageID.len = sizeof (msgNum);
247
248 PKIX_PL_NSSCALLRV(LDAPDEFAULTCLIENT, encoded, SEC_ASN1EncodeItem,; encoded = (SEC_ASN1EncodeItem_Util (arena, ((void*)0), (void
*)&msg, PKIX_PL_LDAPMessageTemplate))
249 (arena, NULL, (void *)&msg, PKIX_PL_LDAPMessageTemplate)); encoded = (SEC_ASN1EncodeItem_Util (arena, ((void*)0), (void
*)&msg, PKIX_PL_LDAPMessageTemplate));
250 if (!encoded) {
251 PKIX_ERROR(PKIX_SECASN1ENCODEITEMFAILED){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_SECASN1ENCODEITEMFAILED, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_SECASN1ENCODEITEMFAILED; goto
cleanup; };
252 }
253
254 *pAbandonMsg = encoded;
255cleanup:
256
257 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
258}
259
260/*
261 * FUNCTION: pkix_pl_LdapDefaultClient_DecodeBindResponse
262 * DESCRIPTION:
263 *
264 * This function decodes the encoded data pointed to by "src", using the arena
265 * pointed to by "arena", storing the decoded LDAPMessage at "pBindResponse"
266 * and the decoding status at "pStatus".
267 *
268 * PARAMETERS:
269 * "arena"
270 * The address of the PLArenaPool to be used in decoding the message. Must
271 * be non-NULL.
272 * "src"
273 * The address of the SECItem containing the DER- (or BER-)encoded string.
274 * Must be non-NULL.
275 * "pBindResponse"
276 * The address at which the LDAPMessage is stored, if the decoding is
277 * successful (the returned status is SECSuccess). Must be non-NULL.
278 * "pStatus"
279 * The address at which the decoding status is stored. Must be non-NULL.
280 * "plContext"
281 * Platform-specific context pointer.
282 * THREAD SAFETY:
283 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
284 * RETURNS:
285 * Returns NULL if the function succeeds.
286 * Returns a LdapDefaultClient Error if the function fails in a
287 * non-fatal way.
288 * Returns a Fatal Error if the function fails in an unrecoverable way.
289 */
290static PKIX_Error *
291pkix_pl_LdapDefaultClient_DecodeBindResponse(
292 PLArenaPool *arena,
293 SECItem *src,
294 LDAPMessage *pBindResponse,
295 SECStatus *pStatus,
296 void *plContext)
297{
298 SECStatus rv = SECFailure;
299 LDAPMessage response;
300
301 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_DecodeBindResponse"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
302 (LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_DecodeBindResponse"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
303 "pkix_pl_LdapDefaultClient_DecodeBindResponse")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_DecodeBindResponse"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
304 PKIX_NULLCHECK_FOUR(arena, src, pBindResponse, pStatus)do { if (((arena) == ((void*)0)) || ((src) == ((void*)0)) || (
(pBindResponse) == ((void*)0)) || ((pStatus) == ((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 PKIX_PL_NSSCALL; (memset (&response, 0, sizeof (LDAPMessage)))
307 (LDAPDEFAULTCLIENT,; (memset (&response, 0, sizeof (LDAPMessage)))
308 PORT_Memset,; (memset (&response, 0, sizeof (LDAPMessage)))
309 (&response, 0, sizeof (LDAPMessage))); (memset (&response, 0, sizeof (LDAPMessage)));
310
311 PKIX_PL_NSSCALLRV(LDAPDEFAULTCLIENT, rv, SEC_ASN1DecodeItem,; rv = (SEC_ASN1DecodeItem_Util (arena, &response, PKIX_PL_LDAPMessageTemplate
, src))
312 (arena, &response, PKIX_PL_LDAPMessageTemplate, src)); rv = (SEC_ASN1DecodeItem_Util (arena, &response, PKIX_PL_LDAPMessageTemplate
, src));
313
314 if (rv == SECSuccess) {
315 *pBindResponse = response;
316 }
317
318 *pStatus = rv;
319
320 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
321}
322
323/*
324 * FUNCTION: pkix_pl_LdapDefaultClient_VerifyBindResponse
325 * DESCRIPTION:
326 *
327 * This function verifies that the contents of the message in the rcvbuf of
328 * the LdapDefaultClient object pointed to by "client", and whose length is
329 * provided by "buflen", is a response to a successful Bind.
330 *
331 * PARAMETERS:
332 * "client"
333 * The address of the LdapDefaultClient object. Must be non-NULL.
334 * "buflen"
335 * The value of the number of bytes in the receive buffer.
336 * "plContext"
337 * Platform-specific context pointer.
338 * THREAD SAFETY:
339 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
340 * RETURNS:
341 * Returns NULL if the function succeeds.
342 * Returns a LdapDefaultClient Error if the function fails in a
343 * non-fatal way.
344 * Returns a Fatal Error if the function fails in an unrecoverable way.
345 */
346static PKIX_Error *
347pkix_pl_LdapDefaultClient_VerifyBindResponse(
348 PKIX_PL_LdapDefaultClient *client,
349 PKIX_UInt32 bufLen,
350 void *plContext)
351{
352 SECItem decode = {siBuffer, NULL((void*)0), 0};
353 SECStatus rv = SECFailure;
354 LDAPMessage msg;
355 LDAPBindResponse *ldapBindResponse = &msg.protocolOp.op.bindResponseMsg;
356
357 ldapBindResponse->resultCode.data = NULL((void*)0);
358
359 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_VerifyBindResponse"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
360 (LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_VerifyBindResponse"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
361 "pkix_pl_LdapDefaultClient_VerifyBindResponse")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_VerifyBindResponse"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
362 PKIX_NULLCHECK_TWO(client, client->rcvBuf)do { if (((client) == ((void*)0)) || ((client->rcvBuf) == (
(void*)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1);
stdVars.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn
(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext
);; } } while (0);
363
364 decode.data = (unsigned char *)(client->rcvBuf);
365 decode.len = bufLen;
366
367 PKIX_CHECK(pkix_pl_LdapDefaultClient_DecodeBindResponsedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_DecodeBindResponse
(client->arena, &decode, &msg, &rv, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTDECODEBINDRESPONSEFAILED; goto cleanup
; } } while (0)
368 (client->arena, &decode, &msg, &rv, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_DecodeBindResponse
(client->arena, &decode, &msg, &rv, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTDECODEBINDRESPONSEFAILED; goto cleanup
; } } while (0)
369 PKIX_LDAPDEFAULTCLIENTDECODEBINDRESPONSEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_DecodeBindResponse
(client->arena, &decode, &msg, &rv, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTDECODEBINDRESPONSEFAILED; goto cleanup
; } } while (0);
370
371 if (rv == SECSuccess) {
372 if (*(ldapBindResponse->resultCode.data) == SUCCESS) {
373 client->connectStatus = BOUND;
374 } else {
375 PKIX_ERROR(PKIX_BINDREJECTEDBYSERVER){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_BINDREJECTEDBYSERVER, ((void*)0), stdVars.aPkixType, 2
, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_BINDREJECTEDBYSERVER; goto
cleanup; };
376 }
377 } else {
378 PKIX_ERROR(PKIX_CANTDECODEBINDRESPONSEFROMSERVER){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_CANTDECODEBINDRESPONSEFROMSERVER, ((void*)0), stdVars.
aPkixType, 2, plContext); } } stdVars.aPkixErrorReceived = ((
PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_CANTDECODEBINDRESPONSEFROMSERVER
; goto cleanup; };
379 }
380
381cleanup:
382
383 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
384}
385
386/*
387 * FUNCTION: pkix_pl_LdapDefaultClient_RecvCheckComplete
388 * DESCRIPTION:
389 *
390 * This function determines whether the current response in the
391 * LdapDefaultClient pointed to by "client" is complete, in the sense that all
392 * bytes required to satisfy the message length field in the encoding have been
393 * received. If so, the pointer to input data is updated to reflect the number
394 * of bytes consumed, provided by "bytesProcessed". The state machine flag
395 * pointed to by "pKeepGoing" is updated to indicate whether processing can
396 * continue without further input.
397 *
398 * PARAMETERS:
399 * "client"
400 * The address of the LdapDefaultClient object. Must be non-NULL.
401 * "bytesProcessed"
402 * The UInt32 value of the number of bytes consumed from the current
403 * buffer.
404 * "pKeepGoing"
405 * The address at which the Boolean state machine flag is stored to
406 * indicate whether processing can continue without further input.
407 * Must be non-NULL.
408 * "plContext"
409 * Platform-specific context pointer.
410 * THREAD SAFETY:
411 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
412 * RETURNS:
413 * Returns NULL if the function succeeds.
414 * Returns a LdapDefaultClient Error if the function fails in a
415 * non-fatal way.
416 * Returns a Fatal Error if the function fails in an unrecoverable way.
417 */
418static PKIX_Error *
419pkix_pl_LdapDefaultClient_RecvCheckComplete(
420 PKIX_PL_LdapDefaultClient *client,
421 PKIX_UInt32 bytesProcessed,
422 PKIX_Boolean *pKeepGoing,
423 void *plContext)
424{
425 PKIX_Boolean complete = PKIX_FALSE((PKIX_Boolean) 0);
426 SECStatus rv = SECFailure;
427 LDAPMessageType messageType = 0;
428 LDAPResultCode resultCode = 0;
429
430 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RecvCheckComplete"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
431 (LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RecvCheckComplete"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
432 "pkix_pl_LdapDefaultClient_RecvCheckComplete")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RecvCheckComplete"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
433 PKIX_NULLCHECK_TWO(client, pKeepGoing)do { if (((client) == ((void*)0)) || ((pKeepGoing) == ((void*
)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
434
435 PKIX_CHECK(pkix_pl_LdapResponse_IsCompletedo { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_IsComplete
(client->currentResponse, &complete, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEISCOMPLETEFAILED
; goto cleanup; } } while (0)
436 (client->currentResponse, &complete, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_IsComplete
(client->currentResponse, &complete, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEISCOMPLETEFAILED
; goto cleanup; } } while (0)
437 PKIX_LDAPRESPONSEISCOMPLETEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_IsComplete
(client->currentResponse, &complete, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEISCOMPLETEFAILED
; goto cleanup; } } while (0);
438
439 if (complete) {
440 PKIX_CHECK(pkix_pl_LdapResponse_Decodedo { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Decode (
client->arena, client->currentResponse, &rv, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSEDECODEFAILED; goto cleanup; } } while (0)
441 (client->arena, client->currentResponse, &rv, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Decode (
client->arena, client->currentResponse, &rv, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSEDECODEFAILED; goto cleanup; } } while (0)
442 PKIX_LDAPRESPONSEDECODEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Decode (
client->arena, client->currentResponse, &rv, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSEDECODEFAILED; goto cleanup; } } while (0);
443
444 if (rv != SECSuccess) {
445 PKIX_ERROR(PKIX_CANTDECODESEARCHRESPONSEFROMSERVER){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_CANTDECODESEARCHRESPONSEFROMSERVER, ((void*)0), stdVars
.aPkixType, 2, plContext); } } stdVars.aPkixErrorReceived = (
(PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_CANTDECODESEARCHRESPONSEFROMSERVER
; goto cleanup; };
446 }
447
448 PKIX_CHECK(pkix_pl_LdapResponse_GetMessageTypedo { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetMessageType
(client->currentResponse, &messageType, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETMESSAGETYPEFAILED
; goto cleanup; } } while (0)
449 (client->currentResponse, &messageType, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetMessageType
(client->currentResponse, &messageType, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETMESSAGETYPEFAILED
; goto cleanup; } } while (0)
450 PKIX_LDAPRESPONSEGETMESSAGETYPEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetMessageType
(client->currentResponse, &messageType, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETMESSAGETYPEFAILED
; goto cleanup; } } while (0);
451
452 if (messageType == LDAP_SEARCHRESPONSEENTRY_TYPE) {
453
454 if (client->entriesFound == NULL((void*)0)) {
455 PKIX_CHECK(PKIX_List_Createdo { stdVars.aPkixErrorResult = (PKIX_List_Create (&(client
->entriesFound), plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTCREATEFAILED; goto cleanup
; } } while (0)
456 (&(client->entriesFound), plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create (&(client
->entriesFound), plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTCREATEFAILED; goto cleanup
; } } while (0)
457 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create (&(client
->entriesFound), plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTCREATEFAILED; goto cleanup
; } } while (0);
458 }
459
460 PKIX_CHECK(PKIX_List_AppendItemdo { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (client
->entriesFound, (PKIX_PL_Object *)client->currentResponse
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTAPPENDITEMFAILED; goto cleanup; } } while (0)
461 (client->entriesFound,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (client
->entriesFound, (PKIX_PL_Object *)client->currentResponse
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTAPPENDITEMFAILED; goto cleanup; } } while (0)
462 (PKIX_PL_Object *)client->currentResponse,do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (client
->entriesFound, (PKIX_PL_Object *)client->currentResponse
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTAPPENDITEMFAILED; goto cleanup; } } while (0)
463 plContext),do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (client
->entriesFound, (PKIX_PL_Object *)client->currentResponse
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTAPPENDITEMFAILED; goto cleanup; } } while (0)
464 PKIX_LISTAPPENDITEMFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_AppendItem (client
->entriesFound, (PKIX_PL_Object *)client->currentResponse
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LISTAPPENDITEMFAILED; goto cleanup; } } while (0);
465
466 PKIX_DECREF(client->currentResponse)do { if (client->currentResponse){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentResponse
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentResponse = ((void*)0); } }
while (0);
467
468 /* current receive buffer empty? */
469 if (client->currentBytesAvailable == 0) {
470 client->connectStatus = RECV;
471 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
472 } else {
473 client->connectStatus = RECV_INITIAL;
474 client->currentInPtr = &((char *)
475 (client->currentInPtr))[bytesProcessed];
476 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
477 }
478
479 } else if (messageType == LDAP_SEARCHRESPONSERESULT_TYPE) {
480 PKIX_CHECK(pkix_pl_LdapResponse_GetResultCodedo { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetResultCode
(client->currentResponse, &resultCode, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETRESULTCODEFAILED
; goto cleanup; } } while (0)
481 (client->currentResponse,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetResultCode
(client->currentResponse, &resultCode, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETRESULTCODEFAILED
; goto cleanup; } } while (0)
482 &resultCode,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetResultCode
(client->currentResponse, &resultCode, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETRESULTCODEFAILED
; goto cleanup; } } while (0)
483 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetResultCode
(client->currentResponse, &resultCode, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETRESULTCODEFAILED
; goto cleanup; } } while (0)
484 PKIX_LDAPRESPONSEGETRESULTCODEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetResultCode
(client->currentResponse, &resultCode, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETRESULTCODEFAILED
; goto cleanup; } } while (0);
485
486 if ((client->entriesFound == NULL((void*)0)) &&
487 ((resultCode == SUCCESS) ||
488 (resultCode == NOSUCHOBJECT))) {
489 PKIX_CHECK(PKIX_List_Createdo { stdVars.aPkixErrorResult = (PKIX_List_Create (&(client
->entriesFound), plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTCREATEFAILED; goto cleanup
; } } while (0)
490 (&(client->entriesFound), plContext),do { stdVars.aPkixErrorResult = (PKIX_List_Create (&(client
->entriesFound), plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTCREATEFAILED; goto cleanup
; } } while (0)
491 PKIX_LISTCREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_Create (&(client
->entriesFound), plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTCREATEFAILED; goto cleanup
; } } while (0);
492 } else if (resultCode == SUCCESS) {
493 PKIX_CHECK(PKIX_List_SetImmutabledo { stdVars.aPkixErrorResult = (PKIX_List_SetImmutable (client
->entriesFound, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTSETIMMUTABLEFAILED; goto cleanup
; } } while (0)
494 (client->entriesFound, plContext),do { stdVars.aPkixErrorResult = (PKIX_List_SetImmutable (client
->entriesFound, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTSETIMMUTABLEFAILED; goto cleanup
; } } while (0)
495 PKIX_LISTSETIMMUTABLEFAILED)do { stdVars.aPkixErrorResult = (PKIX_List_SetImmutable (client
->entriesFound, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LISTSETIMMUTABLEFAILED; goto cleanup
; } } while (0);
496 PKIX_CHECK(PKIX_PL_HashTable_Adddo { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Add (client
->cachePtr, (PKIX_PL_Object *)client->currentRequest, (
PKIX_PL_Object *)client->entriesFound, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLEADDFAILED
; goto cleanup; } } while (0)
497 (client->cachePtr,do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Add (client
->cachePtr, (PKIX_PL_Object *)client->currentRequest, (
PKIX_PL_Object *)client->entriesFound, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLEADDFAILED
; goto cleanup; } } while (0)
498 (PKIX_PL_Object *)client->currentRequest,do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Add (client
->cachePtr, (PKIX_PL_Object *)client->currentRequest, (
PKIX_PL_Object *)client->entriesFound, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLEADDFAILED
; goto cleanup; } } while (0)
499 (PKIX_PL_Object *)client->entriesFound,do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Add (client
->cachePtr, (PKIX_PL_Object *)client->currentRequest, (
PKIX_PL_Object *)client->entriesFound, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLEADDFAILED
; goto cleanup; } } while (0)
500 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Add (client
->cachePtr, (PKIX_PL_Object *)client->currentRequest, (
PKIX_PL_Object *)client->entriesFound, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLEADDFAILED
; goto cleanup; } } while (0)
501 PKIX_HASHTABLEADDFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Add (client
->cachePtr, (PKIX_PL_Object *)client->currentRequest, (
PKIX_PL_Object *)client->entriesFound, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLEADDFAILED
; goto cleanup; } } while (0);
502 } else {
503 PKIX_ERROR(PKIX_UNEXPECTEDRESULTCODEINRESPONSE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_UNEXPECTEDRESULTCODEINRESPONSE, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_UNEXPECTEDRESULTCODEINRESPONSE
; goto cleanup; };
504 }
505
506 client->connectStatus = BOUND;
507 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
508 PKIX_DECREF(client->currentResponse)do { if (client->currentResponse){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentResponse
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentResponse = ((void*)0); } }
while (0);
509
510 } else {
511 PKIX_ERROR(PKIX_SEARCHRESPONSEPACKETOFUNKNOWNTYPE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_SEARCHRESPONSEPACKETOFUNKNOWNTYPE, ((void*)0), stdVars
.aPkixType, 2, plContext); } } stdVars.aPkixErrorReceived = (
(PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_SEARCHRESPONSEPACKETOFUNKNOWNTYPE
; goto cleanup; };
512 }
513 } else {
514 client->connectStatus = RECV;
515 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
516 }
517
518cleanup:
519 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
520}
521
522/* --Private-LdapDefaultClient-Object-Functions------------------------- */
523
524static PKIX_Error *
525pkix_pl_LdapDefaultClient_InitiateRequest(
526 PKIX_PL_LdapClient *client,
527 LDAPRequestParams *requestParams,
528 void **pPollDesc,
529 PKIX_List **pResponse,
530 void *plContext);
531
532static PKIX_Error *
533pkix_pl_LdapDefaultClient_ResumeRequest(
534 PKIX_PL_LdapClient *client,
535 void **pPollDesc,
536 PKIX_List **pResponse,
537 void *plContext);
538
539/*
540 * FUNCTION: pkix_pl_LdapDefaultClient_CreateHelper
541 * DESCRIPTION:
542 *
543 * This function creates a new LdapDefaultClient using the Socket pointed to
544 * by "socket", the PRIntervalTime pointed to by "timeout", and the
545 * LDAPBindAPI pointed to by "bindAPI", and stores the result at "pClient".
546 *
547 * A value of zero for "timeout" means the LDAPClient will use non-blocking
548 * I/O.
549 *
550 * PARAMETERS:
551 * "socket"
552 * Address of the Socket to be used for the client. Must be non-NULL.
553 * "bindAPI"
554 * The address of the LDAPBindAPI containing the Bind information to be
555 * encoded in the Bind message.
556 * "pClient"
557 * The address at which the created LdapDefaultClient is to be stored.
558 * Must be non-NULL.
559 * "plContext"
560 * Platform-specific context pointer.
561 * THREAD SAFETY:
562 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
563 * RETURNS:
564 * Returns NULL if the function succeeds.
565 * Returns a LdapDefaultClient Error if the function fails in
566 * a non-fatal way.
567 * Returns a Fatal Error if the function fails in an unrecoverable way.
568 */
569PKIX_Error *
570pkix_pl_LdapDefaultClient_CreateHelper(
571 PKIX_PL_Socket *socket,
572 LDAPBindAPI *bindAPI,
573 PKIX_PL_LdapDefaultClient **pClient,
574 void *plContext)
575{
576 PKIX_PL_HashTable *ht;
577 PKIX_PL_LdapDefaultClient *ldapDefaultClient = NULL((void*)0);
578 PKIX_PL_Socket_Callback *callbackList;
579 PRFileDesc *fileDesc = NULL((void*)0);
580 PLArenaPool *arena = NULL((void*)0);
581
582 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_CreateHelper")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_CreateHelper"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
583 PKIX_NULLCHECK_TWO(socket, pClient)do { if (((socket) == ((void*)0)) || ((pClient) == ((void*)0)
)){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.
aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
584
585 PKIX_CHECK(PKIX_PL_Object_Allocdo { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LDAPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_LdapDefaultClient), (PKIX_PL_Object **)&
ldapDefaultClient, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_COULDNOTCREATELDAPDEFAULTCLIENTOBJECT
; goto cleanup; } } while (0)
586 (PKIX_LDAPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LDAPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_LdapDefaultClient), (PKIX_PL_Object **)&
ldapDefaultClient, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_COULDNOTCREATELDAPDEFAULTCLIENTOBJECT
; goto cleanup; } } while (0)
587 sizeof (PKIX_PL_LdapDefaultClient),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LDAPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_LdapDefaultClient), (PKIX_PL_Object **)&
ldapDefaultClient, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_COULDNOTCREATELDAPDEFAULTCLIENTOBJECT
; goto cleanup; } } while (0)
588 (PKIX_PL_Object **)&ldapDefaultClient,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LDAPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_LdapDefaultClient), (PKIX_PL_Object **)&
ldapDefaultClient, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_COULDNOTCREATELDAPDEFAULTCLIENTOBJECT
; goto cleanup; } } while (0)
589 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LDAPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_LdapDefaultClient), (PKIX_PL_Object **)&
ldapDefaultClient, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_COULDNOTCREATELDAPDEFAULTCLIENTOBJECT
; goto cleanup; } } while (0)
590 PKIX_COULDNOTCREATELDAPDEFAULTCLIENTOBJECT)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_LDAPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_LdapDefaultClient), (PKIX_PL_Object **)&
ldapDefaultClient, plContext)); if (stdVars.aPkixErrorResult)
{ stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_COULDNOTCREATELDAPDEFAULTCLIENTOBJECT
; goto cleanup; } } while (0);
591
592 ldapDefaultClient->vtable.initiateFcn =
593 pkix_pl_LdapDefaultClient_InitiateRequest;
594 ldapDefaultClient->vtable.resumeFcn =
595 pkix_pl_LdapDefaultClient_ResumeRequest;
596
597 PKIX_CHECK(pkix_pl_Socket_GetPRFileDescdo { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetPRFileDesc
(socket, &fileDesc, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETPRFILEDESCFAILED; goto
cleanup; } } while (0)
598 (socket, &fileDesc, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetPRFileDesc
(socket, &fileDesc, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETPRFILEDESCFAILED; goto
cleanup; } } while (0)
599 PKIX_SOCKETGETPRFILEDESCFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetPRFileDesc
(socket, &fileDesc, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETPRFILEDESCFAILED; goto
cleanup; } } while (0);
600
601 ldapDefaultClient->pollDesc.fd = fileDesc;
602 ldapDefaultClient->pollDesc.in_flags = 0;
603 ldapDefaultClient->pollDesc.out_flags = 0;
604
605 ldapDefaultClient->bindAPI = bindAPI;
606
607 PKIX_CHECK(PKIX_PL_HashTable_Createdo { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Create (128
, 0, &ht, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_HASHTABLECREATEFAILED; goto cleanup; }
} while (0)
608 (LDAP_CACHEBUCKETS, 0, &ht, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Create (128
, 0, &ht, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_HASHTABLECREATEFAILED; goto cleanup; }
} while (0)
609 PKIX_HASHTABLECREATEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Create (128
, 0, &ht, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_HASHTABLECREATEFAILED; goto cleanup; }
} while (0);
610
611 ldapDefaultClient->cachePtr = ht;
612
613 PKIX_CHECK(pkix_pl_Socket_GetCallbackListdo { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetCallbackList
(socket, &callbackList, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETCALLBACKLISTFAILED; goto
cleanup; } } while (0)
614 (socket, &callbackList, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetCallbackList
(socket, &callbackList, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETCALLBACKLISTFAILED; goto
cleanup; } } while (0)
615 PKIX_SOCKETGETCALLBACKLISTFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetCallbackList
(socket, &callbackList, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETCALLBACKLISTFAILED; goto
cleanup; } } while (0);
616
617 ldapDefaultClient->callbackList = callbackList;
618
619 PKIX_INCREF(socket)do { if (socket){ stdVars.aPkixTempResult = PKIX_PL_Object_IncRef
((PKIX_PL_Object *)(socket), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); goto cleanup; } } } while
(0);
620 ldapDefaultClient->clientSocket = socket;
621
622 ldapDefaultClient->messageID = 0;
623
624 ldapDefaultClient->bindAPI = bindAPI;
625
626 arena = PORT_NewArenaPORT_NewArena_Util(DER_DEFAULT_CHUNKSIZE(2048));
627 if (!arena) {
628 PKIX_ERROR_FATAL(PKIX_OUTOFMEMORY){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
= PKIX_OUTOFMEMORY; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
629 }
630 ldapDefaultClient->arena = arena;
631
632 ldapDefaultClient->sendBuf = NULL((void*)0);
633 ldapDefaultClient->bytesToWrite = 0;
634
635 PKIX_CHECK(PKIX_PL_Mallocdo { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (512, &ldapDefaultClient
->rcvBuf, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; } } while (
0)
636 (RCVBUFSIZE, &ldapDefaultClient->rcvBuf, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (512, &ldapDefaultClient
->rcvBuf, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; } } while (
0)
637 PKIX_MALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (512, &ldapDefaultClient
->rcvBuf, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; } } while (
0);
638 ldapDefaultClient->capacity = RCVBUFSIZE512;
639
640 ldapDefaultClient->bindMsg = NULL((void*)0);
641 ldapDefaultClient->bindMsgLen = 0;
642
643 ldapDefaultClient->entriesFound = NULL((void*)0);
644 ldapDefaultClient->currentRequest = NULL((void*)0);
645 ldapDefaultClient->currentResponse = NULL((void*)0);
646
647 *pClient = ldapDefaultClient;
648
649cleanup:
650
651 if (PKIX_ERROR_RECEIVED(stdVars.aPkixErrorReceived || stdVars.aPkixErrorResult || stdVars
.aPkixTempErrorReceived || stdVars.aPkixErrorList)) {
652 PKIX_DECREF(ldapDefaultClient)do { if (ldapDefaultClient){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(ldapDefaultClient), plContext); if (stdVars
.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult
, plContext); stdVars.aPkixTempResult = ((void*)0); } ldapDefaultClient
= ((void*)0); } } while (0);
653 }
654
655 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
656}
657
658/*
659 * FUNCTION: PKIX_PL_LdapDefaultClient_Create
660 * DESCRIPTION:
661 *
662 * This function creates a new LdapDefaultClient using the PRNetAddr pointed to
663 * by "sockaddr", the PRIntervalTime pointed to by "timeout", and the
664 * LDAPBindAPI pointed to by "bindAPI", and stores the result at "pClient".
665 *
666 * A value of zero for "timeout" means the LDAPClient will use non-blocking
667 * I/O.
668 *
669 * PARAMETERS:
670 * "sockaddr"
671 * Address of the PRNetAddr to be used for the socket connection. Must be
672 * non-NULL.
673 * "timeout"
674 * The PRIntervalTime to be used in I/O requests for this client.
675 * "bindAPI"
676 * The address of the LDAPBindAPI containing the Bind information to be
677 * encoded in the Bind message.
678 * "pClient"
679 * The address at which the created LdapDefaultClient is to be stored.
680 * Must be non-NULL.
681 * "plContext"
682 * Platform-specific context pointer.
683 * THREAD SAFETY:
684 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
685 * RETURNS:
686 * Returns NULL if the function succeeds.
687 * Returns a LdapDefaultClient Error if the function fails in
688 * a non-fatal way.
689 * Returns a Fatal Error if the function fails in an unrecoverable way.
690 */
691PKIX_Error *
692PKIX_PL_LdapDefaultClient_Create(
693 PRNetAddr *sockaddr,
694 PRIntervalTime timeout,
695 LDAPBindAPI *bindAPI,
696 PKIX_PL_LdapDefaultClient **pClient,
697 void *plContext)
698{
699 PRErrorCode status = 0;
700 PKIX_PL_Socket *socket = NULL((void*)0);
701 PKIX_PL_LdapDefaultClient *client = NULL((void*)0);
702
703 PKIX_ENTER(LDAPDEFAULTCLIENT, "PKIX_PL_LdapDefaultClient_Create")static const char cMyFuncName[] = {"PKIX_PL_LdapDefaultClient_Create"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
704 PKIX_NULLCHECK_TWO(sockaddr, pClient)do { if (((sockaddr) == ((void*)0)) || ((pClient) == ((void*)
0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
705
706 PKIX_CHECK(pkix_pl_Socket_Createdo { stdVars.aPkixErrorResult = (pkix_pl_Socket_Create (((PKIX_Boolean
) 0), timeout, sockaddr, &status, &socket, plContext)
); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETCREATEFAILED
; goto cleanup; } } while (0)
707 (PKIX_FALSE, timeout, sockaddr, &status, &socket, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Socket_Create (((PKIX_Boolean
) 0), timeout, sockaddr, &status, &socket, plContext)
); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETCREATEFAILED
; goto cleanup; } } while (0)
708 PKIX_SOCKETCREATEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_Socket_Create (((PKIX_Boolean
) 0), timeout, sockaddr, &status, &socket, plContext)
); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETCREATEFAILED
; goto cleanup; } } while (0);
709
710 PKIX_CHECK(pkix_pl_LdapDefaultClient_CreateHelperdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_CreateHelper
(socket, bindAPI, &client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCREATEHELPERFAILED
; goto cleanup; } } while (0)
711 (socket, bindAPI, &client, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_CreateHelper
(socket, bindAPI, &client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCREATEHELPERFAILED
; goto cleanup; } } while (0)
712 PKIX_LDAPDEFAULTCLIENTCREATEHELPERFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_CreateHelper
(socket, bindAPI, &client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCREATEHELPERFAILED
; goto cleanup; } } while (0);
713
714 /* Did Socket_Create say the connection was made? */
715 if (status == 0) {
716 if (client->bindAPI != NULL((void*)0)) {
717 client->connectStatus = CONNECTED;
718 } else {
719 client->connectStatus = BOUND;
720 }
721 } else {
722 client->connectStatus = CONNECT_PENDING;
723 }
724
725 *pClient = client;
726
727cleanup:
728 if (PKIX_ERROR_RECEIVED(stdVars.aPkixErrorReceived || stdVars.aPkixErrorResult || stdVars
.aPkixTempErrorReceived || stdVars.aPkixErrorList)) {
729 PKIX_DECREF(client)do { if (client){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(client), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } client = ((void*)0
); } } while (0);
730 }
731
732 PKIX_DECREF(socket)do { if (socket){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(socket), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } socket = ((void*)0
); } } while (0);
733
734 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
735}
736
737/*
738 * FUNCTION: PKIX_PL_LdapDefaultClient_CreateByName
739 * DESCRIPTION:
740 *
741 * This function creates a new LdapDefaultClient using the hostname pointed to
742 * by "hostname", the PRIntervalTime pointed to by "timeout", and the
743 * LDAPBindAPI pointed to by "bindAPI", and stores the result at "pClient".
744 *
745 * A value of zero for "timeout" means the LDAPClient will use non-blocking
746 * I/O.
747 *
748 * PARAMETERS:
749 * "hostname"
750 * Address of the hostname to be used for the socket connection. Must be
751 * non-NULL.
752 * "timeout"
753 * The PRIntervalTime to be used in I/O requests for this client.
754 * "bindAPI"
755 * The address of the LDAPBindAPI containing the Bind information to be
756 * encoded in the Bind message.
757 * "pClient"
758 * The address at which the created LdapDefaultClient is to be stored.
759 * Must be non-NULL.
760 * "plContext"
761 * Platform-specific context pointer.
762 * THREAD SAFETY:
763 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
764 * RETURNS:
765 * Returns NULL if the function succeeds.
766 * Returns a LdapDefaultClient Error if the function fails in
767 * a non-fatal way.
768 * Returns a Fatal Error if the function fails in an unrecoverable way.
769 */
770PKIX_Error *
771PKIX_PL_LdapDefaultClient_CreateByName(
772 char *hostname,
773 PRIntervalTime timeout,
774 LDAPBindAPI *bindAPI,
775 PKIX_PL_LdapDefaultClient **pClient,
776 void *plContext)
777{
778 PRErrorCode status = 0;
779 PKIX_PL_Socket *socket = NULL((void*)0);
780 PKIX_PL_LdapDefaultClient *client = NULL((void*)0);
781
782 PKIX_ENTER(LDAPDEFAULTCLIENT, "PKIX_PL_LdapDefaultClient_CreateByName")static const char cMyFuncName[] = {"PKIX_PL_LdapDefaultClient_CreateByName"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
783 PKIX_NULLCHECK_TWO(hostname, pClient)do { if (((hostname) == ((void*)0)) || ((pClient) == ((void*)
0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
784
785 PKIX_CHECK(pkix_pl_Socket_CreateByNamedo { stdVars.aPkixErrorResult = (pkix_pl_Socket_CreateByName (
((PKIX_Boolean) 0), timeout, hostname, &status, &socket
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETCREATEBYNAMEFAILED; goto cleanup; } } while (0)
786 (PKIX_FALSE, timeout, hostname, &status, &socket, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_Socket_CreateByName (
((PKIX_Boolean) 0), timeout, hostname, &status, &socket
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETCREATEBYNAMEFAILED; goto cleanup; } } while (0)
787 PKIX_SOCKETCREATEBYNAMEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_Socket_CreateByName (
((PKIX_Boolean) 0), timeout, hostname, &status, &socket
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETCREATEBYNAMEFAILED; goto cleanup; } } while (0);
788
789 PKIX_CHECK(pkix_pl_LdapDefaultClient_CreateHelperdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_CreateHelper
(socket, bindAPI, &client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCREATEHELPERFAILED
; goto cleanup; } } while (0)
790 (socket, bindAPI, &client, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_CreateHelper
(socket, bindAPI, &client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCREATEHELPERFAILED
; goto cleanup; } } while (0)
791 PKIX_LDAPDEFAULTCLIENTCREATEHELPERFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_CreateHelper
(socket, bindAPI, &client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCREATEHELPERFAILED
; goto cleanup; } } while (0);
792
793 /* Did Socket_Create say the connection was made? */
794 if (status == 0) {
795 if (client->bindAPI != NULL((void*)0)) {
796 client->connectStatus = CONNECTED;
797 } else {
798 client->connectStatus = BOUND;
799 }
800 } else {
801 client->connectStatus = CONNECT_PENDING;
802 }
803
804 *pClient = client;
805
806cleanup:
807 if (PKIX_ERROR_RECEIVED(stdVars.aPkixErrorReceived || stdVars.aPkixErrorResult || stdVars
.aPkixTempErrorReceived || stdVars.aPkixErrorList)) {
808 PKIX_DECREF(client)do { if (client){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(client), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } client = ((void*)0
); } } while (0);
809 }
810
811 PKIX_DECREF(socket)do { if (socket){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(socket), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } socket = ((void*)0
); } } while (0);
812
813 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
814}
815
816/*
817 * FUNCTION: pkix_pl_LdapDefaultClient_Destroy
818 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
819 */
820static PKIX_Error *
821pkix_pl_LdapDefaultClient_Destroy(
822 PKIX_PL_Object *object,
823 void *plContext)
824{
825 PKIX_Int32 bytesWritten = 0;
826 PKIX_PL_LdapDefaultClient *client = NULL((void*)0);
827 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
828 SECItem *encoded = NULL((void*)0);
829
830 PKIX_ENTER(LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Destroy"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
831 "pkix_pl_LdapDefaultClient_Destroy")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Destroy"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
832 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);
833
834 PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_LDAPDEFAULTCLIENT_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTANLDAPDEFAULTCLIENT; goto cleanup; } } while
(0)
835 (object, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_LDAPDEFAULTCLIENT_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTANLDAPDEFAULTCLIENT; goto cleanup; } } while
(0)
836 PKIX_OBJECTNOTANLDAPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_LDAPDEFAULTCLIENT_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTANLDAPDEFAULTCLIENT; goto cleanup; } } while
(0);
837
838 client = (PKIX_PL_LdapDefaultClient *)object;
839
840 switch (client->connectStatus) {
841 case CONNECT_PENDING:
842 break;
843 case CONNECTED:
844 case BIND_PENDING:
845 case BIND_RESPONSE:
846 case BIND_RESPONSE_PENDING:
847 case BOUND:
848 case SEND_PENDING:
849 case RECV:
850 case RECV_PENDING:
851 case RECV_INITIAL:
852 case RECV_NONINITIAL:
853 case ABANDON_PENDING:
854 if (client->bindAPI != NULL((void*)0)) {
855 PKIX_CHECK(pkix_pl_LdapDefaultClient_MakeUnbinddo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeUnbind
(client->arena, ++(client->messageID), &encoded, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEUNBINDFAILED; goto cleanup; } } while
(0)
856 (client->arena,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeUnbind
(client->arena, ++(client->messageID), &encoded, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEUNBINDFAILED; goto cleanup; } } while
(0)
857 ++(client->messageID),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeUnbind
(client->arena, ++(client->messageID), &encoded, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEUNBINDFAILED; goto cleanup; } } while
(0)
858 &encoded,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeUnbind
(client->arena, ++(client->messageID), &encoded, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEUNBINDFAILED; goto cleanup; } } while
(0)
859 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeUnbind
(client->arena, ++(client->messageID), &encoded, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEUNBINDFAILED; goto cleanup; } } while
(0)
860 PKIX_LDAPDEFAULTCLIENTMAKEUNBINDFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeUnbind
(client->arena, ++(client->messageID), &encoded, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEUNBINDFAILED; goto cleanup; } } while
(0);
861
862 callbackList =
863 (PKIX_PL_Socket_Callback *)(client->callbackList);
864 PKIX_CHECK(callbackList->sendCallbackdo { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
865 (client->clientSocket,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
866 encoded->data,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
867 encoded->len,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
868 &bytesWritten,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
869 plContext),do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
870 PKIX_SOCKETSENDFAILED)do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0);
871 }
872 break;
873 default:
874 PKIX_ERROR(PKIX_LDAPDEFAULTCLIENTINILLEGALSTATE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_LDAPDEFAULTCLIENTINILLEGALSTATE, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTINILLEGALSTATE
; goto cleanup; };
875 }
876
877 PKIX_DECREF(client->cachePtr)do { if (client->cachePtr){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(client->cachePtr), plContext); if (stdVars
.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult
, plContext); stdVars.aPkixTempResult = ((void*)0); } client->
cachePtr = ((void*)0); } } while (0);
878 PKIX_DECREF(client->clientSocket)do { if (client->clientSocket){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(client->clientSocket), plContext); if
(stdVars.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars
.aPkixTempResult, plContext); stdVars.aPkixTempResult = ((void
*)0); } client->clientSocket = ((void*)0); } } while (0);
879 PKIX_DECREF(client->entriesFound)do { if (client->entriesFound){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(client->entriesFound), plContext); if
(stdVars.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars
.aPkixTempResult, plContext); stdVars.aPkixTempResult = ((void
*)0); } client->entriesFound = ((void*)0); } } while (0);
880 PKIX_DECREF(client->currentRequest)do { if (client->currentRequest){ stdVars.aPkixTempResult =
PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentRequest
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentRequest = ((void*)0); } } while
(0);
881 PKIX_DECREF(client->currentResponse)do { if (client->currentResponse){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentResponse
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentResponse = ((void*)0); } }
while (0);
882
883 PKIX_CHECK(PKIX_PL_Freedo { stdVars.aPkixErrorResult = (PKIX_PL_Free (client->rcvBuf
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_FREEFAILED; goto cleanup; } } while (0)
884 (client->rcvBuf, plContext), PKIX_FREEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Free (client->rcvBuf
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_FREEFAILED; goto cleanup; } } while (0);
885
886 PKIX_PL_NSSCALL; (PORT_FreeArena_Util (client->arena, 0))
887 (LDAPDEFAULTCLIENT,; (PORT_FreeArena_Util (client->arena, 0))
888 PORT_FreeArena,; (PORT_FreeArena_Util (client->arena, 0))
889 (client->arena, PR_FALSE)); (PORT_FreeArena_Util (client->arena, 0));
890
891cleanup:
892
893 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
894}
895
896/*
897 * FUNCTION: pkix_pl_LdapDefaultClient_Hashcode
898 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
899 */
900static PKIX_Error *
901pkix_pl_LdapDefaultClient_Hashcode(
902 PKIX_PL_Object *object,
903 PKIX_UInt32 *pHashcode,
904 void *plContext)
905{
906 PKIX_PL_LdapDefaultClient *ldapDefaultClient = NULL((void*)0);
907 PKIX_UInt32 tempHash = 0;
908
909 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Hashcode"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
910 (LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_Hashcode")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Hashcode"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
911 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);
912
913 PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_LDAPDEFAULTCLIENT_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTANLDAPDEFAULTCLIENT; goto cleanup; } } while
(0)
914 (object, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_LDAPDEFAULTCLIENT_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTANLDAPDEFAULTCLIENT; goto cleanup; } } while
(0)
915 PKIX_OBJECTNOTANLDAPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_LDAPDEFAULTCLIENT_TYPE
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_OBJECTNOTANLDAPDEFAULTCLIENT; goto cleanup; } } while
(0);
916
917 ldapDefaultClient = (PKIX_PL_LdapDefaultClient *)object;
918
919 PKIX_CHECK(PKIX_PL_Object_Hashcodedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_Hashcode ((PKIX_PL_Object
*)ldapDefaultClient->clientSocket, &tempHash, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETHASHCODEFAILED; goto cleanup; } } while (0)
920 ((PKIX_PL_Object *)ldapDefaultClient->clientSocket,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Hashcode ((PKIX_PL_Object
*)ldapDefaultClient->clientSocket, &tempHash, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETHASHCODEFAILED; goto cleanup; } } while (0)
921 &tempHash,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Hashcode ((PKIX_PL_Object
*)ldapDefaultClient->clientSocket, &tempHash, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETHASHCODEFAILED; goto cleanup; } } while (0)
922 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Hashcode ((PKIX_PL_Object
*)ldapDefaultClient->clientSocket, &tempHash, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETHASHCODEFAILED; goto cleanup; } } while (0)
923 PKIX_SOCKETHASHCODEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Hashcode ((PKIX_PL_Object
*)ldapDefaultClient->clientSocket, &tempHash, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETHASHCODEFAILED; goto cleanup; } } while (0);
924
925 if (ldapDefaultClient->bindAPI != NULL((void*)0)) {
926 tempHash = (tempHash << 7) +
927 ldapDefaultClient->bindAPI->selector;
928 }
929
930 *pHashcode = tempHash;
931
932cleanup:
933
934 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
935}
936
937/*
938 * FUNCTION: pkix_pl_LdapDefaultClient_Equals
939 * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
940 */
941static PKIX_Error *
942pkix_pl_LdapDefaultClient_Equals(
943 PKIX_PL_Object *firstObject,
944 PKIX_PL_Object *secondObject,
945 PKIX_Int32 *pResult,
946 void *plContext)
947{
948 PKIX_PL_LdapDefaultClient *firstClientContext = NULL((void*)0);
949 PKIX_PL_LdapDefaultClient *secondClientContext = NULL((void*)0);
950 PKIX_Int32 compare = 0;
951
952 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_Equals")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Equals"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
953 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult)do { if (((firstObject) == ((void*)0)) || ((secondObject) == (
(void*)0)) || ((pResult) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
954
955 *pResult = PKIX_FALSE((PKIX_Boolean) 0);
956
957 PKIX_CHECK(pkix_CheckTypesdo { stdVars.aPkixErrorResult = (pkix_CheckTypes (firstObject
, secondObject, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_OBJECTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
958 (firstObject,do { stdVars.aPkixErrorResult = (pkix_CheckTypes (firstObject
, secondObject, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_OBJECTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
959 secondObject,do { stdVars.aPkixErrorResult = (pkix_CheckTypes (firstObject
, secondObject, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_OBJECTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
960 PKIX_LDAPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (pkix_CheckTypes (firstObject
, secondObject, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_OBJECTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
961 plContext),do { stdVars.aPkixErrorResult = (pkix_CheckTypes (firstObject
, secondObject, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_OBJECTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
962 PKIX_OBJECTNOTANLDAPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckTypes (firstObject
, secondObject, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_OBJECTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0);
963
964 firstClientContext = (PKIX_PL_LdapDefaultClient *)firstObject;
965 secondClientContext = (PKIX_PL_LdapDefaultClient *)secondObject;
966
967 if (firstClientContext == secondClientContext) {
968 *pResult = PKIX_TRUE((PKIX_Boolean) 1);
969 goto cleanup;
970 }
971
972 PKIX_CHECK(PKIX_PL_Object_Equalsdo { stdVars.aPkixErrorResult = (PKIX_PL_Object_Equals ((PKIX_PL_Object
*)firstClientContext->clientSocket, (PKIX_PL_Object *)secondClientContext
->clientSocket, &compare, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETEQUALSFAILED; goto cleanup
; } } while (0)
973 ((PKIX_PL_Object *)firstClientContext->clientSocket,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Equals ((PKIX_PL_Object
*)firstClientContext->clientSocket, (PKIX_PL_Object *)secondClientContext
->clientSocket, &compare, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETEQUALSFAILED; goto cleanup
; } } while (0)
974 (PKIX_PL_Object *)secondClientContext->clientSocket,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Equals ((PKIX_PL_Object
*)firstClientContext->clientSocket, (PKIX_PL_Object *)secondClientContext
->clientSocket, &compare, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETEQUALSFAILED; goto cleanup
; } } while (0)
975 &compare,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Equals ((PKIX_PL_Object
*)firstClientContext->clientSocket, (PKIX_PL_Object *)secondClientContext
->clientSocket, &compare, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETEQUALSFAILED; goto cleanup
; } } while (0)
976 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Equals ((PKIX_PL_Object
*)firstClientContext->clientSocket, (PKIX_PL_Object *)secondClientContext
->clientSocket, &compare, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETEQUALSFAILED; goto cleanup
; } } while (0)
977 PKIX_SOCKETEQUALSFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Equals ((PKIX_PL_Object
*)firstClientContext->clientSocket, (PKIX_PL_Object *)secondClientContext
->clientSocket, &compare, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETEQUALSFAILED; goto cleanup
; } } while (0);
978
979 if (!compare) {
980 goto cleanup;
981 }
982
983 if (PKIX_EXACTLY_ONE_NULL(((firstClientContext->bindAPI) && !(secondClientContext
->bindAPI)) || ((secondClientContext->bindAPI) &&
!(firstClientContext->bindAPI)))
984 (firstClientContext->bindAPI, secondClientContext->bindAPI)(((firstClientContext->bindAPI) && !(secondClientContext
->bindAPI)) || ((secondClientContext->bindAPI) &&
!(firstClientContext->bindAPI)))) {
985 goto cleanup;
986 }
987
988 if (firstClientContext->bindAPI) {
989 if (firstClientContext->bindAPI->selector !=
990 secondClientContext->bindAPI->selector) {
991 goto cleanup;
992 }
993 }
994
995 *pResult = PKIX_TRUE((PKIX_Boolean) 1);
996
997cleanup:
998
999 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1000}
1001
1002/*
1003 * FUNCTION: pkix_pl_LdapDefaultClient_RegisterSelf
1004 *
1005 * DESCRIPTION:
1006 * Registers PKIX_PL_LDAPDEFAULTCLIENT_TYPE and its related
1007 * functions with systemClasses[]
1008 *
1009 * THREAD SAFETY:
1010 * Not Thread Safe - for performance and complexity reasons
1011 *
1012 * Since this function is only called by PKIX_PL_Initialize, which should
1013 * only be called once, it is acceptable that this function is not
1014 * thread-safe.
1015 */
1016PKIX_Error *
1017pkix_pl_LdapDefaultClient_RegisterSelf(void *plContext)
1018{
1019 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
1020 pkix_ClassTable_Entry entry;
1021
1022 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RegisterSelf"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1023 (LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RegisterSelf"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1024 "pkix_pl_LdapDefaultClient_RegisterSelf")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RegisterSelf"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1025
1026 entry.description = "LdapDefaultClient";
1027 entry.objCounter = 0;
1028 entry.typeObjectSize = sizeof(PKIX_PL_LdapDefaultClient);
1029 entry.destructor = pkix_pl_LdapDefaultClient_Destroy;
1030 entry.equalsFunction = pkix_pl_LdapDefaultClient_Equals;
1031 entry.hashcodeFunction = pkix_pl_LdapDefaultClient_Hashcode;
1032 entry.toStringFunction = NULL((void*)0);
1033 entry.comparator = NULL((void*)0);
1034 entry.duplicateFunction = NULL((void*)0);
1035
1036 systemClasses[PKIX_LDAPDEFAULTCLIENT_TYPE] = entry;
1037
1038 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1039}
1040
1041/*
1042 * FUNCTION: pkix_pl_LdapDefaultClient_GetPollDesc
1043 * DESCRIPTION:
1044 *
1045 * This function retrieves the PRPollDesc from the LdapDefaultClient
1046 * pointed to by "context" and stores the address at "pPollDesc".
1047 *
1048 * PARAMETERS:
1049 * "context"
1050 * The LdapDefaultClient whose PRPollDesc is desired. Must be non-NULL.
1051 * "pPollDesc"
1052 * Address where PRPollDesc will be stored. Must be non-NULL.
1053 * "plContext"
1054 * Platform-specific context pointer.
1055 * THREAD SAFETY:
1056 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1057 * RETURNS:
1058 * Returns NULL if the function succeeds.
1059 * Returns a Fatal Error if the function fails in an unrecoverable way.
1060 */
1061PKIX_Error *
1062pkix_pl_LdapDefaultClient_GetPollDesc(
1063 PKIX_PL_LdapDefaultClient *context,
1064 PRPollDesc **pPollDesc,
1065 void *plContext)
1066{
1067 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_GetPollDesc"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1068 (LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_GetPollDesc"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1069 "pkix_pl_LdapDefaultClient_GetPollDesc")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_GetPollDesc"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1070 PKIX_NULLCHECK_TWO(context, pPollDesc)do { if (((context) == ((void*)0)) || ((pPollDesc) == ((void*
)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
1071
1072 *pPollDesc = &(context->pollDesc);
1073
1074 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1075}
1076
1077/* --Private-Ldap-CertStore-I/O-Functions---------------------------- */
1078/*
1079 * FUNCTION: pkix_pl_LdapDefaultClient_ConnectContinue
1080 * DESCRIPTION:
1081 *
1082 * This function determines whether a socket Connect initiated earlier for the
1083 * CertStore embodied in the LdapDefaultClient "client" has completed, and
1084 * stores in "pKeepGoing" a flag indicating whether processing can continue
1085 * without further input.
1086 *
1087 * PARAMETERS:
1088 * "client"
1089 * The address of the LdapDefaultClient object. Must be non-NULL.
1090 * "pKeepGoing"
1091 * The address at which the Boolean state machine flag is stored to
1092 * indicate whether processing can continue without further input.
1093 * Must be non-NULL.
1094 * "plContext"
1095 * Platform-specific context pointer.
1096 * THREAD SAFETY:
1097 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1098 * RETURNS:
1099 * Returns NULL if the function succeeds.
1100 * Returns a LdapDefaultClient Error if the function fails in a
1101 * non-fatal way.
1102 * Returns a Fatal Error if the function fails in an unrecoverable way.
1103 */
1104static PKIX_Error *
1105pkix_pl_LdapDefaultClient_ConnectContinue(
1106 PKIX_PL_LdapDefaultClient *client,
1107 PKIX_Boolean *pKeepGoing,
1108 void *plContext)
1109{
1110 PKIX_PL_Socket_Callback *callbackList;
1111 PRErrorCode status;
1112 PKIX_Boolean keepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1113
1114 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_ConnectContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1115 (LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_ConnectContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1116 "pkix_pl_LdapDefaultClient_ConnectContinue")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_ConnectContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1117 PKIX_NULLCHECK_ONE(client)do { if ((client) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1118
1119 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1120
1121 PKIX_CHECK(callbackList->connectcontinueCallbackdo { stdVars.aPkixErrorResult = (callbackList->connectcontinueCallback
(client->clientSocket, &status, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETCONNECTCONTINUEFAILED
; goto cleanup; } } while (0)
1122 (client->clientSocket, &status, plContext),do { stdVars.aPkixErrorResult = (callbackList->connectcontinueCallback
(client->clientSocket, &status, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETCONNECTCONTINUEFAILED
; goto cleanup; } } while (0)
1123 PKIX_SOCKETCONNECTCONTINUEFAILED)do { stdVars.aPkixErrorResult = (callbackList->connectcontinueCallback
(client->clientSocket, &status, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETCONNECTCONTINUEFAILED
; goto cleanup; } } while (0);
1124
1125 if (status == 0) {
1126 if (client->bindAPI != NULL((void*)0)) {
1127 client->connectStatus = CONNECTED;
1128 } else {
1129 client->connectStatus = BOUND;
1130 }
1131 keepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1132 } else if (status != PR_IN_PROGRESS_ERROR(-5934L)) {
1133 PKIX_ERROR(PKIX_UNEXPECTEDERRORINESTABLISHINGCONNECTION){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_UNEXPECTEDERRORINESTABLISHINGCONNECTION, ((void*)0), stdVars
.aPkixType, 2, plContext); } } stdVars.aPkixErrorReceived = (
(PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_UNEXPECTEDERRORINESTABLISHINGCONNECTION
; goto cleanup; };
1134 }
1135
1136 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1137 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1138 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1139
1140 *pKeepGoing = keepGoing;
1141
1142cleanup:
1143 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1144}
1145
1146/*
1147 * FUNCTION: pkix_pl_LdapDefaultClient_Bind
1148 * DESCRIPTION:
1149 *
1150 * This function creates and sends the LDAP-protocol Bind message for the
1151 * CertStore embodied in the LdapDefaultClient "client", and stores in
1152 * "pKeepGoing" a flag indicating whether processing can continue without
1153 * further input.
1154 *
1155 * PARAMETERS:
1156 * "client"
1157 * The address of the LdapDefaultClient object. Must be non-NULL.
1158 * "pKeepGoing"
1159 * The address at which the Boolean state machine flag is stored to
1160 * indicate whether processing can continue without further input.
1161 * Must be non-NULL.
1162 * "plContext"
1163 * Platform-specific context pointer.
1164 * THREAD SAFETY:
1165 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1166 * RETURNS:
1167 * Returns NULL if the function succeeds.
1168 * Returns a LdapDefaultClient Error if the function fails in a
1169 * non-fatal way.
1170 * Returns a Fatal Error if the function fails in an unrecoverable way.
1171 */
1172static PKIX_Error *
1173pkix_pl_LdapDefaultClient_Bind(
1174 PKIX_PL_LdapDefaultClient *client,
1175 PKIX_Boolean *pKeepGoing,
1176 void *plContext)
1177{
1178 SECItem *encoded = NULL((void*)0);
1179 PKIX_Int32 bytesWritten = 0;
1180 PKIX_PL_Socket_Callback *callbackList;
1181
1182 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_Bind")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Bind"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1183 PKIX_NULLCHECK_ONE(client)do { if ((client) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1184
1185 /* if we have not yet constructed the BIND message, build it now */
1186 if (!(client->bindMsg)) {
1187 PKIX_CHECK(pkix_pl_LdapDefaultClient_MakeBinddo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeBind
(client->arena, 3, client->bindAPI, client->messageID
, &encoded, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED; goto cleanup
; } } while (0)
1188 (client->arena,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeBind
(client->arena, 3, client->bindAPI, client->messageID
, &encoded, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED; goto cleanup
; } } while (0)
1189 3,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeBind
(client->arena, 3, client->bindAPI, client->messageID
, &encoded, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED; goto cleanup
; } } while (0)
1190 client->bindAPI,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeBind
(client->arena, 3, client->bindAPI, client->messageID
, &encoded, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED; goto cleanup
; } } while (0)
1191 client->messageID,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeBind
(client->arena, 3, client->bindAPI, client->messageID
, &encoded, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED; goto cleanup
; } } while (0)
1192 &encoded,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeBind
(client->arena, 3, client->bindAPI, client->messageID
, &encoded, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED; goto cleanup
; } } while (0)
1193 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeBind
(client->arena, 3, client->bindAPI, client->messageID
, &encoded, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED; goto cleanup
; } } while (0)
1194 PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeBind
(client->arena, 3, client->bindAPI, client->messageID
, &encoded, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTMAKEBINDFAILED; goto cleanup
; } } while (0);
1195 client->bindMsg = encoded->data;
1196 client->bindMsgLen = encoded->len;
1197 }
1198
1199 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1200
1201 PKIX_CHECK(callbackList->sendCallbackdo { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->bindMsg, client->bindMsgLen
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1202 (client->clientSocket,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->bindMsg, client->bindMsgLen
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1203 client->bindMsg,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->bindMsg, client->bindMsgLen
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1204 client->bindMsgLen,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->bindMsg, client->bindMsgLen
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1205 &bytesWritten,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->bindMsg, client->bindMsgLen
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1206 plContext),do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->bindMsg, client->bindMsgLen
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1207 PKIX_SOCKETSENDFAILED)do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->bindMsg, client->bindMsgLen
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0);
1208
1209 client->lastIO = PR_Now();
1210
1211 if (bytesWritten < 0) {
1212 client->connectStatus = BIND_PENDING;
1213 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1214 } else {
1215 client->connectStatus = BIND_RESPONSE;
1216 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1217 }
1218
1219 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1220 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1221 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1222
1223cleanup:
1224 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1225}
1226
1227/*
1228 * FUNCTION: pkix_pl_LdapDefaultClient_BindContinue
1229 * DESCRIPTION:
1230 *
1231 * This function determines whether the LDAP-protocol Bind message for the
1232 * CertStore embodied in the LdapDefaultClient "client" has completed, and
1233 * stores in "pKeepGoing" a flag indicating whether processing can continue
1234 * without further input.
1235 *
1236 * PARAMETERS:
1237 * "client"
1238 * The address of the LdapDefaultClient object. Must be non-NULL.
1239 * "pKeepGoing"
1240 * The address at which the Boolean state machine flag is stored to
1241 * indicate whether processing can continue without further input.
1242 * Must be non-NULL.
1243 * "plContext"
1244 * Platform-specific context pointer.
1245 * THREAD SAFETY:
1246 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1247 * RETURNS:
1248 * Returns NULL if the function succeeds.
1249 * Returns a LdapDefaultClient Error if the function fails in a
1250 * non-fatal way.
1251 * Returns a Fatal Error if the function fails in an unrecoverable way.
1252 */
1253PKIX_Error *pkix_pl_LdapDefaultClient_BindContinue(
1254 PKIX_PL_LdapDefaultClient *client,
1255 PKIX_Boolean *pKeepGoing,
1256 void *plContext)
1257{
1258 PKIX_Int32 bytesWritten = 0;
1259 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1260
1261 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_BindContinue")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_BindContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1262 PKIX_NULLCHECK_ONE(client)do { if ((client) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1263
1264 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1265
1266 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1267
1268 PKIX_CHECK(callbackList->pollCallbackdo { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1269 (client->clientSocket, &bytesWritten, NULL, plContext),do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1270 PKIX_SOCKETPOLLFAILED)do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0);
1271
1272 /*
1273 * If the send completed we can proceed to try for the
1274 * response. If the send did not complete we will have
1275 * continue to poll.
1276 */
1277 if (bytesWritten >= 0) {
1278
1279 client->connectStatus = BIND_RESPONSE;
1280
1281 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1282 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1283 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1284
1285 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1286 }
1287
1288cleanup:
1289 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1290}
1291
1292/*
1293 * FUNCTION: pkix_pl_LdapDefaultClient_BindResponse
1294 * DESCRIPTION:
1295 *
1296 * This function attempts to read the LDAP-protocol BindResponse message for
1297 * the CertStore embodied in the LdapDefaultClient "client", and stores in
1298 * "pKeepGoing" a flag indicating whether processing can continue without
1299 * further input.
1300 *
1301 * If a BindResponse is received with a Result code of 0 (success), we
1302 * continue with the connection. If a non-zero Result code is received,
1303 * we throw an Error. Some more sophisticated handling of that condition
1304 * might be in order in the future.
1305 *
1306 * PARAMETERS:
1307 * "client"
1308 * The address of the LdapDefaultClient object. Must be non-NULL.
1309 * "pKeepGoing"
1310 * The address at which the Boolean state machine flag is stored to
1311 * indicate whether processing can continue without further input.
1312 * Must be non-NULL.
1313 * "plContext"
1314 * Platform-specific context pointer.
1315 * THREAD SAFETY:
1316 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1317 * RETURNS:
1318 * Returns NULL if the function succeeds.
1319 * Returns a LdapDefaultClient Error if the function fails in a
1320 * non-fatal way.
1321 * Returns a Fatal Error if the function fails in an unrecoverable way.
1322 */
1323static PKIX_Error *
1324pkix_pl_LdapDefaultClient_BindResponse(
1325 PKIX_PL_LdapDefaultClient *client,
1326 PKIX_Boolean *pKeepGoing,
1327 void *plContext)
1328{
1329 PKIX_Int32 bytesRead = 0;
1330 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1331
1332 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_BindResponse")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_BindResponse"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1333 PKIX_NULLCHECK_TWO(client, client->rcvBuf)do { if (((client) == ((void*)0)) || ((client->rcvBuf) == (
(void*)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1);
stdVars.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn
(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext
);; } } while (0);
1334
1335 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1336
1337 PKIX_CHECK(callbackList->recvCallbackdo { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, client->rcvBuf, client->capacity
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1338 (client->clientSocket,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, client->rcvBuf, client->capacity
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1339 client->rcvBuf,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, client->rcvBuf, client->capacity
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1340 client->capacity,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, client->rcvBuf, client->capacity
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1341 &bytesRead,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, client->rcvBuf, client->capacity
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1342 plContext),do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, client->rcvBuf, client->capacity
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1343 PKIX_SOCKETRECVFAILED)do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, client->rcvBuf, client->capacity
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0);
1344
1345 client->lastIO = PR_Now();
1346
1347 if (bytesRead > 0) {
1348 PKIX_CHECK(pkix_pl_LdapDefaultClient_VerifyBindResponsedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_VerifyBindResponse
(client, bytesRead, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTVERIFYBINDRESPONSEFAILED
; goto cleanup; } } while (0)
1349 (client, bytesRead, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_VerifyBindResponse
(client, bytesRead, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTVERIFYBINDRESPONSEFAILED
; goto cleanup; } } while (0)
1350 PKIX_LDAPDEFAULTCLIENTVERIFYBINDRESPONSEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_VerifyBindResponse
(client, bytesRead, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTVERIFYBINDRESPONSEFAILED
; goto cleanup; } } while (0);
1351 /*
1352 * XXX What should we do if failure? At present if
1353 * VerifyBindResponse throws an Error, we do too.
1354 */
1355 client->connectStatus = BOUND;
1356 } else {
1357 client->connectStatus = BIND_RESPONSE_PENDING;
1358 }
1359
1360 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1361 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1362 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1363
1364 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1365
1366cleanup:
1367 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1368}
1369
1370/*
1371 * FUNCTION: pkix_pl_LdapDefaultClient_BindResponseContinue
1372 * DESCRIPTION:
1373 *
1374 * This function determines whether the LDAP-protocol BindResponse message for
1375 * the CertStore embodied in the LdapDefaultClient "client" has completed, and
1376 * stores in "pKeepGoing" a flag indicating whether processing can continue
1377 * without further input.
1378 *
1379 * PARAMETERS:
1380 * "client"
1381 * The address of the LdapDefaultClient object. Must be non-NULL.
1382 * "pKeepGoing"
1383 * The address at which the Boolean state machine flag is stored to
1384 * indicate whether processing can continue without further input.
1385 * Must be non-NULL.
1386 * "plContext"
1387 * Platform-specific context pointer.
1388 * THREAD SAFETY:
1389 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1390 * RETURNS:
1391 * Returns NULL if the function succeeds.
1392 * Returns a LdapDefaultClient Error if the function fails in a
1393 * non-fatal way.
1394 * Returns a Fatal Error if the function fails in an unrecoverable way.
1395 */
1396static PKIX_Error *
1397pkix_pl_LdapDefaultClient_BindResponseContinue(
1398 PKIX_PL_LdapDefaultClient *client,
1399 PKIX_Boolean *pKeepGoing,
1400 void *plContext)
1401{
1402 PKIX_Int32 bytesRead = 0;
1403 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1404
1405 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_BindResponseContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1406 (LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_BindResponseContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1407 "pkix_pl_LdapDefaultClient_BindResponseContinue")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_BindResponseContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1408 PKIX_NULLCHECK_ONE(client)do { if ((client) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1409
1410 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1411
1412 PKIX_CHECK(callbackList->pollCallbackdo { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, ((void*)0), &bytesRead, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1413 (client->clientSocket, NULL, &bytesRead, plContext),do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, ((void*)0), &bytesRead, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1414 PKIX_SOCKETPOLLFAILED)do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, ((void*)0), &bytesRead, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0);
1415
1416 if (bytesRead > 0) {
1417 PKIX_CHECK(pkix_pl_LdapDefaultClient_VerifyBindResponsedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_VerifyBindResponse
(client, bytesRead, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTVERIFYBINDRESPONSEFAILED
; goto cleanup; } } while (0)
1418 (client, bytesRead, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_VerifyBindResponse
(client, bytesRead, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTVERIFYBINDRESPONSEFAILED
; goto cleanup; } } while (0)
1419 PKIX_LDAPDEFAULTCLIENTVERIFYBINDRESPONSEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_VerifyBindResponse
(client, bytesRead, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTVERIFYBINDRESPONSEFAILED
; goto cleanup; } } while (0);
1420 client->connectStatus = BOUND;
1421
1422 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1423 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1424 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1425
1426 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1427 } else {
1428 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1429 }
1430
1431cleanup:
1432 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1433}
1434
1435/*
1436 * FUNCTION: pkix_pl_LdapDefaultClient_Send
1437 * DESCRIPTION:
1438 *
1439 * This function creates and sends an LDAP-protocol message for the
1440 * CertStore embodied in the LdapDefaultClient "client", and stores in
1441 * "pKeepGoing" a flag indicating whether processing can continue without
1442 * further input, and at "pBytesTransferred" the number of bytes sent.
1443 *
1444 * If "pBytesTransferred" is zero, it indicates that non-blocking I/O is in use
1445 * and that transmission has not completed.
1446 *
1447 * PARAMETERS:
1448 * "client"
1449 * The address of the LdapDefaultClient object. Must be non-NULL.
1450 * "pKeepGoing"
1451 * The address at which the Boolean state machine flag is stored to
1452 * indicate whether processing can continue without further input.
1453 * Must be non-NULL.
1454 * "pBytesTransferred"
1455 * The address at which the number of bytes sent is stored. Must be
1456 * non-NULL.
1457 * "plContext"
1458 * Platform-specific context pointer.
1459 * THREAD SAFETY:
1460 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1461 * RETURNS:
1462 * Returns NULL if the function succeeds.
1463 * Returns a LdapDefaultClient Error if the function fails in a
1464 * non-fatal way.
1465 * Returns a Fatal Error if the function fails in an unrecoverable way.
1466 */
1467static PKIX_Error *
1468pkix_pl_LdapDefaultClient_Send(
1469 PKIX_PL_LdapDefaultClient *client,
1470 PKIX_Boolean *pKeepGoing,
1471 PKIX_UInt32 *pBytesTransferred,
1472 void *plContext)
1473{
1474 PKIX_Int32 bytesWritten = 0;
1475 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1476
1477 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_Send")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Send"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1478 PKIX_NULLCHECK_THREE(client, pKeepGoing, pBytesTransferred)do { if (((client) == ((void*)0)) || ((pKeepGoing) == ((void*
)0)) || ((pBytesTransferred) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1479
1480 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1481
1482 /* Do we have anything waiting to go? */
1483 if (client->sendBuf) {
1484 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1485
1486 PKIX_CHECK(callbackList->sendCallbackdo { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->sendBuf, client->bytesToWrite
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1487 (client->clientSocket,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->sendBuf, client->bytesToWrite
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1488 client->sendBuf,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->sendBuf, client->bytesToWrite
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1489 client->bytesToWrite,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->sendBuf, client->bytesToWrite
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1490 &bytesWritten,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->sendBuf, client->bytesToWrite
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1491 plContext),do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->sendBuf, client->bytesToWrite
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
1492 PKIX_SOCKETSENDFAILED)do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, client->sendBuf, client->bytesToWrite
, &bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0);
1493
1494 client->lastIO = PR_Now();
1495
1496 /*
1497 * If the send completed we can proceed to try for the
1498 * response. If the send did not complete we will have
1499 * to poll for completion later.
1500 */
1501 if (bytesWritten >= 0) {
1502 client->sendBuf = NULL((void*)0);
1503 client->connectStatus = RECV;
1504 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1505
1506 } else {
1507 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1508 client->connectStatus = SEND_PENDING;
1509 }
1510
1511 }
1512
1513 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1514 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1515 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1516
1517 *pBytesTransferred = bytesWritten;
1518
1519cleanup:
1520 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1521}
1522
1523/*
1524 * FUNCTION: pkix_pl_LdapDefaultClient_SendContinue
1525 * DESCRIPTION:
1526 *
1527 * This function determines whether the sending of the LDAP-protocol message
1528 * for the CertStore embodied in the LdapDefaultClient "client" has completed,
1529 * and stores in "pKeepGoing" a flag indicating whether processing can continue
1530 * without further input, and at "pBytesTransferred" the number of bytes sent.
1531 *
1532 * If "pBytesTransferred" is zero, it indicates that non-blocking I/O is in use
1533 * and that transmission has not completed.
1534 *
1535 * PARAMETERS:
1536 * "client"
1537 * The address of the LdapDefaultClient object. Must be non-NULL.
1538 * "pKeepGoing"
1539 * The address at which the Boolean state machine flag is stored to
1540 * indicate whether processing can continue without further input.
1541 * Must be non-NULL.
1542 * "pBytesTransferred"
1543 * The address at which the number of bytes sent is stored. Must be
1544 * non-NULL.
1545 * "plContext"
1546 * Platform-specific context pointer.
1547 * THREAD SAFETY:
1548 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1549 * RETURNS:
1550 * Returns NULL if the function succeeds.
1551 * Returns a LdapDefaultClient Error if the function fails in a
1552 * non-fatal way.
1553 * Returns a Fatal Error if the function fails in an unrecoverable way.
1554 */
1555static PKIX_Error *
1556pkix_pl_LdapDefaultClient_SendContinue(
1557 PKIX_PL_LdapDefaultClient *client,
1558 PKIX_Boolean *pKeepGoing,
1559 PKIX_UInt32 *pBytesTransferred,
1560 void *plContext)
1561{
1562 PKIX_Int32 bytesWritten = 0;
1563 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1564
1565 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_SendContinue")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_SendContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1566 PKIX_NULLCHECK_THREE(client, pKeepGoing, pBytesTransferred)do { if (((client) == ((void*)0)) || ((pKeepGoing) == ((void*
)0)) || ((pBytesTransferred) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1567
1568 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1569
1570 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1571
1572 PKIX_CHECK(callbackList->pollCallbackdo { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1573 (client->clientSocket, &bytesWritten, NULL, plContext),do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1574 PKIX_SOCKETPOLLFAILED)do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0);
1575
1576 /*
1577 * If the send completed we can proceed to try for the
1578 * response. If the send did not complete we will have
1579 * continue to poll.
1580 */
1581 if (bytesWritten >= 0) {
1582 client->sendBuf = NULL((void*)0);
1583 client->connectStatus = RECV;
1584
1585 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1586 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1587 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1588
1589 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1590 }
1591
1592 *pBytesTransferred = bytesWritten;
1593
1594cleanup:
1595 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1596}
1597
1598/*
1599 * FUNCTION: pkix_pl_LdapDefaultClient_Recv
1600 * DESCRIPTION:
1601 *
1602 * This function receives an LDAP-protocol message for the CertStore embodied
1603 * in the LdapDefaultClient "client", and stores in "pKeepGoing" a flag
1604 * indicating whether processing can continue without further input.
1605 *
1606 * PARAMETERS:
1607 * "client"
1608 * The address of the LdapDefaultClient object. Must be non-NULL.
1609 * "pKeepGoing"
1610 * The address at which the Boolean state machine flag is stored to
1611 * indicate whether processing can continue without further input.
1612 * Must be non-NULL.
1613 * "plContext"
1614 * Platform-specific context pointer.
1615 * THREAD SAFETY:
1616 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1617 * RETURNS:
1618 * Returns NULL if the function succeeds.
1619 * Returns a LdapDefaultClient Error if the function fails in a
1620 * non-fatal way.
1621 * Returns a Fatal Error if the function fails in an unrecoverable way.
1622 */
1623static PKIX_Error *
1624pkix_pl_LdapDefaultClient_Recv(
1625 PKIX_PL_LdapDefaultClient *client,
1626 PKIX_Boolean *pKeepGoing,
1627 void *plContext)
1628{
1629 PKIX_Int32 bytesRead = 0;
1630 PKIX_UInt32 bytesToRead = 0;
1631 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1632
1633 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_Recv")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Recv"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1634 PKIX_NULLCHECK_THREE(client, pKeepGoing, client->rcvBuf)do { if (((client) == ((void*)0)) || ((pKeepGoing) == ((void*
)0)) || ((client->rcvBuf) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1635
1636 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1637
1638 /*
1639 * If we attempt to fill our buffer with every read, we increase
1640 * the risk of an ugly situation: one or two bytes of a new message
1641 * left over at the end of processing one message. With such a
1642 * fragment, we can't decode a byte count and so won't know how much
1643 * space to allocate for the next LdapResponse. We try to avoid that
1644 * case by reading just enough to complete the current message, unless
1645 * there will be at least MINIMUM_MSG_LENGTH bytes left over.
1646 */
1647 if (client->currentResponse) {
1648 PKIX_CHECK(pkix_pl_LdapResponse_GetCapacitydo { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetCapacity
(client->currentResponse, &bytesToRead, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETCAPACITYFAILED
; goto cleanup; } } while (0)
1649 (client->currentResponse, &bytesToRead, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetCapacity
(client->currentResponse, &bytesToRead, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETCAPACITYFAILED
; goto cleanup; } } while (0)
1650 PKIX_LDAPRESPONSEGETCAPACITYFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_GetCapacity
(client->currentResponse, &bytesToRead, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEGETCAPACITYFAILED
; goto cleanup; } } while (0);
1651 if ((bytesToRead > client->capacity) ||
1652 ((bytesToRead + MINIMUM_MSG_LENGTH5) < client->capacity)) {
1653 bytesToRead = client->capacity;
1654 }
1655 } else {
1656 bytesToRead = client->capacity;
1657 }
1658
1659 client->currentBytesAvailable = 0;
1660
1661 PKIX_CHECK(callbackList->recvCallbackdo { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)client->rcvBuf, bytesToRead
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1662 (client->clientSocket,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)client->rcvBuf, bytesToRead
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1663 (void *)client->rcvBuf,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)client->rcvBuf, bytesToRead
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1664 bytesToRead,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)client->rcvBuf, bytesToRead
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1665 &bytesRead,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)client->rcvBuf, bytesToRead
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1666 plContext),do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)client->rcvBuf, bytesToRead
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0)
1667 PKIX_SOCKETRECVFAILED)do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)client->rcvBuf, bytesToRead
, &bytesRead, plContext)); if (stdVars.aPkixErrorResult) {
stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED; goto cleanup
; } } while (0);
1668
1669 client->currentInPtr = client->rcvBuf;
1670 client->lastIO = PR_Now();
1671
1672 if (bytesRead > 0) {
1673 client->currentBytesAvailable = bytesRead;
1674 client->connectStatus = RECV_INITIAL;
1675 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1676 } else {
1677 client->connectStatus = RECV_PENDING;
1678 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1679 }
1680
1681 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1682 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1683 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1684
1685cleanup:
1686 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1687}
1688
1689/*
1690 * FUNCTION: pkix_pl_LdapDefaultClient_RecvContinue
1691 * DESCRIPTION:
1692 *
1693 * This function determines whether the receiving of the LDAP-protocol message
1694 * for the CertStore embodied in the LdapDefaultClient "client" has completed,
1695 * and stores in "pKeepGoing" a flag indicating whether processing can continue
1696 * without further input.
1697 *
1698 * PARAMETERS:
1699 * "client"
1700 * The address of the LdapDefaultClient object. Must be non-NULL.
1701 * "pKeepGoing"
1702 * The address at which the Boolean state machine flag is stored to
1703 * indicate whether processing can continue without further input.
1704 * Must be non-NULL.
1705 * "plContext"
1706 * Platform-specific context pointer.
1707 * THREAD SAFETY:
1708 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1709 * RETURNS:
1710 * Returns NULL if the function succeeds.
1711 * Returns a LdapDefaultClient Error if the function fails in a
1712 * non-fatal way.
1713 * Returns a Fatal Error if the function fails in an unrecoverable way.
1714 */
1715static PKIX_Error *
1716pkix_pl_LdapDefaultClient_RecvContinue(
1717 PKIX_PL_LdapDefaultClient *client,
1718 PKIX_Boolean *pKeepGoing,
1719 void *plContext)
1720{
1721 PKIX_Int32 bytesRead = 0;
1722 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1723
1724 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_RecvContinue")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RecvContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1725 PKIX_NULLCHECK_TWO(client, pKeepGoing)do { if (((client) == ((void*)0)) || ((pKeepGoing) == ((void*
)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
1726
1727 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1728
1729 PKIX_CHECK(callbackList->pollCallbackdo { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, ((void*)0), &bytesRead, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1730 (client->clientSocket, NULL, &bytesRead, plContext),do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, ((void*)0), &bytesRead, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1731 PKIX_SOCKETPOLLFAILED)do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, ((void*)0), &bytesRead, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0);
1732
1733 if (bytesRead > 0) {
1734 client->currentBytesAvailable += bytesRead;
1735 client->connectStatus = RECV_INITIAL;
1736 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1737
1738 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1739 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1740 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1741 } else {
1742 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1743 }
1744
1745cleanup:
1746 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1747}
1748
1749/*
1750 * FUNCTION: pkix_pl_LdapDefaultClient_AbandonContinue
1751 * DESCRIPTION:
1752 *
1753 * This function determines whether the abandon-message request of the
1754 * LDAP-protocol message for the CertStore embodied in the LdapDefaultClient
1755 * "client" has completed, and stores in "pKeepGoing" a flag indicating whether
1756 * processing can continue without further input.
1757 *
1758 * PARAMETERS:
1759 * "client"
1760 * The address of the LdapDefaultClient object. Must be non-NULL.
1761 * "pKeepGoing"
1762 * The address at which the Boolean state machine flag is stored to
1763 * indicate whether processing can continue without further input.
1764 * Must be non-NULL.
1765 * "plContext"
1766 * Platform-specific context pointer.
1767 * THREAD SAFETY:
1768 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1769 * RETURNS:
1770 * Returns NULL if the function succeeds.
1771 * Returns a LdapDefaultClient Error if the function fails in a
1772 * non-fatal way.
1773 * Returns a Fatal Error if the function fails in an unrecoverable way.
1774 */
1775static PKIX_Error *
1776pkix_pl_LdapDefaultClient_AbandonContinue(
1777 PKIX_PL_LdapDefaultClient *client,
1778 PKIX_Boolean *pKeepGoing,
1779 void *plContext)
1780{
1781 PKIX_Int32 bytesWritten = 0;
1782 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1783
1784 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_AbandonContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1785 (LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_AbandonContinue")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_AbandonContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1786 PKIX_NULLCHECK_TWO(client, pKeepGoing)do { if (((client) == ((void*)0)) || ((pKeepGoing) == ((void*
)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
1787
1788 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1789
1790 PKIX_CHECK(callbackList->pollCallbackdo { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1791 (client->clientSocket, &bytesWritten, NULL, plContext),do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0)
1792 PKIX_SOCKETPOLLFAILED)do { stdVars.aPkixErrorResult = (callbackList->pollCallback
(client->clientSocket, &bytesWritten, ((void*)0), plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_SOCKETPOLLFAILED; goto cleanup; } } while (0);
1793
1794 if (bytesWritten > 0) {
1795 client->connectStatus = BOUND;
1796 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1797
1798 PKIX_CHECK(PKIX_PL_Object_InvalidateCachedo { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1799 ((PKIX_PL_Object *)client, plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0)
1800 PKIX_OBJECTINVALIDATECACHEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_InvalidateCache
((PKIX_PL_Object *)client, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_OBJECTINVALIDATECACHEFAILED; goto
cleanup; } } while (0);
1801 } else {
1802 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1803 }
1804
1805cleanup:
1806 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1807}
1808
1809/*
1810 * FUNCTION: pkix_pl_LdapDefaultClient_RecvInitial
1811 * DESCRIPTION:
1812 *
1813 * This function processes the contents of the first buffer of a received
1814 * LDAP-protocol message for the CertStore embodied in the LdapDefaultClient
1815 * "client", and stores in "pKeepGoing" a flag indicating whether processing can
1816 * continue without further input.
1817 *
1818 * PARAMETERS:
1819 * "client"
1820 * The address of the LdapDefaultClient object. Must be non-NULL.
1821 * "pKeepGoing"
1822 * The address at which the Boolean state machine flag is stored to
1823 * indicate whether processing can continue without further input.
1824 * Must be non-NULL.
1825 * "plContext"
1826 * Platform-specific context pointer.
1827 * THREAD SAFETY:
1828 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1829 * RETURNS:
1830 * Returns NULL if the function succeeds.
1831 * Returns a LdapDefaultClient Error if the function fails in a
1832 * non-fatal way.
1833 * Returns a Fatal Error if the function fails in an unrecoverable way.
1834 */
1835static PKIX_Error *
1836pkix_pl_LdapDefaultClient_RecvInitial(
1837 PKIX_PL_LdapDefaultClient *client,
1838 PKIX_Boolean *pKeepGoing,
1839 void *plContext)
1840{
1841 unsigned char *msgBuf = NULL((void*)0);
1842 unsigned char *to = NULL((void*)0);
1843 unsigned char *from = NULL((void*)0);
1844 PKIX_UInt32 dataIndex = 0;
1845 PKIX_UInt32 messageIdLen = 0;
1846 PKIX_UInt32 messageLength = 0;
1847 PKIX_UInt32 sizeofLength = 0;
1848 PKIX_UInt32 bytesProcessed = 0;
1849 unsigned char messageChar = 0;
1850 LDAPMessageType messageType = 0;
1851 PKIX_Int32 bytesRead = 0;
1852 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1853
1854 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_RecvInitial")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RecvInitial"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1855 PKIX_NULLCHECK_TWO(client, pKeepGoing)do { if (((client) == ((void*)0)) || ((pKeepGoing) == ((void*
)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
1856
1857 /*
1858 * Is there an LDAPResponse in progress? I.e., have we
1859 * already processed the tag and length at the beginning of
1860 * the message?
1861 */
1862 if (client->currentResponse) {
1863 client->connectStatus = RECV_NONINITIAL;
1864 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1865 goto cleanup;
1866 }
1867 msgBuf = client->currentInPtr;
1868
1869 /* Do we have enough of the message to decode the message length? */
1870 if (client->currentBytesAvailable < MINIMUM_MSG_LENGTH5) {
1871 /*
1872 * No! Move these few bytes to the beginning of rcvBuf
1873 * and hang another read.
1874 */
1875
1876 to = (unsigned char *)client->rcvBuf;
1877 from = client->currentInPtr;
1878 for (dataIndex = 0;
1879 dataIndex < client->currentBytesAvailable;
1880 dataIndex++) {
1881 *to++ = *from++;
1882 }
1883 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
1884 PKIX_CHECK(callbackList->recvCallbackdo { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)to, client->capacity - client
->currentBytesAvailable, &bytesRead, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
1885 (client->clientSocket,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)to, client->capacity - client
->currentBytesAvailable, &bytesRead, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
1886 (void *)to,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)to, client->capacity - client
->currentBytesAvailable, &bytesRead, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
1887 client->capacity - client->currentBytesAvailable,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)to, client->capacity - client
->currentBytesAvailable, &bytesRead, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
1888 &bytesRead,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)to, client->capacity - client
->currentBytesAvailable, &bytesRead, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
1889 plContext),do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)to, client->capacity - client
->currentBytesAvailable, &bytesRead, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
1890 PKIX_SOCKETRECVFAILED)do { stdVars.aPkixErrorResult = (callbackList->recvCallback
(client->clientSocket, (void *)to, client->capacity - client
->currentBytesAvailable, &bytesRead, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0);
1891
1892 client->currentInPtr = client->rcvBuf;
1893 client->lastIO = PR_Now();
1894
1895 if (bytesRead <= 0) {
1896 client->connectStatus = RECV_PENDING;
1897 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1898 goto cleanup;
1899 } else {
1900 client->currentBytesAvailable += bytesRead;
1901 }
1902 }
1903
1904 /*
1905 * We have to determine whether the response is an entry, with
1906 * application-specific tag LDAP_SEARCHRESPONSEENTRY_TYPE, or a
1907 * resultCode, with application tag LDAP_SEARCHRESPONSERESULT_TYPE.
1908 * First, we have to figure out where to look for the tag.
1909 */
1910
1911 /* Is the message length short form (one octet) or long form? */
1912 if ((msgBuf[1] & 0x80) != 0) {
1913 sizeofLength = msgBuf[1] & 0x7F;
1914 for (dataIndex = 0; dataIndex < sizeofLength; dataIndex++) {
1915 messageLength =
1916 (messageLength << 8) + msgBuf[dataIndex + 2];
1917 }
1918 } else {
1919 messageLength = msgBuf[1];
1920 }
1921
1922 /* How many bytes did the messageID require? */
1923 messageIdLen = msgBuf[dataIndex + 3];
1924
1925 messageChar = msgBuf[dataIndex + messageIdLen + 4];
1926
1927 /* Are we looking at an Entry message or a ResultCode message? */
1928 if ((SEC_ASN1_CONSTRUCTED0x20 | SEC_ASN1_APPLICATION0x40 |
1929 LDAP_SEARCHRESPONSEENTRY_TYPE) == messageChar) {
1930
1931 messageType = LDAP_SEARCHRESPONSEENTRY_TYPE;
1932
1933 } else if ((SEC_ASN1_CONSTRUCTED0x20 | SEC_ASN1_APPLICATION0x40 |
1934 LDAP_SEARCHRESPONSERESULT_TYPE) == messageChar) {
1935
1936 messageType = LDAP_SEARCHRESPONSERESULT_TYPE;
1937
1938 } else {
1939
1940 PKIX_ERROR(PKIX_SEARCHRESPONSEPACKETOFUNKNOWNTYPE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_SEARCHRESPONSEPACKETOFUNKNOWNTYPE, ((void*)0), stdVars
.aPkixType, 2, plContext); } } stdVars.aPkixErrorReceived = (
(PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_SEARCHRESPONSEPACKETOFUNKNOWNTYPE
; goto cleanup; };
1941
1942 }
1943
1944 /*
1945 * messageLength is the length from (tag, length, value).
1946 * We have to allocate space for the tag and length bits too.
1947 */
1948 PKIX_CHECK(pkix_pl_LdapResponse_Createdo { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0)
1949 (messageType,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0)
1950 messageLength + dataIndex + 2,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0)
1951 client->currentBytesAvailable,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0)
1952 msgBuf,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0)
1953 &bytesProcessed,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0)
1954 &(client->currentResponse),do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0)
1955 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0)
1956 PKIX_LDAPRESPONSECREATEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Create (
messageType, messageLength + dataIndex + 2, client->currentBytesAvailable
, msgBuf, &bytesProcessed, &(client->currentResponse
), plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPRESPONSECREATEFAILED; goto cleanup; } } while (0);
1957
1958 client->currentBytesAvailable -= bytesProcessed;
1959
1960 PKIX_CHECK(pkix_pl_LdapDefaultClient_RecvCheckCompletedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvCheckComplete
(client, bytesProcessed, pKeepGoing, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
1961 (client, bytesProcessed, pKeepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvCheckComplete
(client, bytesProcessed, pKeepGoing, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
1962 PKIX_LDAPDEFAULTCLIENTRECVCHECKCOMPLETEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvCheckComplete
(client, bytesProcessed, pKeepGoing, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCHECKCOMPLETEFAILED
; goto cleanup; } } while (0);
1963
1964cleanup:
1965
1966 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1967}
1968
1969/*
1970 * FUNCTION: pkix_pl_LdapDefaultClient_RecvNonInitial
1971 * DESCRIPTION:
1972 *
1973 * This function processes the contents of buffers, after the first, of a
1974 * received LDAP-protocol message for the CertStore embodied in the
1975 * LdapDefaultClient "client", and stores in "pKeepGoing" a flag indicating
1976 * whether processing can continue without further input.
1977 *
1978 * PARAMETERS:
1979 * "client"
1980 * The address of the LdapDefaultClient object. Must be non-NULL.
1981 * "pKeepGoing"
1982 * The address at which the Boolean state machine flag is stored to
1983 * indicate whether processing can continue without further input.
1984 * Must be non-NULL.
1985 * "plContext"
1986 * Platform-specific context pointer.
1987 * THREAD SAFETY:
1988 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1989 * RETURNS:
1990 * Returns NULL if the function succeeds.
1991 * Returns a LdapDefaultClient Error if the function fails in a
1992 * non-fatal way.
1993 * Returns a Fatal Error if the function fails in an unrecoverable way.
1994 */
1995static PKIX_Error *
1996pkix_pl_LdapDefaultClient_RecvNonInitial(
1997 PKIX_PL_LdapDefaultClient *client,
1998 PKIX_Boolean *pKeepGoing,
1999 void *plContext)
2000{
2001
2002 PKIX_UInt32 bytesProcessed = 0;
2003
2004 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RecvNonInitial"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
2005 (LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_RecvNonInitial")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_RecvNonInitial"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
2006 PKIX_NULLCHECK_TWO(client, pKeepGoing)do { if (((client) == ((void*)0)) || ((pKeepGoing) == ((void*
)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
} } while (0);
2007
2008 PKIX_CHECK(pkix_pl_LdapResponse_Appenddo { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Append (
client->currentResponse, client->currentBytesAvailable,
client->currentInPtr, &bytesProcessed, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEAPPENDFAILED
; goto cleanup; } } while (0)
2009 (client->currentResponse,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Append (
client->currentResponse, client->currentBytesAvailable,
client->currentInPtr, &bytesProcessed, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEAPPENDFAILED
; goto cleanup; } } while (0)
2010 client->currentBytesAvailable,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Append (
client->currentResponse, client->currentBytesAvailable,
client->currentInPtr, &bytesProcessed, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEAPPENDFAILED
; goto cleanup; } } while (0)
2011 client->currentInPtr,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Append (
client->currentResponse, client->currentBytesAvailable,
client->currentInPtr, &bytesProcessed, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEAPPENDFAILED
; goto cleanup; } } while (0)
2012 &bytesProcessed,do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Append (
client->currentResponse, client->currentBytesAvailable,
client->currentInPtr, &bytesProcessed, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEAPPENDFAILED
; goto cleanup; } } while (0)
2013 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Append (
client->currentResponse, client->currentBytesAvailable,
client->currentInPtr, &bytesProcessed, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEAPPENDFAILED
; goto cleanup; } } while (0)
2014 PKIX_LDAPRESPONSEAPPENDFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapResponse_Append (
client->currentResponse, client->currentBytesAvailable,
client->currentInPtr, &bytesProcessed, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPRESPONSEAPPENDFAILED
; goto cleanup; } } while (0);
2015
2016 client->currentBytesAvailable -= bytesProcessed;
2017
2018 PKIX_CHECK(pkix_pl_LdapDefaultClient_RecvCheckCompletedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvCheckComplete
(client, bytesProcessed, pKeepGoing, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
2019 (client, bytesProcessed, pKeepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvCheckComplete
(client, bytesProcessed, pKeepGoing, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
2020 PKIX_LDAPDEFAULTCLIENTRECVCHECKCOMPLETEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvCheckComplete
(client, bytesProcessed, pKeepGoing, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCHECKCOMPLETEFAILED
; goto cleanup; } } while (0);
2021
2022cleanup:
2023
2024 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
2025}
2026
2027/*
2028 * FUNCTION: pkix_pl_LdapDefaultClient_Dispatch
2029 * DESCRIPTION:
2030 *
2031 * This function is the state machine dispatcher for the CertStore embodied in
2032 * the LdapDefaultClient pointed to by "client". Results are returned by
2033 * changes to various fields in the context.
2034 *
2035 * PARAMETERS:
2036 * "client"
2037 * The address of the LdapDefaultClient object. Must be non-NULL.
2038 * "plContext"
2039 * Platform-specific context pointer.
2040 * THREAD SAFETY:
2041 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
2042 * RETURNS:
2043 * Returns NULL if the function succeeds.
2044 * Returns a LdapDefaultClient Error if the function fails in a
2045 * non-fatal way.
2046 * Returns a Fatal Error if the function fails in an unrecoverable way.
2047 */
2048static PKIX_Error *
2049pkix_pl_LdapDefaultClient_Dispatch(
2050 PKIX_PL_LdapDefaultClient *client,
2051 void *plContext)
2052{
2053 PKIX_UInt32 bytesTransferred = 0;
2054 PKIX_Boolean keepGoing = PKIX_TRUE((PKIX_Boolean) 1);
2055
2056 PKIX_ENTER(LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_Dispatch")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_Dispatch"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
2057 PKIX_NULLCHECK_ONE(client)do { if ((client) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
2058
2059 while (keepGoing) {
2060 switch (client->connectStatus) {
2061 case CONNECT_PENDING:
2062 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_ConnectContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCONNECTCONTINUEFAILED
; goto cleanup; } } while (0)
2063 (pkix_pl_LdapDefaultClient_ConnectContinuedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_ConnectContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCONNECTCONTINUEFAILED
; goto cleanup; } } while (0)
2064 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_ConnectContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCONNECTCONTINUEFAILED
; goto cleanup; } } while (0)
2065 PKIX_LDAPDEFAULTCLIENTCONNECTCONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_ConnectContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTCONNECTCONTINUEFAILED
; goto cleanup; } } while (0);
2066 break;
2067 case CONNECTED:
2068 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Bind
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDFAILED; goto
cleanup; } } while (0)
2069 (pkix_pl_LdapDefaultClient_Binddo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Bind
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDFAILED; goto
cleanup; } } while (0)
2070 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Bind
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDFAILED; goto
cleanup; } } while (0)
2071 PKIX_LDAPDEFAULTCLIENTBINDFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Bind
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDFAILED; goto
cleanup; } } while (0);
2072 break;
2073 case BIND_PENDING:
2074 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDCONTINUEFAILED
; goto cleanup; } } while (0)
2075 (pkix_pl_LdapDefaultClient_BindContinuedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDCONTINUEFAILED
; goto cleanup; } } while (0)
2076 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDCONTINUEFAILED
; goto cleanup; } } while (0)
2077 PKIX_LDAPDEFAULTCLIENTBINDCONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDCONTINUEFAILED
; goto cleanup; } } while (0);
2078 break;
2079 case BIND_RESPONSE:
2080 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindResponse
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDRESPONSEFAILED
; goto cleanup; } } while (0)
2081 (pkix_pl_LdapDefaultClient_BindResponsedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindResponse
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDRESPONSEFAILED
; goto cleanup; } } while (0)
2082 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindResponse
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDRESPONSEFAILED
; goto cleanup; } } while (0)
2083 PKIX_LDAPDEFAULTCLIENTBINDRESPONSEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindResponse
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDRESPONSEFAILED
; goto cleanup; } } while (0);
2084 break;
2085 case BIND_RESPONSE_PENDING:
2086 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindResponseContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDRESPONSECONTINUEFAILED
; goto cleanup; } } while (0)
2087 (pkix_pl_LdapDefaultClient_BindResponseContinuedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindResponseContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDRESPONSECONTINUEFAILED
; goto cleanup; } } while (0)
2088 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindResponseContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDRESPONSECONTINUEFAILED
; goto cleanup; } } while (0)
2089 PKIX_LDAPDEFAULTCLIENTBINDRESPONSECONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_BindResponseContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTBINDRESPONSECONTINUEFAILED
; goto cleanup; } } while (0);
2090 break;
2091 case BOUND:
2092 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Send
(client, &keepGoing, &bytesTransferred, plContext));
if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTSENDFAILED
; goto cleanup; } } while (0)
2093 (pkix_pl_LdapDefaultClient_Senddo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Send
(client, &keepGoing, &bytesTransferred, plContext));
if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTSENDFAILED
; goto cleanup; } } while (0)
2094 (client, &keepGoing, &bytesTransferred, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Send
(client, &keepGoing, &bytesTransferred, plContext));
if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTSENDFAILED
; goto cleanup; } } while (0)
2095 PKIX_LDAPDEFAULTCLIENTSENDFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Send
(client, &keepGoing, &bytesTransferred, plContext));
if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTSENDFAILED
; goto cleanup; } } while (0);
2096 break;
2097 case SEND_PENDING:
2098 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_SendContinue
(client, &keepGoing, &bytesTransferred, plContext));
if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTSENDCONTINUEFAILED
; goto cleanup; } } while (0)
2099 (pkix_pl_LdapDefaultClient_SendContinuedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_SendContinue
(client, &keepGoing, &bytesTransferred, plContext));
if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTSENDCONTINUEFAILED
; goto cleanup; } } while (0)
2100 (client, &keepGoing, &bytesTransferred, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_SendContinue
(client, &keepGoing, &bytesTransferred, plContext));
if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTSENDCONTINUEFAILED
; goto cleanup; } } while (0)
2101 PKIX_LDAPDEFAULTCLIENTSENDCONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_SendContinue
(client, &keepGoing, &bytesTransferred, plContext));
if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTSENDCONTINUEFAILED
; goto cleanup; } } while (0);
2102 break;
2103 case RECV:
2104 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Recv
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVFAILED; goto
cleanup; } } while (0)
2105 (pkix_pl_LdapDefaultClient_Recvdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Recv
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVFAILED; goto
cleanup; } } while (0)
2106 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Recv
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVFAILED; goto
cleanup; } } while (0)
2107 PKIX_LDAPDEFAULTCLIENTRECVFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Recv
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVFAILED; goto
cleanup; } } while (0);
2108 break;
2109 case RECV_PENDING:
2110 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCONTINUEFAILED
; goto cleanup; } } while (0)
2111 (pkix_pl_LdapDefaultClient_RecvContinuedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCONTINUEFAILED
; goto cleanup; } } while (0)
2112 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCONTINUEFAILED
; goto cleanup; } } while (0)
2113 PKIX_LDAPDEFAULTCLIENTRECVCONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVCONTINUEFAILED
; goto cleanup; } } while (0);
2114 break;
2115 case RECV_INITIAL:
2116 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvInitial
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVINITIALFAILED
; goto cleanup; } } while (0)
2117 (pkix_pl_LdapDefaultClient_RecvInitialdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvInitial
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVINITIALFAILED
; goto cleanup; } } while (0)
2118 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvInitial
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVINITIALFAILED
; goto cleanup; } } while (0)
2119 PKIX_LDAPDEFAULTCLIENTRECVINITIALFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvInitial
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVINITIALFAILED
; goto cleanup; } } while (0);
2120 break;
2121 case RECV_NONINITIAL:
2122 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvNonInitial
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVNONINITIALFAILED
; goto cleanup; } } while (0)
2123 (pkix_pl_LdapDefaultClient_RecvNonInitialdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvNonInitial
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVNONINITIALFAILED
; goto cleanup; } } while (0)
2124 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvNonInitial
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVNONINITIALFAILED
; goto cleanup; } } while (0)
2125 PKIX_LDAPDEFAULTCLIENTRECVNONINITIALFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_RecvNonInitial
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTRECVNONINITIALFAILED
; goto cleanup; } } while (0);
2126 break;
2127 case ABANDON_PENDING:
2128 PKIX_CHECKdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_AbandonContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTABANDONCONTINUEFAILED
; goto cleanup; } } while (0)
2129 (pkix_pl_LdapDefaultClient_AbandonContinuedo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_AbandonContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTABANDONCONTINUEFAILED
; goto cleanup; } } while (0)
2130 (client, &keepGoing, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_AbandonContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTABANDONCONTINUEFAILED
; goto cleanup; } } while (0)
2131 PKIX_LDAPDEFAULTCLIENTABANDONCONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_AbandonContinue
(client, &keepGoing, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTABANDONCONTINUEFAILED
; goto cleanup; } } while (0);
2132 break;
2133 default:
2134 PKIX_ERROR(PKIX_LDAPCERTSTOREINILLEGALSTATE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_LDAPCERTSTOREINILLEGALSTATE, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_LDAPCERTSTOREINILLEGALSTATE
; goto cleanup; };
2135 }
2136 }
2137
2138cleanup:
2139
2140 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
2141}
2142
2143/*
2144 * FUNCTION: pkix_pl_LdapDefaultClient_MakeAndFilter
2145 * DESCRIPTION:
2146 *
2147 * This function allocates space from the arena pointed to by "arena" to
2148 * construct a filter that will match components of the X500Name pointed to by
2149 * XXX...
2150 *
2151 * PARAMETERS:
2152 * "arena"
2153 * The address of the PLArenaPool used in creating the filter. Must be
2154 * non-NULL.
2155 * "nameComponent"
2156 * The address of a NULL-terminated list of LDAPNameComponents
2157 * Must be non-NULL.
2158 * "pFilter"
2159 * The address at which the result is stored.
2160 * "plContext"
2161 * Platform-specific context pointer
2162 * THREAD SAFETY:
2163 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
2164 * RETURNS:
2165 * Returns NULL if the function succeeds.
2166 * Returns a CertStore Error if the function fails in a non-fatal way.
2167 * Returns a Fatal Error if the function fails in an unrecoverable way.
2168 */
2169static PKIX_Error *
2170pkix_pl_LdapDefaultClient_MakeAndFilter(
2171 PLArenaPool *arena,
2172 LDAPNameComponent **nameComponents,
2173 LDAPFilter **pFilter,
2174 void *plContext)
2175{
2176 LDAPFilter **setOfFilter;
2177 LDAPFilter *andFilter = NULL((void*)0);
2178 LDAPFilter *currentFilter = NULL((void*)0);
2179 PKIX_UInt32 componentsPresent = 0;
2180 void *v = NULL((void*)0);
2181 unsigned char *component = NULL((void*)0);
2182 LDAPNameComponent **componentP = NULL((void*)0);
2183
2184 PKIX_ENTER(CERTSTORE, "pkix_pl_LdapDefaultClient_MakeAndFilter")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_MakeAndFilter"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_CERTSTORE_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
2185 PKIX_NULLCHECK_THREE(arena, nameComponents, pFilter)do { if (((arena) == ((void*)0)) || ((nameComponents) == ((void
*)0)) || ((pFilter) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
2186
2187 /* count how many components we were provided */
2188 for (componentP = nameComponents, componentsPresent = 0;
2189 *(componentP++) != NULL((void*)0);
2190 componentsPresent++) {}
2191
2192 /* Space for (componentsPresent + 1) pointers to LDAPFilter */
2193 PKIX_PL_NSSCALLRV(CERTSTORE, v, PORT_ArenaZAlloc,; v = (PORT_ArenaZAlloc_Util (arena, (componentsPresent + 1)*
sizeof(LDAPFilter *)))
2194 (arena, (componentsPresent + 1)*sizeof(LDAPFilter *))); v = (PORT_ArenaZAlloc_Util (arena, (componentsPresent + 1)*
sizeof(LDAPFilter *)));
2195 setOfFilter = (LDAPFilter **)v;
2196
2197 /* Space for AndFilter and <componentsPresent> EqualFilters */
2198 PKIX_PL_NSSCALLRV(CERTSTORE, v, PORT_ArenaZNewArray,; v = ((LDAPFilter *)PORT_ArenaZAlloc_Util(arena, sizeof(LDAPFilter
) * (componentsPresent + 1)))
2199 (arena, LDAPFilter, componentsPresent + 1)); v = ((LDAPFilter *)PORT_ArenaZAlloc_Util(arena, sizeof(LDAPFilter
) * (componentsPresent + 1)));
2200 setOfFilter[0] = (LDAPFilter *)v;
2201
2202 /* Claim the first array element for the ANDFilter */
2203 andFilter = setOfFilter[0];
2204
2205 /* Set ANDFilter to point to the first EqualFilter pointer */
2206 andFilter->selector = LDAP_ANDFILTER_TYPE;
2207 andFilter->filter.andFilter.filters = setOfFilter;
2208
2209 currentFilter = andFilter + 1;
2210
2211 for (componentP = nameComponents, componentsPresent = 0;
2212 *(componentP) != NULL((void*)0); componentP++) {
2213 setOfFilter[componentsPresent++] = currentFilter;
2214 currentFilter->selector = LDAP_EQUALFILTER_TYPE;
2215 component = (*componentP)->attrType;
2216 currentFilter->filter.equalFilter.attrType.data = component;
2217 currentFilter->filter.equalFilter.attrType.len =
2218 PL_strlen((const char *)component);
2219 component = (*componentP)->attrValue;
2220 currentFilter->filter.equalFilter.attrValue.data = component;
2221 currentFilter->filter.equalFilter.attrValue.len =
2222 PL_strlen((const char *)component);
2223 currentFilter++;
2224 }
2225
2226 setOfFilter[componentsPresent] = NULL((void*)0);
2227
2228 *pFilter = andFilter;
2229
2230 PKIX_RETURN(CERTSTORE)return PKIX_DoReturn(&stdVars, (PKIX_CERTSTORE_ERROR), ((
PKIX_Boolean) 1), plContext);;
2231
2232}
2233
2234/*
2235 * FUNCTION: pkix_pl_LdapDefaultClient_InitiateRequest
2236 * DESCRIPTION:
2237 *
2238 *
2239 * PARAMETERS:
2240 * "client"
2241 * The address of the LdapDefaultClient object. Must be non-NULL.
2242 * "requestParams"
2243 * The address of an LdapClientParams object. Must be non-NULL.
2244 * "pPollDesc"
2245 * The location where the address of the PRPollDesc is stored, if the
2246 * client returns with I/O pending.
2247 * "pResponse"
2248 * The address where the List of LDAPResponses, or NULL for an
2249 * unfinished request, is stored. Must be non-NULL.
2250 * "plContext"
2251 * Platform-specific context pointer.
2252 * THREAD SAFETY:
2253 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
2254 * RETURNS:
2255 * Returns NULL if the function succeeds.
2256 * Returns a LdapDefaultClient Error if the function fails in a
2257 * non-fatal way.
2258 * Returns a Fatal Error if the function fails in an unrecoverable way.
2259 */
2260static PKIX_Error *
2261pkix_pl_LdapDefaultClient_InitiateRequest(
2262 PKIX_PL_LdapClient *genericClient,
2263 LDAPRequestParams *requestParams,
2264 void **pPollDesc,
2265 PKIX_List **pResponse,
2266 void *plContext)
2267{
2268 PKIX_List *searchResponseList = NULL((void*)0);
2269 SECItem *encoded = NULL((void*)0);
2270 LDAPFilter *filter = NULL((void*)0);
2271 PKIX_PL_LdapDefaultClient *client = 0;
2272
2273 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_InitiateRequest"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
2274 (LDAPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_InitiateRequest"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
2275 "pkix_pl_LdapDefaultClient_InitiateRequest")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_InitiateRequest"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
2276 PKIX_NULLCHECK_FOUR(genericClient, requestParams, pPollDesc, pResponse)do { if (((genericClient) == ((void*)0)) || ((requestParams) ==
((void*)0)) || ((pPollDesc) == ((void*)0)) || ((pResponse) ==
((void*)0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1
); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn
(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext
);; } } while (0);
2277
2278 PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
2279 ((PKIX_PL_Object *)genericClient,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
2280 PKIX_LDAPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
2281 plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
2282 PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0);
2283
2284 client = (PKIX_PL_LdapDefaultClient *)genericClient;
2285
2286 PKIX_CHECK(pkix_pl_LdapDefaultClient_MakeAndFilterdo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAndFilter
(client->arena, requestParams->nc, &filter, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEANDFILTERFAILED; goto cleanup; }
} while (0)
2287 (client->arena, requestParams->nc, &filter, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAndFilter
(client->arena, requestParams->nc, &filter, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEANDFILTERFAILED; goto cleanup; }
} while (0)
2288 PKIX_LDAPDEFAULTCLIENTMAKEANDFILTERFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAndFilter
(client->arena, requestParams->nc, &filter, plContext
)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass =
stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEANDFILTERFAILED; goto cleanup; }
} while (0);
2289
2290 PKIX_CHECK(pkix_pl_LdapRequest_Createdo { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2291 (client->arena,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2292 client->messageID++,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2293 requestParams->baseObject,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2294 requestParams->scope,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2295 requestParams->derefAliases,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2296 requestParams->sizeLimit,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2297 requestParams->timeLimit,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2298 PKIX_FALSE, /* attrs only */do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2299 filter,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2300 requestParams->attributes,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2301 &client->currentRequest,do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2302 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0)
2303 PKIX_LDAPREQUESTCREATEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_Create (
client->arena, client->messageID++, requestParams->baseObject
, requestParams->scope, requestParams->derefAliases, requestParams
->sizeLimit, requestParams->timeLimit, ((PKIX_Boolean) 0
), filter, requestParams->attributes, &client->currentRequest
, plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPREQUESTCREATEFAILED; goto cleanup; } } while (0);
2304
2305 /* check hashtable for matching request */
2306 PKIX_CHECK(PKIX_PL_HashTable_Lookupdo { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Lookup (client
->cachePtr, (PKIX_PL_Object *)(client->currentRequest),
(PKIX_PL_Object **)&searchResponseList, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLELOOKUPFAILED
; goto cleanup; } } while (0)
2307 (client->cachePtr,do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Lookup (client
->cachePtr, (PKIX_PL_Object *)(client->currentRequest),
(PKIX_PL_Object **)&searchResponseList, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLELOOKUPFAILED
; goto cleanup; } } while (0)
2308 (PKIX_PL_Object *)(client->currentRequest),do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Lookup (client
->cachePtr, (PKIX_PL_Object *)(client->currentRequest),
(PKIX_PL_Object **)&searchResponseList, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLELOOKUPFAILED
; goto cleanup; } } while (0)
2309 (PKIX_PL_Object **)&searchResponseList,do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Lookup (client
->cachePtr, (PKIX_PL_Object *)(client->currentRequest),
(PKIX_PL_Object **)&searchResponseList, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLELOOKUPFAILED
; goto cleanup; } } while (0)
2310 plContext),do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Lookup (client
->cachePtr, (PKIX_PL_Object *)(client->currentRequest),
(PKIX_PL_Object **)&searchResponseList, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLELOOKUPFAILED
; goto cleanup; } } while (0)
2311 PKIX_HASHTABLELOOKUPFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_HashTable_Lookup (client
->cachePtr, (PKIX_PL_Object *)(client->currentRequest),
(PKIX_PL_Object **)&searchResponseList, plContext)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HASHTABLELOOKUPFAILED
; goto cleanup; } } while (0);
2312
2313 if (searchResponseList != NULL((void*)0)) {
2314 *pPollDesc = NULL((void*)0);
2315 *pResponse = searchResponseList;
2316 PKIX_DECREF(client->currentRequest)do { if (client->currentRequest){ stdVars.aPkixTempResult =
PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentRequest
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentRequest = ((void*)0); } } while
(0);
2317 goto cleanup;
2318 }
2319
2320 /* It wasn't cached. We'll have to actually send it. */
2321
2322 PKIX_CHECK(pkix_pl_LdapRequest_GetEncodeddo { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_GetEncoded
(client->currentRequest, &encoded, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPREQUESTGETENCODEDFAILED
; goto cleanup; } } while (0)
2323 (client->currentRequest, &encoded, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_GetEncoded
(client->currentRequest, &encoded, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPREQUESTGETENCODEDFAILED
; goto cleanup; } } while (0)
2324 PKIX_LDAPREQUESTGETENCODEDFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapRequest_GetEncoded
(client->currentRequest, &encoded, plContext)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_LDAPREQUESTGETENCODEDFAILED
; goto cleanup; } } while (0);
2325
2326 client->sendBuf = encoded->data;
2327 client->bytesToWrite = encoded->len;
2328
2329 PKIX_CHECK(pkix_pl_LdapDefaultClient_Dispatch(client, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Dispatch
(client, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTDISPATCHFAILED; goto cleanup
; } } while (0)
2330 PKIX_LDAPDEFAULTCLIENTDISPATCHFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Dispatch
(client, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTDISPATCHFAILED; goto cleanup
; } } while (0);
2331
2332 /*
2333 * It's not enough that we may be done with a particular read.
2334 * We're still processing the transaction until we've gotten the
2335 * SearchResponseResult message and returned to the BOUND state.
2336 * Otherwise we must still have a read pending, and must hold off
2337 * on returning results.
2338 */
2339 if ((client->connectStatus == BOUND) &&
2340 (client->entriesFound != NULL((void*)0))) {
2341 *pPollDesc = NULL((void*)0);
2342 *pResponse = client->entriesFound;
2343 client->entriesFound = NULL((void*)0);
2344 PKIX_DECREF(client->currentRequest)do { if (client->currentRequest){ stdVars.aPkixTempResult =
PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentRequest
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentRequest = ((void*)0); } } while
(0);
2345 } else {
2346 *pPollDesc = &client->pollDesc;
2347 *pResponse = NULL((void*)0);
2348 }
2349
2350cleanup:
2351
2352 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
2353
2354}
2355
2356/*
2357 * FUNCTION: pkix_pl_LdapDefaultClient_ResumeRequest
2358 * DESCRIPTION:
2359 *
2360 *
2361 * PARAMETERS:
2362 * "client"
2363 * The address of the LdapDefaultClient object. Must be non-NULL.
2364 * "pPollDesc"
2365 * The location where the address of the PRPollDesc is stored, if the
2366 * client returns with I/O pending.
2367 * "pResponse"
2368 * The address where the List of LDAPResponses, or NULL for an
2369 * unfinished request, is stored. Must be non-NULL.
2370 * "plContext"
2371 * Platform-specific context pointer.
2372 * THREAD SAFETY:
2373 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
2374 * RETURNS:
2375 * Returns NULL if the function succeeds.
2376 * Returns a LdapDefaultClient Error if the function fails in a
2377 * non-fatal way.
2378 * Returns a Fatal Error if the function fails in an unrecoverable way.
2379 */
2380static PKIX_Error *
2381pkix_pl_LdapDefaultClient_ResumeRequest(
2382 PKIX_PL_LdapClient *genericClient,
2383 void **pPollDesc,
2384 PKIX_List **pResponse,
2385 void *plContext)
2386{
2387 PKIX_PL_LdapDefaultClient *client = 0;
2388
2389 PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_ResumeRequest"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
2390 (LDAPDEFAULTCLIENT, "pkix_pl_LdapDefaultClient_ResumeRequest")static const char cMyFuncName[] = {"pkix_pl_LdapDefaultClient_ResumeRequest"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_LDAPDEFAULTCLIENT_ERROR; ; do { if
(pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
2391 PKIX_NULLCHECK_THREE(genericClient, pPollDesc, pResponse)do { if (((genericClient) == ((void*)0)) || ((pPollDesc) == (
(void*)0)) || ((pResponse) == ((void*)0))){ stdVars.aPkixErrorReceived
= ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
2392
2393 PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
2394 ((PKIX_PL_Object *)genericClient,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
2395 PKIX_LDAPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
2396 plContext),do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0)
2397 PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
*)genericClient, PKIX_LDAPDEFAULTCLIENT_TYPE, plContext)); if
(stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_GENERICCLIENTNOTANLDAPDEFAULTCLIENT
; goto cleanup; } } while (0);
2398
2399 client = (PKIX_PL_LdapDefaultClient *)genericClient;
2400
2401 PKIX_CHECK(pkix_pl_LdapDefaultClient_Dispatch(client, plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Dispatch
(client, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTDISPATCHFAILED; goto cleanup
; } } while (0)
2402 PKIX_LDAPDEFAULTCLIENTDISPATCHFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_Dispatch
(client, plContext)); if (stdVars.aPkixErrorResult) { stdVars
.aPkixErrorClass = stdVars.aPkixErrorResult->errClass; stdVars
.aPkixErrorCode = PKIX_LDAPDEFAULTCLIENTDISPATCHFAILED; goto cleanup
; } } while (0);
2403
2404 /*
2405 * It's not enough that we may be done with a particular read.
2406 * We're still processing the transaction until we've gotten the
2407 * SearchResponseResult message and returned to the BOUND state.
2408 * Otherwise we must still have a read pending, and must hold off
2409 * on returning results.
2410 */
2411 if ((client->connectStatus == BOUND) &&
2412 (client->entriesFound != NULL((void*)0))) {
2413 *pPollDesc = NULL((void*)0);
2414 *pResponse = client->entriesFound;
2415 client->entriesFound = NULL((void*)0);
2416 PKIX_DECREF(client->currentRequest)do { if (client->currentRequest){ stdVars.aPkixTempResult =
PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentRequest
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentRequest = ((void*)0); } } while
(0);
2417 } else {
2418 *pPollDesc = &client->pollDesc;
2419 *pResponse = NULL((void*)0);
2420 }
2421
2422cleanup:
2423
2424 PKIX_RETURN(LDAPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_LDAPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
2425
2426}
2427
2428/* --Public-LdapDefaultClient-Functions----------------------------------- */
2429
2430/*
2431 * FUNCTION: PKIX_PL_LdapDefaultClient_AbandonRequest
2432 * DESCRIPTION:
2433 *
2434 * This function creates and sends an LDAP-protocol "Abandon" message to the
2435 * server connected to the LdapDefaultClient pointed to by "client".
2436 *
2437 * PARAMETERS:
2438 * "client"
2439 * The LdapDefaultClient whose connection is to be abandoned. Must be
2440 * non-NULL.
2441 * "plContext"
2442 * Platform-specific context pointer.
2443 * THREAD SAFETY:
2444 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
2445 * RETURNS:
2446 * Returns NULL if the function succeeds.
2447 * Returns a Fatal Error if the function fails in an unrecoverable way.
2448 */
2449PKIX_Error *
2450PKIX_PL_LdapDefaultClient_AbandonRequest(
2451 PKIX_PL_LdapDefaultClient *client,
2452 void *plContext)
2453{
2454 PKIX_Int32 bytesWritten = 0;
2455 PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
2456 SECItem *encoded = NULL((void*)0);
1
'encoded' initialized to a null pointer value
→
2457
2458 PKIX_ENTER(CERTSTORE, "PKIX_PL_LdapDefaultClient_AbandonRequest")static const char cMyFuncName[] = {"PKIX_PL_LdapDefaultClient_AbandonRequest"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_CERTSTORE_ERROR; ; do { if (pkixLoggersDebugTrace
) { pkix_Logger_Check(pkixLoggersDebugTrace, stdVars.aMyFuncName
, ">>>", stdVars.aPkixType, 5, plContext); } } while
(0);;
2
←
Assuming 'pkixLoggersDebugTrace' is null
→
3
←
Taking false branch
→
4
←
Loop condition is false. Exiting loop
→
2459 PKIX_NULLCHECK_ONE(client)do { if ((client) == ((void*)0)){ stdVars.aPkixErrorReceived =
((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
5
←
Assuming 'client' is not equal to null
→
6
←
Taking false branch
→
7
←
Loop condition is false. Exiting loop
→
2460
2461 if (client->connectStatus == RECV_PENDING) {
8
←
Assuming field 'connectStatus' is equal to RECV_PENDING
→
9
←
Taking true branch
→
2462 PKIX_CHECK(pkix_pl_LdapDefaultClient_MakeAbandondo { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAbandon
(client->arena, (client->messageID) - 1, &encoded,
plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEABANDONFAILED; goto cleanup; } }
while (0)
10
←
Calling 'pkix_pl_LdapDefaultClient_MakeAbandon'
→
16
←
Returning from 'pkix_pl_LdapDefaultClient_MakeAbandon'
→
17
←
Assuming field 'aPkixErrorResult' is null
→
18
←
Taking false branch
→
19
←
Loop condition is false. Exiting loop
→
2463 (client->arena,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAbandon
(client->arena, (client->messageID) - 1, &encoded,
plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEABANDONFAILED; goto cleanup; } }
while (0)
2464 (client->messageID) - 1,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAbandon
(client->arena, (client->messageID) - 1, &encoded,
plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEABANDONFAILED; goto cleanup; } }
while (0)
2465 &encoded,do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAbandon
(client->arena, (client->messageID) - 1, &encoded,
plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEABANDONFAILED; goto cleanup; } }
while (0)
2466 plContext),do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAbandon
(client->arena, (client->messageID) - 1, &encoded,
plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEABANDONFAILED; goto cleanup; } }
while (0)
2467 PKIX_LDAPDEFAULTCLIENTMAKEABANDONFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_LdapDefaultClient_MakeAbandon
(client->arena, (client->messageID) - 1, &encoded,
plContext)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
= stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
= PKIX_LDAPDEFAULTCLIENTMAKEABANDONFAILED; goto cleanup; } }
while (0);
2468
2469 callbackList = (PKIX_PL_Socket_Callback *)(client->callbackList);
2470 PKIX_CHECK(callbackList->sendCallbackdo { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
20
←
Access to field 'data' results in a dereference of a null pointer (loaded from variable 'encoded')
2471 (client->clientSocket,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
2472 encoded->data,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
2473 encoded->len,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
2474 &bytesWritten,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
2475 plContext),do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0)
2476 PKIX_SOCKETSENDFAILED)do { stdVars.aPkixErrorResult = (callbackList->sendCallback
(client->clientSocket, encoded->data, encoded->len,
&bytesWritten, plContext)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETSENDFAILED; goto cleanup
; } } while (0);
2477
2478 if (bytesWritten < 0) {
2479 client->connectStatus = ABANDON_PENDING;
2480 } else {
2481 client->connectStatus = BOUND;
2482 }
2483 }
2484
2485 PKIX_DECREF(client->entriesFound)do { if (client->entriesFound){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(client->entriesFound), plContext); if
(stdVars.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars
.aPkixTempResult, plContext); stdVars.aPkixTempResult = ((void
*)0); } client->entriesFound = ((void*)0); } } while (0);
2486 PKIX_DECREF(client->currentRequest)do { if (client->currentRequest){ stdVars.aPkixTempResult =
PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentRequest
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentRequest = ((void*)0); } } while
(0);
2487 PKIX_DECREF(client->currentResponse)do { if (client->currentResponse){ stdVars.aPkixTempResult
= PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(client->currentResponse
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
= ((void*)0); } client->currentResponse = ((void*)0); } }
while (0);
2488
2489cleanup:
2490
2491 PKIX_DECREF(client)do { if (client){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)(client), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); } client = ((void*)0
); } } while (0);
2492
2493 PKIX_RETURN(CERTSTORE)return PKIX_DoReturn(&stdVars, (PKIX_CERTSTORE_ERROR), ((
PKIX_Boolean) 1), plContext);;
2494}