pkix_pl_httpdefaultclient.c

Bug Summary

File:	s/lib/libpkix/pkix_pl_nss/module/pkix_pl_httpdefaultclient.c
Warning:	line 1445, column 57 Dereference of null pointer (loaded from variable 'http_response_data_len')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
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_httpdefaultclient.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_httpdefaultclient.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_httpdefaultclient.c
6 *
7 * HTTPDefaultClient Function Definitions
8 *
9 */
10 
11#include "pkix_pl_httpdefaultclient.h"
12 
13static void *plContext = NULL((void*)0);
14 
15/*
16 * The interface specification for an http client requires that it register
17 * a function table of type SEC_HttpClientFcn, which is defined as a union
18 * of tables, of which only version 1 is defined at present.
19 *
20 * Note: these functions violate the PKIX calling conventions, in that they
21 * return SECStatus rather than PKIX_Error*, and that they do not provide a
22 * plContext argument. They are implemented here as calls to PKIX functions,
23 * but the plContext value is circularly defined - a true kludge. Its value
24 * is saved at the time of the call to pkix_pl_HttpDefaultClient_Create for
25 * subsequent use, but since that initial call comes from the
26 * pkix_pl_HttpDefaultClient_CreateSessionFcn, it's not really getting saved.
27 */
28static SEC_HttpClientFcnV1 vtable = {
29        pkix_pl_HttpDefaultClient_CreateSessionFcn,
30        pkix_pl_HttpDefaultClient_KeepAliveSessionFcn,
31        pkix_pl_HttpDefaultClient_FreeSessionFcn,
32        pkix_pl_HttpDefaultClient_RequestCreateFcn,
33        pkix_pl_HttpDefaultClient_SetPostDataFcn,
34        pkix_pl_HttpDefaultClient_AddHeaderFcn,
35        pkix_pl_HttpDefaultClient_TrySendAndReceiveFcn,
36        pkix_pl_HttpDefaultClient_CancelFcn,
37        pkix_pl_HttpDefaultClient_FreeFcn
38};
39 
40static SEC_HttpClientFcn httpClient;
41 
42static const char *eohMarker = "\r\n\r\n";
43static const PKIX_UInt32 eohMarkLen = 4; /* strlen(eohMarker) */
44static const char *crlf = "\r\n";
45static const PKIX_UInt32 crlfLen = 2; /* strlen(crlf) */
46static const char *httpprotocol = "HTTP/";
47static const PKIX_UInt32 httpprotocolLen = 5; /* strlen(httpprotocol) */
48 
49 
50#define HTTP_UNKNOWN_CONTENT_LENGTH-1 -1
51 
52/* --Private-HttpDefaultClient-Functions------------------------- */
53 
54/*
55 * FUNCTION: pkix_pl_HttpDefaultClient_HdrCheckComplete
56 * DESCRIPTION:
57 *
58 *  This function determines whether the headers in the current receive buffer
59 *  in the HttpDefaultClient pointed to by "client" are complete. If so, the
60 *  input data is checked for status code, content-type and content-length are
61 *  extracted, and the client is set up to read the body of the response.
62 *  Otherwise, the client is set up to continue reading header data.
63 *
64 * PARAMETERS:
65 *  "client"
66 *      The address of the HttpDefaultClient object. Must be non-NULL.
67 *  "bytesRead"
68 *      The UInt32 number of bytes received in the latest read.
69 *  "pKeepGoing"
70 *      The address at which the Boolean state machine flag is stored to
71 *      indicate whether processing can continue without further input.
72 *      Must be non-NULL.
73 *  "plCtx"
74 *      Platform-specific context pointer.
75 * THREAD SAFETY:
76 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
77 * RETURNS:
78 *  Returns NULL if the function succeeds.
79 *  Returns a HttpDefaultClient Error if the function fails in a
80 *      non-fatal way.
81 *  Returns a Fatal Error if the function fails in an unrecoverable way.
82 */
83static PKIX_Error *
84pkix_pl_HttpDefaultClient_HdrCheckComplete(
85        PKIX_PL_HttpDefaultClient *client,
86        PKIX_UInt32 bytesRead,
87        PKIX_Boolean *pKeepGoing,
88        void *plCtx)
89{
90        PKIX_UInt32 alreadyScanned = 0;
91        PKIX_UInt32 comp = 0;
92        PKIX_UInt32 headerLength = 0;
93        PKIX_Int32 contentLength = HTTP_UNKNOWN_CONTENT_LENGTH-1;
94        char *eoh = NULL((void*)0);
95        char *statusLineEnd = NULL((void*)0);
96        char *space = NULL((void*)0);
97        char *nextHeader = NULL((void*)0);
98        const char *httpcode = NULL((void*)0);
99        char *thisHeaderEnd = NULL((void*)0);
100        char *value = NULL((void*)0);
101        char *colon = NULL((void*)0);
102	char *copy = NULL((void*)0);
103        char *body = NULL((void*)0);
104 
105        PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_HdrCheckComplete"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
106                (HTTPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_HdrCheckComplete"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
107                "pkix_pl_HttpDefaultClient_HdrCheckComplete")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_HdrCheckComplete"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
108        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);
109 
110        *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
111 
112        /* Does buffer contain end-of-header marker? */
113 
114        /* Copy number of scanned bytes into a variable. */
115        alreadyScanned = client->filledupBytes;
116        /*
117         * If this is the initial buffer, we have to scan from the beginning.
118         * If we scanned, failed to find eohMarker, and read some more, we
119         * only have to scan from where we left off.
120         */
121        if (alreadyScanned > eohMarkLen) {
122            /* Back up and restart scanning over a few bytes that were
123             * scanned before */
124            PKIX_UInt32 searchStartPos = alreadyScanned - eohMarkLen;
125            eoh = PL_strnstr(&(client->rcvBuf[searchStartPos]), eohMarker,
126                             bytesRead + searchStartPos);
127        } else {
128            /* A search from the beginning of the buffer. */
129            eoh = PL_strnstr(client->rcvBuf, eohMarker, bytesRead);
130        }
131 
132        client->filledupBytes += bytesRead;
133 
134        if (eoh == NULL((void*)0)) { /* did we see end-of-header? */
135                /* No. Continue to read header data */
136                client->connectStatus = HTTP_RECV_HDR;
137                *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
138                goto cleanup;
139        }
140 
141        /* Yes. Calculate how many bytes in header (not counting eohMarker) */
142        headerLength = (eoh - client->rcvBuf);
143 
144        /* allocate space to copy header (and for the NULL terminator) */
145        PKIX_CHECK(PKIX_PL_Malloc(headerLength + 1, (void **)&copy, plCtx),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc(headerLength +
 1, (void **)&copy, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0)
146                PKIX_MALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc(headerLength +
 1, (void **)&copy, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0);
147 
148        /* copy header data before we corrupt it (by storing NULLs) */
149        PORT_Memcpymemcpy(copy, client->rcvBuf, headerLength);
150	/* Store the NULL terminator */
151	copy[headerLength] = '\0';
152	client->rcvHeaders = copy;
153 
154        /* Did caller want a pointer to header? */
155        if (client->rcv_http_headers != NULL((void*)0)) {
156                /* store pointer for caller */
157                *(client->rcv_http_headers) = copy;
158        }
159 
160        /* Check that message status is okay. */
161        statusLineEnd = PL_strnstr(client->rcvBuf, crlf, client->capacity);
162        if (statusLineEnd == NULL((void*)0)) {
163                client->connectStatus = HTTP_ERROR;
164                PORT_SetErrorPORT_SetError_Util(SEC_ERROR_OCSP_BAD_HTTP_RESPONSE);
165                goto cleanup;
166        }
167 
168        *statusLineEnd = '\0';
169 
170        space = strchr((const char *)client->rcvBuf, ' ');
171        if (space == NULL((void*)0)) {
172                client->connectStatus = HTTP_ERROR;
173                goto cleanup;
174        }
175 
176        comp = PORT_StrncasecmpPL_strncasecmp((const char *)client->rcvBuf, httpprotocol,
177                                httpprotocolLen);
178        if (comp != 0) {
179                client->connectStatus = HTTP_ERROR;
180                goto cleanup;
181        }
182 
183        httpcode = space + 1;
184        space = strchr(httpcode, ' ');
185        if (space == NULL((void*)0)) {
186                client->connectStatus = HTTP_ERROR;
187                goto cleanup;
188        }
189        *space = '\0';
190 
191        client->responseCode = atoi(httpcode);
192        if (client->responseCode != 200) {
193                client->connectStatus = HTTP_ERROR;
194                goto cleanup;
195        }
196 
197        /* Find the content-type and content-length */
198        nextHeader = statusLineEnd + crlfLen;
199        *eoh = '\0';
200        do {
201                thisHeaderEnd = NULL((void*)0);
202                value = NULL((void*)0);
203 
204                colon = strchr(nextHeader, ':');
205                if (colon == NULL((void*)0)) {
206                        client->connectStatus = HTTP_ERROR;
207                        goto cleanup;
208                }
209                *colon = '\0';
210                value = colon + 1;
211                if (*value != ' ') {
212                        client->connectStatus = HTTP_ERROR;
213                        goto cleanup;
214                }
215                value++;
216                thisHeaderEnd = strstr(value, crlf);
217                if (thisHeaderEnd != NULL((void*)0)) {
218                        *thisHeaderEnd = '\0';
219                }
220                comp = PORT_StrcasecmpPL_strcasecmp(nextHeader, "content-type");
221                if (comp == 0) {
222                        client->rcvContentType = PORT_StrdupPORT_Strdup_Util(value);
223                } else {
224                        comp = PORT_StrcasecmpPL_strcasecmp(nextHeader, "content-length");
225                        if (comp == 0) {
226                                contentLength = atoi(value);
227                        }
228                }
229                if (thisHeaderEnd != NULL((void*)0)) {
230                        nextHeader = thisHeaderEnd + crlfLen;
231                } else {
232                        nextHeader = NULL((void*)0);
233                }
234        } while ((nextHeader != NULL((void*)0)) && (nextHeader < (eoh + crlfLen)));
235                
236        /* Did caller provide a pointer to return content-type? */
237        if (client->rcv_http_content_type != NULL((void*)0)) {
238                *(client->rcv_http_content_type) = client->rcvContentType;
239        }
240 
241        if (client->rcvContentType == NULL((void*)0)) {
242                client->connectStatus = HTTP_ERROR;
243                goto cleanup;
244        }
245 
246         /* How many bytes remain in current buffer, beyond the header? */
247         headerLength += eohMarkLen;
248         client->filledupBytes -= headerLength;
249 
250         /*
251          * The headers have passed validation. Now figure out whether the
252          * message is within the caller's size limit (if one was specified).
253          */
254         switch (contentLength) {
255         case 0:
256             client->rcv_http_data_len = 0;
257             client->connectStatus = HTTP_COMPLETE;
258             *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
259             break;
260 
261         case HTTP_UNKNOWN_CONTENT_LENGTH-1:
262             /* Unknown contentLength indicator.Will be set by
263              * pkix_pl_HttpDefaultClient_RecvBody whey connection get closed */
264             client->rcv_http_data_len = HTTP_UNKNOWN_CONTENT_LENGTH-1;
265             contentLength =                 /* Try to reserve 4K+ buffer */
266                 client->filledupBytes + HTTP_DATA_BUFSIZE4096;
267             if (client->maxResponseLen > 0 &&
268                 contentLength > (PKIX_Int32)client->maxResponseLen) {
269                 if (client->filledupBytes < client->maxResponseLen) {
270                     contentLength = client->maxResponseLen;
271                 } else {
272                     client->connectStatus = HTTP_ERROR;
273                     goto cleanup;
274                 }
275             }
276             /* set available number of bytes in the buffer */
277             client->capacity = contentLength;
278             client->connectStatus = HTTP_RECV_BODY;
279             *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
280             break;
281 
282         default:
283             client->rcv_http_data_len = contentLength;
284             if (client->maxResponseLen > 0 &&
285                 (PKIX_Int32)client->maxResponseLen < contentLength) {
286                 client->connectStatus = HTTP_ERROR;
287                 goto cleanup;
288             }
289             
290             /*
291              * Do we have all of the message body, or do we need to read some more?
292              */
293             if ((PKIX_Int32)client->filledupBytes < contentLength) {
294                 client->connectStatus = HTTP_RECV_BODY;
295                 *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
296             } else {
297                 client->connectStatus = HTTP_COMPLETE;
298                 *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
299             }
300         }
301 
302         if (contentLength > 0) {
303             /* allocate a buffer of size contentLength  for the content */
304             PKIX_CHECK(PKIX_PL_Malloc(contentLength, (void **)&body, plCtx),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc(contentLength
, (void **)&body, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0)
305                        PKIX_MALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc(contentLength
, (void **)&body, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0);
306             
307             /* copy any remaining bytes in current buffer into new buffer */
308             if (client->filledupBytes > 0) {
309                 PORT_Memcpymemcpy(body, &(client->rcvBuf[headerLength]),
310                             client->filledupBytes);
311             }
312         }
313 
314         PKIX_CHECK(PKIX_PL_Free(client->rcvBuf, plCtx),do { stdVars.aPkixErrorResult = (PKIX_PL_Free(client->rcvBuf
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_FREEFAILED; goto cleanup; } } while (0)
315                    PKIX_FREEFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Free(client->rcvBuf
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_FREEFAILED; goto cleanup; } } while (0);
316         client->rcvBuf = body;
317 
318cleanup:
319 
320        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
321}
322 
323/*
324 * FUNCTION: PKIX_PL_HttpDefaultClient_Create
325 * DESCRIPTION:
326 *
327 *  This function creates a new HttpDefaultClient, and stores the result at
328 *  "pClient".
329 *
330 *  The HttpClient API does not include a plContext argument in its
331 *  function calls. Its value at the time of this Create call must be the
332 *  same as when the client is invoked.
333 *
334 * PARAMETERS:
335 *  "host"
336 *      The name of the server with which we hope to exchange messages. Must
337 *      be non-NULL.
338 *  "portnum"
339 *      The port number to be used for our connection to the server.
340 *  "pClient"
341 *      The address at which the created HttpDefaultClient is to be stored.
342 *      Must be non-NULL.
343 *  "plCtx"
344 *      Platform-specific context pointer.
345 * THREAD SAFETY:
346 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
347 * RETURNS:
348 *  Returns NULL if the function succeeds.
349 *  Returns a HttpDefaultClient Error if the function fails in
350 *      a non-fatal way.
351 *  Returns a Fatal Error if the function fails in an unrecoverable way.
352 */
353static PKIX_Error *
354pkix_pl_HttpDefaultClient_Create(
355        const char *host,
356        PRUint16 portnum,
357        PKIX_PL_HttpDefaultClient **pClient,
358        void *plCtx)
359{
360        PKIX_PL_HttpDefaultClient *client = NULL((void*)0);
361 
362        PKIX_ENTER(HTTPDEFAULTCLIENT, "PKIX_PL_HttpDefaultClient_Create")static const char cMyFuncName[] = {"PKIX_PL_HttpDefaultClient_Create"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
363        PKIX_NULLCHECK_TWO(pClient, host)do { if (((pClient) == ((void*)0)) || ((host) == ((void*)0)))
{ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
 = PKIX_NULLARGUMENT; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR
), ((PKIX_Boolean) 1), plContext);; } } while (0);
364 
365        /* allocate an HttpDefaultClient */
366        PKIX_CHECK(PKIX_PL_Object_Allocdo { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_HTTPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_HttpDefaultClient), (PKIX_PL_Object **)&
client, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_COULDNOTCREATEHTTPDEFAULTCLIENTOBJECT; goto cleanup; }
 } while (0)
367                (PKIX_HTTPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_HTTPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_HttpDefaultClient), (PKIX_PL_Object **)&
client, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_COULDNOTCREATEHTTPDEFAULTCLIENTOBJECT; goto cleanup; }
 } while (0)
368                sizeof (PKIX_PL_HttpDefaultClient),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_HTTPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_HttpDefaultClient), (PKIX_PL_Object **)&
client, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_COULDNOTCREATEHTTPDEFAULTCLIENTOBJECT; goto cleanup; }
 } while (0)
369                (PKIX_PL_Object **)&client,do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_HTTPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_HttpDefaultClient), (PKIX_PL_Object **)&
client, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_COULDNOTCREATEHTTPDEFAULTCLIENTOBJECT; goto cleanup; }
 } while (0)
370                plCtx),do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_HTTPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_HttpDefaultClient), (PKIX_PL_Object **)&
client, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_COULDNOTCREATEHTTPDEFAULTCLIENTOBJECT; goto cleanup; }
 } while (0)
371                PKIX_COULDNOTCREATEHTTPDEFAULTCLIENTOBJECT)do { stdVars.aPkixErrorResult = (PKIX_PL_Object_Alloc (PKIX_HTTPDEFAULTCLIENT_TYPE
, sizeof (PKIX_PL_HttpDefaultClient), (PKIX_PL_Object **)&
client, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_COULDNOTCREATEHTTPDEFAULTCLIENTOBJECT; goto cleanup; }
 } while (0);
372 
373        /* Client timeout is overwritten in HttpDefaultClient_RequestCreate
374         * function. Default value will be ignored. */
375        client->timeout = 0;
376        client->connectStatus = HTTP_NOT_CONNECTED;
377        client->portnum = portnum;
378        client->bytesToWrite = 0;
379        client->send_http_data_len = 0;
380        client->rcv_http_data_len = 0;
381        client->capacity = 0;
382        client->filledupBytes = 0;
383        client->responseCode = 0;
384        client->maxResponseLen = 0;
385        client->GETLen = 0;
386        client->POSTLen = 0;
387        client->pRcv_http_data_len = NULL((void*)0);
388        client->callbackList = NULL((void*)0);
389        client->GETBuf = NULL((void*)0);
390        client->POSTBuf = NULL((void*)0);
391        client->rcvBuf = NULL((void*)0);
392        /* "host" is a parsing result by CERT_GetURL function that adds
393         * "end of line" to the value. OK to dup the string. */
394        client->host = PORT_StrdupPORT_Strdup_Util(host);
395        if (!client->host) {
396            PKIX_ERROR(PKIX_ALLOCERROR){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_ALLOCERROR, ((void*)0), stdVars.aPkixType, 2, plContext
); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_ALLOCERROR; goto cleanup; };
397        }
398        client->path = NULL((void*)0);
399        client->rcvContentType = NULL((void*)0);
400        client->rcvHeaders = NULL((void*)0);
401        client->send_http_method = HTTP_POST_METHOD;
402        client->send_http_content_type = NULL((void*)0);
403        client->send_http_data = NULL((void*)0);
404        client->rcv_http_response_code = NULL((void*)0);
405        client->rcv_http_content_type = NULL((void*)0);
406        client->rcv_http_headers = NULL((void*)0);
407        client->rcv_http_data = NULL((void*)0);
408        client->socket = NULL((void*)0);
409 
410        /*
411         * The HttpClient API does not include a plCtx argument in its
412         * function calls. Save it here.
413         */
414        client->plContext = plCtx;
415 
416        *pClient = client;
417 
418cleanup:
419        if (PKIX_ERROR_RECEIVED(stdVars.aPkixErrorReceived || stdVars.aPkixErrorResult || stdVars
.aPkixTempErrorReceived || stdVars.aPkixErrorList)) {
420                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);
421        }
422 
423        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
424}
425 
426/*
427 * FUNCTION: pkix_pl_HttpDefaultClient_Destroy
428 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
429 */
430static PKIX_Error *
431pkix_pl_HttpDefaultClient_Destroy(
432        PKIX_PL_Object *object,
433        void *plCtx)
434{
435        PKIX_PL_HttpDefaultClient *client = NULL((void*)0);
436 
437        PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_Destroy")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_Destroy"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
438        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);
439 
440        PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_HTTPDEFAULTCLIENT_TYPE
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_OBJECTNOTANHTTPDEFAULTCLIENT; goto cleanup; } } while
 (0)
441                    (object, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx),do { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_HTTPDEFAULTCLIENT_TYPE
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_OBJECTNOTANHTTPDEFAULTCLIENT; goto cleanup; } } while
 (0)
442                    PKIX_OBJECTNOTANHTTPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType (object, PKIX_HTTPDEFAULTCLIENT_TYPE
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_OBJECTNOTANHTTPDEFAULTCLIENT; goto cleanup; } } while
 (0);
443 
444        client = (PKIX_PL_HttpDefaultClient *)object;
445 
446        if (client->rcvHeaders) {
447            PKIX_PL_Free(client->rcvHeaders, plCtx);
448            client->rcvHeaders = NULL((void*)0);
449        }
450        if (client->rcvContentType) {
451            PORT_FreePORT_Free_Util(client->rcvContentType);
452            client->rcvContentType = NULL((void*)0);
453        }
454        if (client->GETBuf != NULL((void*)0)) {
455                PR_smprintf_free(client->GETBuf);
456                client->GETBuf = NULL((void*)0);
457        }
458        if (client->POSTBuf != NULL((void*)0)) {
459                PKIX_PL_Free(client->POSTBuf, plCtx);
460                client->POSTBuf = NULL((void*)0);
461        }
462        if (client->rcvBuf != NULL((void*)0)) {
463                PKIX_PL_Free(client->rcvBuf, plCtx);
464                client->rcvBuf = NULL((void*)0);
465        }
466        if (client->host) {
467                PORT_FreePORT_Free_Util(client->host);
468                client->host = NULL((void*)0);
469        }
470        if (client->path) {
471                PORT_FreePORT_Free_Util(client->path);
472                client->path = NULL((void*)0);
473        }
474        PKIX_DECREF(client->socket)do { if (client->socket){ stdVars.aPkixTempResult = PKIX_PL_Object_DecRef
 ((PKIX_PL_Object *)(client->socket), plContext); if (stdVars
.aPkixTempResult) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult
, plContext); stdVars.aPkixTempResult = ((void*)0); } client->
socket = ((void*)0); } } while (0);
475 
476cleanup:
477 
478        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
479}
480 
481/*
482 * FUNCTION: pkix_pl_HttpDefaultClient_RegisterSelf
483 *
484 * DESCRIPTION:
485 *  Registers PKIX_PL_HTTPDEFAULTCLIENT_TYPE and its related
486 *  functions with systemClasses[]
487 *
488 * THREAD SAFETY:
489 *  Not Thread Safe - for performance and complexity reasons
490 *
491 *  Since this function is only called by PKIX_PL_Initialize, which should
492 *  only be called once, it is acceptable that this function is not
493 *  thread-safe.
494 */
495PKIX_Error *
496pkix_pl_HttpDefaultClient_RegisterSelf(void *plCtx)
497{
498        extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
499        pkix_ClassTable_Entry *entry =
500            &systemClasses[PKIX_HTTPDEFAULTCLIENT_TYPE];
501 
502        PKIX_ENTER(HTTPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RegisterSelf"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
503                "pkix_pl_HttpDefaultClient_RegisterSelf")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RegisterSelf"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
504 
505        entry->description = "HttpDefaultClient";
506        entry->typeObjectSize = sizeof(PKIX_PL_HttpDefaultClient);
507        entry->destructor = pkix_pl_HttpDefaultClient_Destroy;
508 
509        httpClient.version = 1;
510        httpClient.fcnTable.ftable1 = vtable;
511        (void)SEC_RegisterDefaultHttpClient(&httpClient);
512 
513        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
514}
515 
516/* --Private-HttpDefaultClient-I/O-Functions---------------------------- */
517/*
518 * FUNCTION: pkix_pl_HttpDefaultClient_ConnectContinue
519 * DESCRIPTION:
520 *
521 *  This function determines whether a socket Connect initiated earlier for the
522 *  HttpDefaultClient "client" has completed, and stores in "pKeepGoing" a flag
523 *  indicating whether processing can continue without further input.
524 *
525 * PARAMETERS:
526 *  "client"
527 *      The address of the HttpDefaultClient object. Must be non-NULL.
528 *  "pKeepGoing"
529 *      The address at which the Boolean state machine flag is stored to
530 *      indicate whether processing can continue without further input.
531 *      Must be non-NULL.
532 *  "plCtx"
533 *      Platform-specific context pointer.
534 * THREAD SAFETY:
535 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
536 * RETURNS:
537 *  Returns NULL if the function succeeds.
538 *  Returns a HttpDefaultClient Error if the function fails in a
539 *      non-fatal way.
540 *  Returns a Fatal Error if the function fails in an unrecoverable way.
541 */
542static PKIX_Error *
543pkix_pl_HttpDefaultClient_ConnectContinue(
544        PKIX_PL_HttpDefaultClient *client,
545        PKIX_Boolean *pKeepGoing,
546        void *plCtx)
547{
548        PRErrorCode status;
549        PKIX_Boolean keepGoing = PKIX_FALSE((PKIX_Boolean) 0);
550        PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
551 
552        PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_ConnectContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
553                (HTTPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_ConnectContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
554                "pkix_pl_HttpDefaultClient_ConnectContinue")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_ConnectContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
555        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);
556 
557        callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
558 
559        PKIX_CHECK(callbackList->connectcontinueCallbackdo { stdVars.aPkixErrorResult = (callbackList->connectcontinueCallback
 (client->socket, &status, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETCONNECTCONTINUEFAILED; goto
 cleanup; } } while (0)
560                (client->socket, &status, plCtx),do { stdVars.aPkixErrorResult = (callbackList->connectcontinueCallback
 (client->socket, &status, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETCONNECTCONTINUEFAILED; goto
 cleanup; } } while (0)
561                PKIX_SOCKETCONNECTCONTINUEFAILED)do { stdVars.aPkixErrorResult = (callbackList->connectcontinueCallback
 (client->socket, &status, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETCONNECTCONTINUEFAILED; goto
 cleanup; } } while (0);
562 
563        if (status == 0) {
564                client->connectStatus = HTTP_CONNECTED;
565                keepGoing = PKIX_TRUE((PKIX_Boolean) 1);
566        } else if (status != PR_IN_PROGRESS_ERROR(-5934L)) {
567                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; };
568        }
569 
570        *pKeepGoing = keepGoing;
571 
572cleanup:
573        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
574}
575 
576/*
577 * FUNCTION: pkix_pl_HttpDefaultClient_Send
578 * DESCRIPTION:
579 *
580 *  This function creates and sends HTTP-protocol headers and, if applicable,
581 *  data, for the HttpDefaultClient "client", and stores in "pKeepGoing" a flag
582 *  indicating whether processing can continue without further input, and at
583 *  "pBytesTransferred" the number of bytes sent.
584 *
585 *  If "pBytesTransferred" is zero, it indicates that non-blocking I/O is in use
586 *  and that transmission has not completed.
587 *
588 * PARAMETERS:
589 *  "client"
590 *      The address of the HttpDefaultClient object. Must be non-NULL.
591 *  "pKeepGoing"
592 *      The address at which the Boolean state machine flag is stored to
593 *      indicate whether processing can continue without further input.
594 *      Must be non-NULL.
595 *  "pBytesTransferred"
596 *      The address at which the number of bytes sent is stored. Must be
597 *      non-NULL.
598 *  "plCtx"
599 *      Platform-specific context pointer.
600 * THREAD SAFETY:
601 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
602 * RETURNS:
603 *  Returns NULL if the function succeeds.
604 *  Returns a HttpDefaultClient Error if the function fails in a
605 *      non-fatal way.
606 *  Returns a Fatal Error if the function fails in an unrecoverable way.
607 */
608static PKIX_Error *
609pkix_pl_HttpDefaultClient_Send(
610        PKIX_PL_HttpDefaultClient *client,
611        PKIX_Boolean *pKeepGoing,
612        PKIX_UInt32 *pBytesTransferred,
613        void *plCtx)
614{
615        PKIX_Int32 bytesWritten = 0;
616        PKIX_Int32 lenToWrite = 0;
617        PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
618        char *dataToWrite = NULL((void*)0);
619 
620        PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_Send")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_Send"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
621        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);
622 
623        *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
624 
625        /* Do we have anything waiting to go? */
626        if ((client->GETBuf) || (client->POSTBuf)) {
627 
628                if (client->GETBuf) {
629                        dataToWrite = client->GETBuf;
630                        lenToWrite = client->GETLen;
631                } else {
632                        dataToWrite = client->POSTBuf;
633                        lenToWrite = client->POSTLen;
634                }
635 
636                callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
637 
638                PKIX_CHECK(callbackList->sendCallbackdo { stdVars.aPkixErrorResult = (callbackList->sendCallback
 (client->socket, dataToWrite, lenToWrite, &bytesWritten
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_SOCKETSENDFAILED; goto cleanup; } } while (0)
639                        (client->socket,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
 (client->socket, dataToWrite, lenToWrite, &bytesWritten
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_SOCKETSENDFAILED; goto cleanup; } } while (0)
640                        dataToWrite,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
 (client->socket, dataToWrite, lenToWrite, &bytesWritten
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_SOCKETSENDFAILED; goto cleanup; } } while (0)
641                        lenToWrite,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
 (client->socket, dataToWrite, lenToWrite, &bytesWritten
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_SOCKETSENDFAILED; goto cleanup; } } while (0)
642                        &bytesWritten,do { stdVars.aPkixErrorResult = (callbackList->sendCallback
 (client->socket, dataToWrite, lenToWrite, &bytesWritten
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_SOCKETSENDFAILED; goto cleanup; } } while (0)
643                        plCtx),do { stdVars.aPkixErrorResult = (callbackList->sendCallback
 (client->socket, dataToWrite, lenToWrite, &bytesWritten
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_SOCKETSENDFAILED; goto cleanup; } } while (0)
644                        PKIX_SOCKETSENDFAILED)do { stdVars.aPkixErrorResult = (callbackList->sendCallback
 (client->socket, dataToWrite, lenToWrite, &bytesWritten
, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_SOCKETSENDFAILED; goto cleanup; } } while (0);
645 
646                client->rcvBuf = NULL((void*)0);
647                client->capacity = 0;
648                client->filledupBytes = 0;
649 
650                /*
651                 * If the send completed we can proceed to try for the
652                 * response. If the send did not complete we will have
653                 * to poll for completion later.
654                 */
655                if (bytesWritten >= 0) {
656                        client->connectStatus = HTTP_RECV_HDR;
657                        *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
658                } else {
659                        client->connectStatus = HTTP_SEND_PENDING;
660                        *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
661                }
662 
663        }
664 
665        *pBytesTransferred = bytesWritten;
666 
667cleanup:
668        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
669}
670 
671/*
672 * FUNCTION: pkix_pl_HttpDefaultClient_SendContinue
673 * DESCRIPTION:
674 *
675 *  This function determines whether the sending of the HTTP message for the
676 *  HttpDefaultClient "client" has completed, and stores in "pKeepGoing" a
677 *  flag indicating whether processing can continue without further input, and
678 *  at "pBytesTransferred" the number of bytes sent.
679 *
680 *  If "pBytesTransferred" is zero, it indicates that non-blocking I/O is in use
681 *  and that transmission has not completed.
682 *
683 * PARAMETERS:
684 *  "client"
685 *      The address of the HttpDefaultClient object. Must be non-NULL.
686 *  "pKeepGoing"
687 *      The address at which the Boolean state machine flag is stored to
688 *      indicate whether processing can continue without further input.
689 *      Must be non-NULL.
690 *  "pBytesTransferred"
691 *      The address at which the number of bytes sent is stored. Must be
692 *      non-NULL.
693 *  "plCtx"
694 *      Platform-specific context pointer.
695 * THREAD SAFETY:
696 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
697 * RETURNS:
698 *  Returns NULL if the function succeeds.
699 *  Returns a HttpDefaultClient Error if the function fails in a
700 *      non-fatal way.
701 *  Returns a Fatal Error if the function fails in an unrecoverable way.
702 */
703static PKIX_Error *
704pkix_pl_HttpDefaultClient_SendContinue(
705        PKIX_PL_HttpDefaultClient *client,
706        PKIX_Boolean *pKeepGoing,
707        PKIX_UInt32 *pBytesTransferred,
708        void *plCtx)
709{
710        PKIX_Int32 bytesWritten = 0;
711        PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
712 
713        PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_SendContinue")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_SendContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
714        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);
715 
716        *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
717 
718        callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
719 
720        PKIX_CHECK(callbackList->pollCallbackdo { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, &bytesWritten, ((void*)0), plCtx)); if
 (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0)
721                (client->socket, &bytesWritten, NULL, plCtx),do { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, &bytesWritten, ((void*)0), plCtx)); if
 (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0)
722                PKIX_SOCKETPOLLFAILED)do { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, &bytesWritten, ((void*)0), plCtx)); if
 (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0);
723 
724        /*
725         * If the send completed we can proceed to try for the
726         * response. If the send did not complete we will have
727         * continue to poll.
728         */
729        if (bytesWritten >= 0) {
730                       client->connectStatus = HTTP_RECV_HDR;
731                *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
732        }
733 
734        *pBytesTransferred = bytesWritten;
735 
736cleanup:
737        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
738}
739 
740/*
741 * FUNCTION: pkix_pl_HttpDefaultClient_RecvHdr
742 * DESCRIPTION:
743 *
744 *  This function receives HTTP headers for the HttpDefaultClient "client", and
745 *  stores in "pKeepGoing" a flag indicating whether processing can continue
746 *  without further input.
747 *
748 * PARAMETERS:
749 *  "client"
750 *      The address of the HttpDefaultClient object. Must be non-NULL.
751 *  "pKeepGoing"
752 *      The address at which the Boolean state machine flag is stored to
753 *      indicate whether processing can continue without further input.
754 *      Must be non-NULL.
755 *  "plCtx"
756 *      Platform-specific context pointer.
757 * THREAD SAFETY:
758 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
759 * RETURNS:
760 *  Returns NULL if the function succeeds.
761 *  Returns a HttpDefaultClient Error if the function fails in a
762 *      non-fatal way.
763 *  Returns a Fatal Error if the function fails in an unrecoverable way.
764 */
765static PKIX_Error *
766pkix_pl_HttpDefaultClient_RecvHdr(
767        PKIX_PL_HttpDefaultClient *client,
768        PKIX_Boolean *pKeepGoing,
769        void *plCtx)
770{
771        PKIX_UInt32 bytesToRead = 0;
772        PKIX_Int32 bytesRead = 0;
773        PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
774 
775        PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_RecvHdr")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RecvHdr"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
776        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);
777 
778        /*
779         * rcvbuf, capacity, and filledupBytes were
780         * initialized when we wrote the headers. We begin by reading
781         * HTTP_HEADER_BUFSIZE bytes, repeatedly increasing the buffersize and
782         * reading again if necessary, until we have read the end-of-header
783         * marker, "\r\n\r\n", or have reached our maximum.
784         */
785        client->capacity += HTTP_HEADER_BUFSIZE1024;
786        PKIX_CHECK(PKIX_PL_Reallocdo { stdVars.aPkixErrorResult = (PKIX_PL_Realloc (client->
rcvBuf, client->capacity, (void **)&(client->rcvBuf
), plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_REALLOCFAILED; goto cleanup; } } while (0)
787                (client->rcvBuf,do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc (client->
rcvBuf, client->capacity, (void **)&(client->rcvBuf
), plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_REALLOCFAILED; goto cleanup; } } while (0)
788                client->capacity,do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc (client->
rcvBuf, client->capacity, (void **)&(client->rcvBuf
), plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_REALLOCFAILED; goto cleanup; } } while (0)
789                (void **)&(client->rcvBuf),do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc (client->
rcvBuf, client->capacity, (void **)&(client->rcvBuf
), plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_REALLOCFAILED; goto cleanup; } } while (0)
790                plCtx),do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc (client->
rcvBuf, client->capacity, (void **)&(client->rcvBuf
), plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_REALLOCFAILED; goto cleanup; } } while (0)
791                PKIX_REALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc (client->
rcvBuf, client->capacity, (void **)&(client->rcvBuf
), plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_REALLOCFAILED; goto cleanup; } } while (0);
792 
793        bytesToRead = client->capacity - client->filledupBytes;
794 
795        callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
796 
797        PKIX_CHECK(callbackList->recvCallbackdo { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
798                (client->socket,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
799                (void *)&(client->rcvBuf[client->filledupBytes]),do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
800                bytesToRead,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
801                &bytesRead,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
802                plCtx),do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
803                PKIX_SOCKETRECVFAILED)do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0);
804 
805        if (bytesRead > 0) {
806            /* client->filledupBytes will be adjusted by
807             * pkix_pl_HttpDefaultClient_HdrCheckComplete */
808            PKIX_CHECK(do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_HdrCheckComplete
(client, bytesRead, pKeepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
809                pkix_pl_HttpDefaultClient_HdrCheckComplete(client, bytesRead,do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_HdrCheckComplete
(client, bytesRead, pKeepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
810                                                           pKeepGoing,do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_HdrCheckComplete
(client, bytesRead, pKeepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
811                                                           plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_HdrCheckComplete
(client, bytesRead, pKeepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
812                       PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_HdrCheckComplete
(client, bytesRead, pKeepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED
; goto cleanup; } } while (0);
813        } else {
814            client->connectStatus = HTTP_RECV_HDR_PENDING;
815            *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
816        }
817 
818cleanup:
819        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
820}
821 
822/*
823 * FUNCTION: pkix_pl_HttpDefaultClient_RecvHdrContinue
824 * DESCRIPTION:
825 *
826 *  This function determines whether the receiving of the HTTP headers for the
827 *  HttpDefaultClient "client" has completed, and stores in "pKeepGoing" a flag
828 *  indicating whether processing can continue without further input.
829 *
830 * PARAMETERS:
831 *  "client"
832 *      The address of the HttpDefaultClient object. Must be non-NULL.
833 *  "pKeepGoing"
834 *      The address at which the Boolean state machine flag is stored to
835 *      indicate whether processing can continue without further input.
836 *      Must be non-NULL.
837 *  "plCtx"
838 *      Platform-specific context pointer.
839 * THREAD SAFETY:
840 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
841 * RETURNS:
842 *  Returns NULL if the function succeeds.
843 *  Returns a HttpDefaultClient Error if the function fails in a
844 *      non-fatal way.
845 *  Returns a Fatal Error if the function fails in an unrecoverable way.
846 */
847static PKIX_Error *
848pkix_pl_HttpDefaultClient_RecvHdrContinue(
849        PKIX_PL_HttpDefaultClient *client,
850        PKIX_Boolean *pKeepGoing,
851        void *plCtx)
852{
853        PKIX_Int32 bytesRead = 0;
854        PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
855 
856        PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RecvHdrContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
857                (HTTPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RecvHdrContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
858                "pkix_pl_HttpDefaultClient_RecvHdrContinue")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RecvHdrContinue"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
859        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);
860 
861        callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
862 
863        PKIX_CHECK(callbackList->pollCallbackdo { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, ((void*)0), &bytesRead, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0)
864                (client->socket, NULL, &bytesRead, plCtx),do { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, ((void*)0), &bytesRead, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0)
865                PKIX_SOCKETPOLLFAILED)do { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, ((void*)0), &bytesRead, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0);
866 
867        if (bytesRead > 0) {
868                client->filledupBytes += bytesRead;
869 
870                PKIX_CHECK(pkix_pl_HttpDefaultClient_HdrCheckCompletedo { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_HdrCheckComplete
 (client, bytesRead, pKeepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
871                        (client, bytesRead, pKeepGoing, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_HdrCheckComplete
 (client, bytesRead, pKeepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED
; goto cleanup; } } while (0)
872                        PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_HdrCheckComplete
 (client, bytesRead, pKeepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED
; goto cleanup; } } while (0);
873 
874        } else {
875 
876                *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
877 
878        }
879 
880cleanup:
881        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
882}
883 
884/*
885 * FUNCTION: pkix_pl_HttpDefaultClient_RecvBody
886 * DESCRIPTION:
887 *
888 *  This function processes the contents of the first buffer of a received
889 *  HTTP-protocol message for the HttpDefaultClient "client", and stores in
890 *  "pKeepGoing" a flag indicating whether processing can continue without
891 *  further input.
892 *
893 * PARAMETERS:
894 *  "client"
895 *      The address of the HttpDefaultClient object. Must be non-NULL.
896 *  "pKeepGoing"
897 *      The address at which the Boolean state machine flag is stored to
898 *      indicate whether processing can continue without further input.
899 *      Must be non-NULL.
900 *  "plCtx"
901 *      Platform-specific context pointer.
902 * THREAD SAFETY:
903 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
904 * RETURNS:
905 *  Returns NULL if the function succeeds.
906 *  Returns a HttpDefaultClient Error if the function fails in a
907 *      non-fatal way.
908 *  Returns a Fatal Error if the function fails in an unrecoverable way.
909 */
910static PKIX_Error *
911pkix_pl_HttpDefaultClient_RecvBody(
912        PKIX_PL_HttpDefaultClient *client,
913        PKIX_Boolean *pKeepGoing,
914        void *plCtx)
915{
916        PKIX_Int32 bytesRead = 0;
917        PKIX_Int32 bytesToRead = 0;
918        PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
919 
920        PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_RecvBody")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RecvBody"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
921        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);
922 
923        callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
924 
925        if (client->rcv_http_data_len != HTTP_UNKNOWN_CONTENT_LENGTH-1) {
926            bytesToRead = client->rcv_http_data_len -
927                client->filledupBytes;
928        } else {
929            /* Reading till the EOF. Context length is not known.*/
930            /* Check the buffer capacity: increase and
931             * reallocate if it is low. */
932            int freeBuffSize = client->capacity - client->filledupBytes;
933            if (freeBuffSize < HTTP_MIN_AVAILABLE_BUFFER_SIZE512) {
934                /* New length will be consist of available(downloaded) bytes,
935                 * plus remaining capacity, plus new expansion. */
936                int currBuffSize = client->capacity;
937                /* Try to increase the buffer by 4K */
938                unsigned int newLength = currBuffSize + HTTP_DATA_BUFSIZE4096;
939                if (client->maxResponseLen > 0 &&
940                    newLength > client->maxResponseLen) {
941                        newLength = client->maxResponseLen;
942                }
943                /* Check if we can grow the buffer and report an error if
944                 * new size is not larger than the current size of the buffer.*/
945                if (newLength <= client->filledupBytes) {
946                    client->rcv_http_data_len = client->filledupBytes;
947                    client->connectStatus = HTTP_ERROR;
948                    *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
949                    goto cleanup;
950                }
951                if (client->capacity < newLength) {
952                    client->capacity = newLength;
953                    PKIX_CHECK(do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc(client->rcvBuf
, newLength, (void**)&client->rcvBuf, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REALLOCFAILED; goto
 cleanup; } } while (0)
954                        PKIX_PL_Realloc(client->rcvBuf, newLength,do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc(client->rcvBuf
, newLength, (void**)&client->rcvBuf, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REALLOCFAILED; goto
 cleanup; } } while (0)
955                                        (void**)&client->rcvBuf, plCtx),do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc(client->rcvBuf
, newLength, (void**)&client->rcvBuf, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REALLOCFAILED; goto
 cleanup; } } while (0)
956                        PKIX_REALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Realloc(client->rcvBuf
, newLength, (void**)&client->rcvBuf, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REALLOCFAILED; goto
 cleanup; } } while (0);
957                    freeBuffSize = client->capacity -
958                        client->filledupBytes;
959                }
960            }
961            bytesToRead = freeBuffSize;
962        }
963 
964        /* Use poll callback if waiting on non-blocking IO */
965        if (client->connectStatus == HTTP_RECV_BODY_PENDING) {
966            PKIX_CHECK(callbackList->pollCallbackdo { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, ((void*)0), &bytesRead, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0)
967                       (client->socket, NULL, &bytesRead, plCtx),do { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, ((void*)0), &bytesRead, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0)
968                       PKIX_SOCKETPOLLFAILED)do { stdVars.aPkixErrorResult = (callbackList->pollCallback
 (client->socket, ((void*)0), &bytesRead, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETPOLLFAILED
; goto cleanup; } } while (0);
969        } else {
970            PKIX_CHECK(callbackList->recvCallbackdo { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
971                       (client->socket,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
972                        (void *)&(client->rcvBuf[client->filledupBytes]),do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
973                        bytesToRead,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
974                        &bytesRead,do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
975                        plCtx),do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0)
976                       PKIX_SOCKETRECVFAILED)do { stdVars.aPkixErrorResult = (callbackList->recvCallback
 (client->socket, (void *)&(client->rcvBuf[client->
filledupBytes]), bytesToRead, &bytesRead, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SOCKETRECVFAILED
; goto cleanup; } } while (0);
977        }
978 
979        /* If bytesRead < 0, an error will be thrown by recvCallback, so
980         * need to handle >= 0 cases. */
981 
982        /* bytesRead == 0 - IO was blocked. */
983        if (bytesRead == 0) {
984            client->connectStatus = HTTP_RECV_BODY_PENDING;
985            *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
986            goto cleanup;
987        }
988        
989        /* We got something. Did we get it all? */
990        client->filledupBytes += bytesRead;
991 
992        /* continue if not enough bytes read or if complete size of
993         * transfer is unknown */
994        if (bytesToRead > bytesRead ||
995            client->rcv_http_data_len == HTTP_UNKNOWN_CONTENT_LENGTH-1) {
996            *pKeepGoing = PKIX_TRUE((PKIX_Boolean) 1);
997            goto cleanup;
998        }
999        client->connectStatus = HTTP_COMPLETE;
1000        *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1001 
1002cleanup:
1003        if (pkixErrorResultstdVars.aPkixErrorResult && pkixErrorResultstdVars.aPkixErrorResult->errCode ==
1004            PKIX_PRRECVREPORTSNETWORKCONNECTIONCLOSED) {
1005            if (client->rcv_http_data_len == HTTP_UNKNOWN_CONTENT_LENGTH-1) {
1006                client->rcv_http_data_len = client->filledupBytes;
1007                client->connectStatus = HTTP_COMPLETE;
1008                *pKeepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1009                PKIX_DECREF(pkixErrorResult)do { if (stdVars.aPkixErrorResult){ stdVars.aPkixTempResult =
 PKIX_PL_Object_DecRef ((PKIX_PL_Object *)(stdVars.aPkixErrorResult
), plContext); if (stdVars.aPkixTempResult) { PKIX_DoAddError
(&stdVars, stdVars.aPkixTempResult, plContext); stdVars.aPkixTempResult
 = ((void*)0); } stdVars.aPkixErrorResult = ((void*)0); } } while
 (0);
1010            } else {
1011                client->connectStatus = HTTP_ERROR;
1012            }
1013        }
1014 
1015        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1016}
1017 
1018/*
1019 * FUNCTION: pkix_pl_HttpDefaultClient_Dispatch
1020 * DESCRIPTION:
1021 *
1022 *  This function is the state machine dispatcher for the HttpDefaultClient
1023 *  pointed to by "client". Results are returned by changes to various fields
1024 *  in the context.
1025 *
1026 * PARAMETERS:
1027 *  "client"
1028 *      The address of the HttpDefaultClient object. Must be non-NULL.
1029 *  "plCtx"
1030 *      Platform-specific context pointer.
1031 * THREAD SAFETY:
1032 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1033 * RETURNS:
1034 *  Returns NULL if the function succeeds.
1035 *  Returns a HttpDefaultClient Error if the function fails in a
1036 *      non-fatal way.
1037 *  Returns a Fatal Error if the function fails in an unrecoverable way.
1038 */
1039static PKIX_Error *
1040pkix_pl_HttpDefaultClient_Dispatch(
1041        PKIX_PL_HttpDefaultClient *client,
1042        void *plCtx)
1043{
1044        PKIX_UInt32 bytesTransferred = 0;
1045        PKIX_Boolean keepGoing = PKIX_TRUE((PKIX_Boolean) 1);
1046 
1047        PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_Dispatch")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_Dispatch"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1048        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);
1049 
1050        while (keepGoing) {
1051                switch (client->connectStatus) {
1052                case HTTP_CONNECT_PENDING:
1053                    PKIX_CHECK(pkix_pl_HttpDefaultClient_ConnectContinuedo { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_ConnectContinue
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTCONNECTCONTINUEFAILED
; goto cleanup; } } while (0)
1054                        (client, &keepGoing, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_ConnectContinue
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTCONNECTCONTINUEFAILED
; goto cleanup; } } while (0)
1055                        PKIX_HTTPDEFAULTCLIENTCONNECTCONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_ConnectContinue
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTCONNECTCONTINUEFAILED
; goto cleanup; } } while (0);
1056                    break;
1057                case HTTP_CONNECTED:
1058                    PKIX_CHECK(pkix_pl_HttpDefaultClient_Senddo { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_Send
 (client, &keepGoing, &bytesTransferred, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTSENDFAILED
; goto cleanup; } } while (0)
1059                        (client, &keepGoing, &bytesTransferred, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_Send
 (client, &keepGoing, &bytesTransferred, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTSENDFAILED
; goto cleanup; } } while (0)
1060                        PKIX_HTTPDEFAULTCLIENTSENDFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_Send
 (client, &keepGoing, &bytesTransferred, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTSENDFAILED
; goto cleanup; } } while (0);
1061                    break;
1062                case HTTP_SEND_PENDING:
1063                    PKIX_CHECK(pkix_pl_HttpDefaultClient_SendContinuedo { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_SendContinue
 (client, &keepGoing, &bytesTransferred, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTSENDCONTINUEFAILED
; goto cleanup; } } while (0)
1064                        (client, &keepGoing, &bytesTransferred, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_SendContinue
 (client, &keepGoing, &bytesTransferred, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTSENDCONTINUEFAILED
; goto cleanup; } } while (0)
1065                        PKIX_HTTPDEFAULTCLIENTSENDCONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_SendContinue
 (client, &keepGoing, &bytesTransferred, plCtx)); if (
stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars
.aPkixErrorResult->errClass; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTSENDCONTINUEFAILED
; goto cleanup; } } while (0);
1066                    break;
1067                case HTTP_RECV_HDR:
1068                    PKIX_CHECK(pkix_pl_HttpDefaultClient_RecvHdrdo { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvHdr
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVHDRFAILED
; goto cleanup; } } while (0)
1069                        (client, &keepGoing, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvHdr
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVHDRFAILED
; goto cleanup; } } while (0)
1070                        PKIX_HTTPDEFAULTCLIENTRECVHDRFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvHdr
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVHDRFAILED
; goto cleanup; } } while (0);
1071                    break;
1072                case HTTP_RECV_HDR_PENDING:
1073                    PKIX_CHECK(pkix_pl_HttpDefaultClient_RecvHdrContinuedo { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvHdrContinue
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVHDRCONTINUEFAILED
; goto cleanup; } } while (0)
1074                        (client, &keepGoing, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvHdrContinue
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVHDRCONTINUEFAILED
; goto cleanup; } } while (0)
1075                        PKIX_HTTPDEFAULTCLIENTRECVHDRCONTINUEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvHdrContinue
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVHDRCONTINUEFAILED
; goto cleanup; } } while (0);
1076                    break;
1077                case HTTP_RECV_BODY:
1078                case HTTP_RECV_BODY_PENDING:
1079                    PKIX_CHECK(pkix_pl_HttpDefaultClient_RecvBodydo { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvBody
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVBODYFAILED
; goto cleanup; } } while (0)
1080                        (client, &keepGoing, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvBody
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVBODYFAILED
; goto cleanup; } } while (0)
1081                        PKIX_HTTPDEFAULTCLIENTRECVBODYFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_RecvBody
 (client, &keepGoing, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTRECVBODYFAILED
; goto cleanup; } } while (0);
1082                    break;
1083                case HTTP_ERROR:
1084                case HTTP_COMPLETE:
1085                    keepGoing = PKIX_FALSE((PKIX_Boolean) 0);
1086                    break;
1087                case HTTP_NOT_CONNECTED:
1088                default:
1089                    PKIX_ERROR(PKIX_HTTPDEFAULTCLIENTINILLEGALSTATE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_HTTPDEFAULTCLIENTINILLEGALSTATE, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTINILLEGALSTATE
; goto cleanup; };
1090                }
1091        }
1092 
1093cleanup:
1094 
1095        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1096}
1097 
1098/*
1099 * --HttpClient vtable functions
1100 * See comments in ocspt.h for the function (wrappers) that return SECStatus.
1101 * The functions that return PKIX_Error* are the libpkix implementations.
1102 */
1103 
1104PKIX_Error *
1105pkix_pl_HttpDefaultClient_CreateSession(
1106        const char *host,
1107        PRUint16 portnum,
1108        SEC_HTTP_SERVER_SESSION *pSession,
1109        void *plCtx)
1110{
1111        PKIX_PL_HttpDefaultClient *client = NULL((void*)0);
1112 
1113        PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_CreateSession"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1114                (HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_CreateSession")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_CreateSession"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1115        PKIX_NULLCHECK_TWO(host, pSession)do { if (((host) == ((void*)0)) || ((pSession) == ((void*)0))
){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
 = PKIX_NULLARGUMENT; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR
), ((PKIX_Boolean) 1), plContext);; } } while (0);
1116 
1117        PKIX_CHECK(pkix_pl_HttpDefaultClient_Createdo { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_Create
 (host, portnum, &client, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTCREATEFAILED
; goto cleanup; } } while (0)
1118                (host, portnum, &client, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_Create
 (host, portnum, &client, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTCREATEFAILED
; goto cleanup; } } while (0)
1119                PKIX_HTTPDEFAULTCLIENTCREATEFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_Create
 (host, portnum, &client, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPDEFAULTCLIENTCREATEFAILED
; goto cleanup; } } while (0);
1120 
1121        *pSession = (SEC_HTTP_SERVER_SESSION)client;
1122 
1123cleanup:
1124 
1125        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1126 
1127}
1128 
1129PKIX_Error *
1130pkix_pl_HttpDefaultClient_KeepAliveSession(
1131        SEC_HTTP_SERVER_SESSION session,
1132        PRPollDesc **pPollDesc,
1133        void *plCtx)
1134{
1135        PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_KeepAliveSession"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1136                (HTTPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_KeepAliveSession"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1137                "pkix_pl_HttpDefaultClient_KeepAliveSession")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_KeepAliveSession"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1138        PKIX_NULLCHECK_TWO(session, pPollDesc)do { if (((session) == ((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);
1139 
1140        PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1141                ((PKIX_PL_Object *)session,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1142                PKIX_HTTPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1143                plCtx),do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1144                PKIX_SESSIONNOTANHTTPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0);
1145 
1146        /* XXX Not implemented */
1147 
1148cleanup:
1149 
1150        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1151 
1152}
1153 
1154PKIX_Error *
1155pkix_pl_HttpDefaultClient_RequestCreate(
1156        SEC_HTTP_SERVER_SESSION session,
1157        const char *http_protocol_variant, /* usually "http" */
1158        const char *path_and_query_string,
1159        const char *http_request_method, 
1160        const PRIntervalTime timeout, 
1161        SEC_HTTP_REQUEST_SESSION *pRequest,
1162        void *plCtx)
1163{
1164        PKIX_PL_HttpDefaultClient *client = NULL((void*)0);
1165        PKIX_PL_Socket *socket = NULL((void*)0);
1166        PKIX_PL_Socket_Callback *callbackList = NULL((void*)0);
1167        PRFileDesc *fileDesc = NULL((void*)0);
1168        PRErrorCode status = 0;
1169 
1170        PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RequestCreate"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1171                (HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_RequestCreate")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_RequestCreate"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1172        PKIX_NULLCHECK_TWO(session, pRequest)do { if (((session) == ((void*)0)) || ((pRequest) == ((void*)
0))){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_NULLARGUMENT; return PKIX_DoReturn(&
stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean) 1), plContext);;
 } } while (0);
1173 
1174        PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1175                ((PKIX_PL_Object *)session,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1176                PKIX_HTTPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1177                plCtx),do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1178                PKIX_SESSIONNOTANHTTPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)session, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_SESSIONNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0);
1179 
1180        client = (PKIX_PL_HttpDefaultClient *)session;
1181 
1182        /* We only know how to do http */
1183        if (PORT_StrncasecmpPL_strncasecmp(http_protocol_variant, "http", 4) != 0) {
1184                PKIX_ERROR(PKIX_UNRECOGNIZEDPROTOCOLREQUESTED){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_UNRECOGNIZEDPROTOCOLREQUESTED, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_UNRECOGNIZEDPROTOCOLREQUESTED
; goto cleanup; };
1185        }
1186 
1187        if (PORT_StrncasecmpPL_strncasecmp(http_request_method, "POST", 4) == 0) {
1188                client->send_http_method = HTTP_POST_METHOD;
1189        } else if (PORT_StrncasecmpPL_strncasecmp(http_request_method, "GET", 3) == 0) {
1190                client->send_http_method = HTTP_GET_METHOD;
1191        } else {
1192                /* We only know how to do POST and GET */
1193                PKIX_ERROR(PKIX_UNRECOGNIZEDREQUESTMETHOD){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_UNRECOGNIZEDREQUESTMETHOD, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_UNRECOGNIZEDREQUESTMETHOD
; goto cleanup; };
1194        }
1195 
1196        if (path_and_query_string) {
1197            /* "path_and_query_string" is a parsing result by CERT_GetURL
1198             * function that adds "end of line" to the value. OK to dup
1199             * the string. */
1200            client->path = PORT_StrdupPORT_Strdup_Util(path_and_query_string);
1201            if (!client->path) {
1202                PKIX_ERROR(PKIX_ALLOCERROR){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_ALLOCERROR, ((void*)0), stdVars.aPkixType, 2, plContext
); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars
.aPkixErrorCode = PKIX_ALLOCERROR; goto cleanup; };
1203            }
1204        }
1205 
1206        client->timeout = timeout;
1207 
1208#if 0
1209	PKIX_CHECK(pkix_HttpCertStore_FindSocketConnectiondo { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, "variation.red.iplanet.com", 2001, &status, &
socket, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED; goto cleanup
; } } while (0)
1210                (timeout,do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, "variation.red.iplanet.com", 2001, &status, &
socket, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED; goto cleanup
; } } while (0)
1211                "variation.red.iplanet.com", /* (char *)client->host, */do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, "variation.red.iplanet.com", 2001, &status, &
socket, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED; goto cleanup
; } } while (0)
1212                2001,   /* client->portnum, */do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, "variation.red.iplanet.com", 2001, &status, &
socket, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED; goto cleanup
; } } while (0)
1213                &status,do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, "variation.red.iplanet.com", 2001, &status, &
socket, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED; goto cleanup
; } } while (0)
1214                &socket,do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, "variation.red.iplanet.com", 2001, &status, &
socket, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED; goto cleanup
; } } while (0)
1215                plCtx),do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, "variation.red.iplanet.com", 2001, &status, &
socket, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED; goto cleanup
; } } while (0)
1216		PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED)do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, "variation.red.iplanet.com", 2001, &status, &
socket, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED; goto cleanup
; } } while (0);
1217#else
1218	PKIX_CHECK(pkix_HttpCertStore_FindSocketConnectiondo { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, (char *)client->host, client->portnum, &
status, &socket, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED
; goto cleanup; } } while (0)
1219                (timeout,do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, (char *)client->host, client->portnum, &
status, &socket, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED
; goto cleanup; } } while (0)
1220                (char *)client->host,do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, (char *)client->host, client->portnum, &
status, &socket, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED
; goto cleanup; } } while (0)
1221                client->portnum,do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, (char *)client->host, client->portnum, &
status, &socket, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED
; goto cleanup; } } while (0)
1222                &status,do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, (char *)client->host, client->portnum, &
status, &socket, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED
; goto cleanup; } } while (0)
1223                &socket,do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, (char *)client->host, client->portnum, &
status, &socket, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED
; goto cleanup; } } while (0)
1224                plCtx),do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, (char *)client->host, client->portnum, &
status, &socket, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED
; goto cleanup; } } while (0)
1225		PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED)do { stdVars.aPkixErrorResult = (pkix_HttpCertStore_FindSocketConnection
 (timeout, (char *)client->host, client->portnum, &
status, &socket, plCtx)); if (stdVars.aPkixErrorResult) {
 stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED
; goto cleanup; } } while (0);
1226#endif
1227 
1228        client->socket = socket;
1229 
1230        PKIX_CHECK(pkix_pl_Socket_GetCallbackListdo { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetCallbackList
 (socket, &callbackList, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETCALLBACKLISTFAILED; goto
 cleanup; } } while (0)
1231                (socket, &callbackList, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetCallbackList
 (socket, &callbackList, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETCALLBACKLISTFAILED; goto
 cleanup; } } while (0)
1232                PKIX_SOCKETGETCALLBACKLISTFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetCallbackList
 (socket, &callbackList, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETCALLBACKLISTFAILED; goto
 cleanup; } } while (0);
1233 
1234        client->callbackList = (void *)callbackList;
1235 
1236        PKIX_CHECK(pkix_pl_Socket_GetPRFileDescdo { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetPRFileDesc
 (socket, &fileDesc, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETPRFILEDESCFAILED; goto
 cleanup; } } while (0)
1237                (socket, &fileDesc, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetPRFileDesc
 (socket, &fileDesc, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETPRFILEDESCFAILED; goto
 cleanup; } } while (0)
1238                PKIX_SOCKETGETPRFILEDESCFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_Socket_GetPRFileDesc
 (socket, &fileDesc, plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_SOCKETGETPRFILEDESCFAILED; goto
 cleanup; } } while (0);
1239 
1240        client->pollDesc.fd = fileDesc;
1241        client->pollDesc.in_flags = 0;
1242        client->pollDesc.out_flags = 0;
1243 
1244        client->send_http_data = NULL((void*)0);
1245        client->send_http_data_len = 0;
1246        client->send_http_content_type = NULL((void*)0);
1247 
1248        client->connectStatus =
1249                 ((status == 0) ? HTTP_CONNECTED : HTTP_CONNECT_PENDING);
1250 
1251        /* Request object is the same object as Session object */
1252        PKIX_INCREF(client)do { if (client){ stdVars.aPkixTempResult = PKIX_PL_Object_IncRef
 ((PKIX_PL_Object *)(client), plContext); if (stdVars.aPkixTempResult
) { PKIX_DoAddError(&stdVars, stdVars.aPkixTempResult, plContext
); stdVars.aPkixTempResult = ((void*)0); goto cleanup; } } } while
 (0);
1253        *pRequest = client;
1254 
1255cleanup:
1256 
1257        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1258 
1259}
1260 
1261PKIX_Error *
1262pkix_pl_HttpDefaultClient_SetPostData(
1263        SEC_HTTP_REQUEST_SESSION request,
1264        const char *http_data, 
1265        const PRUint32 http_data_len,
1266        const char *http_content_type,
1267        void *plCtx)
1268{
1269        PKIX_PL_HttpDefaultClient *client = NULL((void*)0);
1270 
1271        PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_SetPostData"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1272                (HTTPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_SetPostData"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1273                "pkix_pl_HttpDefaultClient_SetPostData")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_SetPostData"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1274        PKIX_NULLCHECK_ONE(request)do { if ((request) == ((void*)0)){ stdVars.aPkixErrorReceived
 = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1275 
1276        PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1277                ((PKIX_PL_Object *)request,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1278                PKIX_HTTPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1279                plCtx),do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1280                PKIX_REQUESTNOTANHTTPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0);
1281 
1282        client = (PKIX_PL_HttpDefaultClient *)request;
1283 
1284        client->send_http_data = http_data;
1285        client->send_http_data_len = http_data_len;
1286        client->send_http_content_type = http_content_type;
1287 
1288        /* Caller is allowed to give NULL or empty string for content_type */
1289        if ((client->send_http_content_type == NULL((void*)0)) ||
1290            (*(client->send_http_content_type) == '\0')) {
1291                client->send_http_content_type = "application/ocsp-request";
1292        }
1293 
1294cleanup:
1295 
1296        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1297 
1298}
1299 
1300PKIX_Error *
1301pkix_pl_HttpDefaultClient_TrySendAndReceive(
1302        SEC_HTTP_REQUEST_SESSION request,
1303        PRUint16 *http_response_code, 
1304        const char **http_response_content_type, 
1305        const char **http_response_headers, 
1306        const char **http_response_data, 
1307        PRUint32 *http_response_data_len, 
1308        PRPollDesc **pPollDesc,
1309        SECStatus *pSECReturn,
1310        void *plCtx)        
1311{
1312        PKIX_PL_HttpDefaultClient *client = NULL((void*)0);
1313        PKIX_UInt32 postLen = 0;
1314        PRPollDesc *pollDesc = NULL((void*)0);
1315        char *sendbuf = NULL((void*)0);
1316        char portstr[16];
1317 
1318        PKIX_ENTERstatic const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_TrySendAndReceive"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
3
←
Assuming 'pkixLoggersDebugTrace' is non-null→
4
←
Taking true branch→
5
←
Loop condition is false.  Exiting loop→
1319                (HTTPDEFAULTCLIENT,static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_TrySendAndReceive"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);
1320                "pkix_pl_HttpDefaultClient_TrySendAndReceive")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_TrySendAndReceive"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1321 
1322        PKIX_NULLCHECK_ONE(request)do { if ((request) == ((void*)0)){ stdVars.aPkixErrorReceived
 = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
6
←
Assuming 'request' is not equal to null→
7
←
Taking false branch→
8
←
Loop condition is false.  Exiting loop→
1323 
1324        PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
9
←
Assuming field 'aPkixErrorResult' is null→
10
←
Taking false branch→
11
←
Loop condition is false.  Exiting loop→
1325                ((PKIX_PL_Object *)request,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1326                PKIX_HTTPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1327                plCtx),do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1328                PKIX_REQUESTNOTANHTTPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0);
1329 
1330        client = (PKIX_PL_HttpDefaultClient *)request;
1331 
1332        if (!pPollDesc && client->timeout == 0) {
12
←
Assuming 'pPollDesc' is non-null→
1333            PKIX_ERROR_FATAL(PKIX_NULLARGUMENT){ stdVars.aPkixErrorReceived = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode
 = PKIX_NULLARGUMENT; stdVars.aPkixErrorClass = PKIX_FATAL_ERROR
; { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, stdVars.aPkixErrorCode, ((void*)0), stdVars.aPkixType, 1, plContext
); } }; goto cleanup; };
1334        }
1335 
1336        if (pPollDesc12.1
'pPollDesc' is non-null
) {
13
←
Taking true branch→
1337            pollDesc = *pPollDesc;
1338        }
1339 
1340        /* if not continuing from an earlier WOULDBLOCK return... */
1341        if (pollDesc == NULL((void*)0)) {
14
←
Assuming 'pollDesc' is equal to NULL→
1342 
1343                if (!((client->connectStatus == HTTP_CONNECTED) ||
15
←
Assuming field 'connectStatus' is equal to HTTP_CONNECTED→
16
←
Taking false branch→
1344                     (client->connectStatus == HTTP_CONNECT_PENDING))) {
1345                        PKIX_ERROR(PKIX_HTTPCLIENTININVALIDSTATE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_HTTPCLIENTININVALIDSTATE, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_HTTPCLIENTININVALIDSTATE;
 goto cleanup; };
1346                }
1347 
1348                /* Did caller provide a value for response length? */
1349                if (http_response_data_len != NULL((void*)0)) {
17
←
Assuming 'http_response_data_len' is equal to NULL→
18
←
Taking false branch→
1350                        client->pRcv_http_data_len = http_response_data_len;
1351                        client->maxResponseLen = *http_response_data_len;
1352                }
1353 
1354                client->rcv_http_response_code = http_response_code;
1355                client->rcv_http_content_type = http_response_content_type;
1356                client->rcv_http_headers = http_response_headers;
1357                client->rcv_http_data = http_response_data;
1358 
1359                /* prepare the message */
1360                portstr[0] = '\0';
1361                if (client->portnum != 80) {
19
←
Assuming field 'portnum' is equal to 80→
20
←
Taking false branch→
1362                        PR_snprintf(portstr, sizeof(portstr), ":%d", 
1363                                    client->portnum);
1364                }
1365                
1366                if (client->send_http_method == HTTP_POST_METHOD) {
21
←
Assuming field 'send_http_method' is not equal to HTTP_POST_METHOD→
22
←
Taking false branch→
1367                        sendbuf = PR_smprintf
1368                            ("POST %s HTTP/1.0\r\nHost: %s%s\r\n"
1369                            "Content-Type: %s\r\nContent-Length: %u\r\n\r\n",
1370                            client->path,
1371                            client->host,
1372                            portstr,
1373                            client->send_http_content_type,
1374                            client->send_http_data_len);
1375                        postLen = PORT_Strlen(sendbuf)strlen(sendbuf);
1376                            
1377                        client->POSTLen = postLen + client->send_http_data_len;
1378 
1379                        /* allocate postBuffer big enough for header + data */
1380                        PKIX_CHECK(PKIX_PL_Mallocdo { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (client->POSTLen
, (void **)&(client->POSTBuf), plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0)
1381                                (client->POSTLen,do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (client->POSTLen
, (void **)&(client->POSTBuf), plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0)
1382                                (void **)&(client->POSTBuf),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (client->POSTLen
, (void **)&(client->POSTBuf), plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0)
1383                                plCtx),do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (client->POSTLen
, (void **)&(client->POSTBuf), plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0)
1384                                PKIX_MALLOCFAILED)do { stdVars.aPkixErrorResult = (PKIX_PL_Malloc (client->POSTLen
, (void **)&(client->POSTBuf), plCtx)); if (stdVars.aPkixErrorResult
) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult->errClass
; stdVars.aPkixErrorCode = PKIX_MALLOCFAILED; goto cleanup; }
 } while (0);
1385 
1386                        /* copy header into postBuffer */
1387                        PORT_Memcpymemcpy(client->POSTBuf, sendbuf, postLen);
1388 
1389                        /* append data after header */
1390                        PORT_Memcpymemcpy(&client->POSTBuf[postLen],
1391                                    client->send_http_data,
1392                                    client->send_http_data_len);
1393 
1394                        /* PR_smprintf_free original header buffer */
1395                        PR_smprintf_free(sendbuf);
1396                        sendbuf = NULL((void*)0);
1397                        
1398                } else if (client->send_http_method == HTTP_GET_METHOD) {
23
←
Assuming field 'send_http_method' is not equal to HTTP_GET_METHOD→
24
←
Taking false branch→
1399                        client->GETBuf = PR_smprintf
1400                            ("GET %s HTTP/1.0\r\nHost: %s%s\r\n\r\n",
1401                            client->path,
1402                            client->host,
1403                            portstr);
1404                        client->GETLen = PORT_Strlen(client->GETBuf)strlen(client->GETBuf);
1405                }
1406 
1407        }
1408 
1409        /* continue according to state */
1410        PKIX_CHECK(pkix_pl_HttpDefaultClient_Dispatch(client, plCtx),do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_Dispatch
(client, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPDEFAULTCLIENTDISPATCHFAILED; goto cleanup; } } while
 (0)
25
←
Assuming field 'aPkixErrorResult' is null→
26
←
Taking false branch→
27
←
Loop condition is false.  Exiting loop→
1411                PKIX_HTTPDEFAULTCLIENTDISPATCHFAILED)do { stdVars.aPkixErrorResult = (pkix_pl_HttpDefaultClient_Dispatch
(client, plCtx)); if (stdVars.aPkixErrorResult) { stdVars.aPkixErrorClass
 = stdVars.aPkixErrorResult->errClass; stdVars.aPkixErrorCode
 = PKIX_HTTPDEFAULTCLIENTDISPATCHFAILED; goto cleanup; } } while
 (0);
1412 
1413        switch (client->connectStatus) {
28
←
Control jumps to 'case HTTP_COMPLETE:'  at line 1441→
1414                case HTTP_CONNECT_PENDING:
1415                case HTTP_SEND_PENDING:
1416                case HTTP_RECV_HDR_PENDING:
1417                case HTTP_RECV_BODY_PENDING:
1418                        pollDesc = &(client->pollDesc);
1419                        *pSECReturn = SECWouldBlock;
1420                        break;
1421                case HTTP_ERROR:
1422                        /* Did caller provide a pointer for length? */
1423                        if (client->pRcv_http_data_len != NULL((void*)0)) {
1424                                /* Was error "response too big?" */
1425                                if (client->rcv_http_data_len !=
1426                                            HTTP_UNKNOWN_CONTENT_LENGTH-1 &&
1427                                    client->maxResponseLen >=
1428                                                client->rcv_http_data_len) {
1429                                        /* Yes, report needed space */
1430                                        *(client->pRcv_http_data_len) =
1431                                                 client->rcv_http_data_len;
1432                                } else {
1433                                        /* No, report problem other than size */
1434                                        *(client->pRcv_http_data_len) = 0;
1435                                }
1436                        }
1437 
1438                        pollDesc = NULL((void*)0);
1439                        *pSECReturn = SECFailure;
1440                        break;
1441                case HTTP_COMPLETE:
1442                        *(client->rcv_http_response_code) =
1443                                client->responseCode;
1444                        if (client->pRcv_http_data_len != NULL((void*)0)) {
29
←
Assuming field 'pRcv_http_data_len' is not equal to NULL→
30
←
Taking true branch→
1445                                *http_response_data_len =
31
←
Dereference of null pointer (loaded from variable 'http_response_data_len')
1446                                         client->rcv_http_data_len;
1447                        }
1448                        if (client->rcv_http_data != NULL((void*)0)) {
1449                                *(client->rcv_http_data) = client->rcvBuf;
1450                        }
1451                        pollDesc = NULL((void*)0);
1452                        *pSECReturn = SECSuccess;
1453                        break;
1454                case HTTP_NOT_CONNECTED:
1455                case HTTP_CONNECTED:
1456                case HTTP_RECV_HDR:
1457                case HTTP_RECV_BODY:
1458                default:
1459                        pollDesc = NULL((void*)0);
1460                        *pSECReturn = SECFailure;
1461                        PKIX_ERROR(PKIX_HTTPCLIENTININVALIDSTATE){ { if (pkixLoggersErrors) { pkix_Logger_CheckWithCode(pkixLoggersErrors
, PKIX_HTTPCLIENTININVALIDSTATE, ((void*)0), stdVars.aPkixType
, 2, plContext); } } stdVars.aPkixErrorReceived = ((PKIX_Boolean
) 1); stdVars.aPkixErrorCode = PKIX_HTTPCLIENTININVALIDSTATE;
 goto cleanup; };
1462                        break;
1463        }
1464 
1465        if (pPollDesc) {
1466            *pPollDesc = pollDesc;
1467        }
1468 
1469cleanup:
1470        if (sendbuf) {
1471            PR_smprintf_free(sendbuf);
1472        }
1473 
1474        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1475 
1476}
1477 
1478PKIX_Error *
1479pkix_pl_HttpDefaultClient_Cancel(
1480        SEC_HTTP_REQUEST_SESSION request,
1481        void *plCtx)
1482{
1483        PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_Cancel")static const char cMyFuncName[] = {"pkix_pl_HttpDefaultClient_Cancel"
}; PKIX_StdVars stdVars = zeroStdVars; stdVars.aMyFuncName = cMyFuncName
; stdVars.aPkixType = PKIX_HTTPDEFAULTCLIENT_ERROR; ; do { if
 (pkixLoggersDebugTrace) { pkix_Logger_Check(pkixLoggersDebugTrace
, stdVars.aMyFuncName, ">>>", stdVars.aPkixType, 5, plContext
); } } while (0);;
1484        PKIX_NULLCHECK_ONE(request)do { if ((request) == ((void*)0)){ stdVars.aPkixErrorReceived
 = ((PKIX_Boolean) 1); stdVars.aPkixErrorCode = PKIX_NULLARGUMENT
; return PKIX_DoReturn(&stdVars, (PKIX_FATAL_ERROR), ((PKIX_Boolean
) 1), plContext);; } } while (0);
1485 
1486        PKIX_CHECK(pkix_CheckTypedo { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1487                ((PKIX_PL_Object *)request,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1488                PKIX_HTTPDEFAULTCLIENT_TYPE,do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1489                plCtx),do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0)
1490                PKIX_REQUESTNOTANHTTPDEFAULTCLIENT)do { stdVars.aPkixErrorResult = (pkix_CheckType ((PKIX_PL_Object
 *)request, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx)); if (stdVars
.aPkixErrorResult) { stdVars.aPkixErrorClass = stdVars.aPkixErrorResult
->errClass; stdVars.aPkixErrorCode = PKIX_REQUESTNOTANHTTPDEFAULTCLIENT
; goto cleanup; } } while (0);
1491 
1492        /* XXX Not implemented */
1493 
1494cleanup:
1495 
1496        PKIX_RETURN(HTTPDEFAULTCLIENT)return PKIX_DoReturn(&stdVars, (PKIX_HTTPDEFAULTCLIENT_ERROR
), ((PKIX_Boolean) 1), plContext);;
1497 
1498}
1499 
1500SECStatus
1501pkix_pl_HttpDefaultClient_CreateSessionFcn(
1502        const char *host,
1503        PRUint16 portnum,
1504        SEC_HTTP_SERVER_SESSION *pSession)
1505{
1506        PKIX_Error *err = pkix_pl_HttpDefaultClient_CreateSession
1507                (host, portnum, pSession, plContext);
1508 
1509        if (err) {
1510                PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
1511                return SECFailure;
1512        }
1513        return SECSuccess;
1514}
1515 
1516SECStatus
1517pkix_pl_HttpDefaultClient_KeepAliveSessionFcn(
1518        SEC_HTTP_SERVER_SESSION session,
1519        PRPollDesc **pPollDesc)
1520{
1521        PKIX_Error *err = pkix_pl_HttpDefaultClient_KeepAliveSession
1522                (session, pPollDesc, plContext);
1523 
1524        if (err) {
1525                PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
1526                return SECFailure;
1527        }
1528        return SECSuccess;
1529}
1530 
1531SECStatus
1532pkix_pl_HttpDefaultClient_FreeSessionFcn(
1533        SEC_HTTP_SERVER_SESSION session)
1534{
1535        PKIX_Error *err =
1536            PKIX_PL_Object_DecRef((PKIX_PL_Object *)(session), plContext);
1537 
1538        if (err) {
1539                PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
1540                return SECFailure;
1541        }
1542        return SECSuccess;
1543}
1544 
1545SECStatus
1546pkix_pl_HttpDefaultClient_RequestCreateFcn(
1547        SEC_HTTP_SERVER_SESSION session,
1548        const char *http_protocol_variant, /* usually "http" */
1549        const char *path_and_query_string,
1550        const char *http_request_method, 
1551        const PRIntervalTime timeout, 
1552        SEC_HTTP_REQUEST_SESSION *pRequest)
1553{
1554        PKIX_Error *err = pkix_pl_HttpDefaultClient_RequestCreate
1555                (session,
1556                http_protocol_variant,
1557                path_and_query_string,
1558                http_request_method,
1559                timeout,
1560                pRequest,
1561                plContext);
1562 
1563        if (err) {
1564                PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
1565                return SECFailure;
1566        }
1567        return SECSuccess;
1568}
1569 
1570SECStatus
1571pkix_pl_HttpDefaultClient_SetPostDataFcn(
1572        SEC_HTTP_REQUEST_SESSION request,
1573        const char *http_data, 
1574        const PRUint32 http_data_len,
1575        const char *http_content_type)
1576{
1577        PKIX_Error *err =
1578            pkix_pl_HttpDefaultClient_SetPostData(request, http_data,
1579                                                  http_data_len,
1580                                                  http_content_type,
1581                                                  plContext);
1582        if (err) {
1583                PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
1584                return SECFailure;
1585        }
1586        return SECSuccess;
1587}
1588 
1589SECStatus
1590pkix_pl_HttpDefaultClient_AddHeaderFcn(
1591        SEC_HTTP_REQUEST_SESSION request,
1592        const char *http_header_name, 
1593        const char *http_header_value)
1594{
1595        /* Not supported */
1596        return SECFailure;
1597}
1598 
1599SECStatus
1600pkix_pl_HttpDefaultClient_TrySendAndReceiveFcn(
1601        SEC_HTTP_REQUEST_SESSION request,
1602        PRPollDesc **pPollDesc,
1603        PRUint16 *http_response_code, 
1604        const char **http_response_content_type, 
1605        const char **http_response_headers, 
1606        const char **http_response_data, 
1607        PRUint32 *http_response_data_len) 
1608{
1609        SECStatus rv = SECFailure;
1610 
1611        PKIX_Error *err = pkix_pl_HttpDefaultClient_TrySendAndReceive
2
←
Calling 'pkix_pl_HttpDefaultClient_TrySendAndReceive'→
1612                (request,
1613                http_response_code, 
1614                http_response_content_type, 
1615                http_response_headers, 
1616                http_response_data, 
1617                http_response_data_len,
1
Passing value via 6th parameter 'http_response_data_len'→
1618                pPollDesc,
1619                &rv,
1620                plContext);
1621 
1622        if (err) {
1623                PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
1624                return rv;
1625        }
1626        return SECSuccess;
1627}
1628 
1629SECStatus
1630pkix_pl_HttpDefaultClient_CancelFcn(
1631        SEC_HTTP_REQUEST_SESSION request)
1632{
1633        PKIX_Error *err = pkix_pl_HttpDefaultClient_Cancel(request, plContext);
1634 
1635        if (err) {
1636                PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
1637                return SECFailure;
1638        }
1639        return SECSuccess;
1640}
1641 
1642SECStatus
1643pkix_pl_HttpDefaultClient_FreeFcn(
1644        SEC_HTTP_REQUEST_SESSION request)
1645{
1646        PKIX_Error *err =
1647            PKIX_PL_Object_DecRef((PKIX_PL_Object *)(request), plContext);
1648 
1649        if (err) {
1650                PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
1651                return SECFailure;
1652        }
1653        return SECSuccess;
1654}