Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
/*
* pkix_pl_httpdefaultclient.c
*
* HTTPDefaultClient Function Definitions
*
*/
#include "pkix_pl_httpdefaultclient.h"
static void *plContext = NULL;
/*
* The interface specification for an http client requires that it register
* a function table of type SEC_HttpClientFcn, which is defined as a union
* of tables, of which only version 1 is defined at present.
*
* Note: these functions violate the PKIX calling conventions, in that they
* return SECStatus rather than PKIX_Error*, and that they do not provide a
* plContext argument. They are implemented here as calls to PKIX functions,
* but the plContext value is circularly defined - a true kludge. Its value
* is saved at the time of the call to pkix_pl_HttpDefaultClient_Create for
* subsequent use, but since that initial call comes from the
* pkix_pl_HttpDefaultClient_CreateSessionFcn, it's not really getting saved.
*/
static SEC_HttpClientFcnV1 vtable = {
pkix_pl_HttpDefaultClient_CreateSessionFcn,
pkix_pl_HttpDefaultClient_KeepAliveSessionFcn,
pkix_pl_HttpDefaultClient_FreeSessionFcn,
pkix_pl_HttpDefaultClient_RequestCreateFcn,
pkix_pl_HttpDefaultClient_SetPostDataFcn,
pkix_pl_HttpDefaultClient_AddHeaderFcn,
pkix_pl_HttpDefaultClient_TrySendAndReceiveFcn,
pkix_pl_HttpDefaultClient_CancelFcn,
pkix_pl_HttpDefaultClient_FreeFcn
};
static SEC_HttpClientFcn httpClient;
static const char *eohMarker = "\r\n\r\n";
static const PKIX_UInt32 eohMarkLen = 4; /* strlen(eohMarker) */
static const char *crlf = "\r\n";
static const PKIX_UInt32 crlfLen = 2; /* strlen(crlf) */
static const char *httpprotocol = "HTTP/";
static const PKIX_UInt32 httpprotocolLen = 5; /* strlen(httpprotocol) */
#define HTTP_UNKNOWN_CONTENT_LENGTH -1
/* --Private-HttpDefaultClient-Functions------------------------- */
/*
* FUNCTION: pkix_pl_HttpDefaultClient_HdrCheckComplete
* DESCRIPTION:
*
* This function determines whether the headers in the current receive buffer
* in the HttpDefaultClient pointed to by "client" are complete. If so, the
* input data is checked for status code, content-type and content-length are
* extracted, and the client is set up to read the body of the response.
* Otherwise, the client is set up to continue reading header data.
*
* PARAMETERS:
* "client"
* The address of the HttpDefaultClient object. Must be non-NULL.
* "bytesRead"
* The UInt32 number of bytes received in the latest read.
* "pKeepGoing"
* The address at which the Boolean state machine flag is stored to
* indicate whether processing can continue without further input.
* Must be non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in a
* non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_HdrCheckComplete(
PKIX_PL_HttpDefaultClient *client,
PKIX_UInt32 bytesRead,
PKIX_Boolean *pKeepGoing,
void *plCtx)
{
PKIX_UInt32 alreadyScanned = 0;
PKIX_UInt32 comp = 0;
PKIX_UInt32 headerLength = 0;
PKIX_Int32 contentLength = HTTP_UNKNOWN_CONTENT_LENGTH;
char *eoh = NULL;
char *statusLineEnd = NULL;
char *space = NULL;
char *nextHeader = NULL;
const char *httpcode = NULL;
char *thisHeaderEnd = NULL;
char *value = NULL;
char *colon = NULL;
char *copy = NULL;
char *body = NULL;
PKIX_ENTER
(HTTPDEFAULTCLIENT,
"pkix_pl_HttpDefaultClient_HdrCheckComplete");
PKIX_NULLCHECK_TWO(client, pKeepGoing);
*pKeepGoing = PKIX_FALSE;
/* Does buffer contain end-of-header marker? */
/* Copy number of scanned bytes into a variable. */
alreadyScanned = client->filledupBytes;
/*
* If this is the initial buffer, we have to scan from the beginning.
* If we scanned, failed to find eohMarker, and read some more, we
* only have to scan from where we left off.
*/
if (alreadyScanned > eohMarkLen) {
/* Back up and restart scanning over a few bytes that were
* scanned before */
PKIX_UInt32 searchStartPos = alreadyScanned - eohMarkLen;
eoh = PL_strnstr(&(client->rcvBuf[searchStartPos]), eohMarker,
bytesRead + searchStartPos);
} else {
/* A search from the beginning of the buffer. */
eoh = PL_strnstr(client->rcvBuf, eohMarker, bytesRead);
}
client->filledupBytes += bytesRead;
if (eoh == NULL) { /* did we see end-of-header? */
/* No. Continue to read header data */
client->connectStatus = HTTP_RECV_HDR;
*pKeepGoing = PKIX_TRUE;
goto cleanup;
}
/* Yes. Calculate how many bytes in header (not counting eohMarker) */
headerLength = (eoh - client->rcvBuf);
/* allocate space to copy header (and for the NULL terminator) */
PKIX_CHECK(PKIX_PL_Malloc(headerLength + 1, (void **)©, plCtx),
PKIX_MALLOCFAILED);
/* copy header data before we corrupt it (by storing NULLs) */
PORT_Memcpy(copy, client->rcvBuf, headerLength);
/* Store the NULL terminator */
copy[headerLength] = '\0';
client->rcvHeaders = copy;
/* Did caller want a pointer to header? */
if (client->rcv_http_headers != NULL) {
/* store pointer for caller */
*(client->rcv_http_headers) = copy;
}
/* Check that message status is okay. */
statusLineEnd = PL_strnstr(client->rcvBuf, crlf, client->capacity);
if (statusLineEnd == NULL) {
client->connectStatus = HTTP_ERROR;
PORT_SetError(SEC_ERROR_OCSP_BAD_HTTP_RESPONSE);
goto cleanup;
}
*statusLineEnd = '\0';
space = strchr((const char *)client->rcvBuf, ' ');
if (space == NULL) {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
comp = PORT_Strncasecmp((const char *)client->rcvBuf, httpprotocol,
httpprotocolLen);
if (comp != 0) {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
httpcode = space + 1;
space = strchr(httpcode, ' ');
if (space == NULL) {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
*space = '\0';
client->responseCode = atoi(httpcode);
if (client->responseCode != 200) {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
/* Find the content-type and content-length */
nextHeader = statusLineEnd + crlfLen;
*eoh = '\0';
do {
thisHeaderEnd = NULL;
value = NULL;
colon = strchr(nextHeader, ':');
if (colon == NULL) {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
*colon = '\0';
value = colon + 1;
if (*value != ' ') {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
value++;
thisHeaderEnd = strstr(value, crlf);
if (thisHeaderEnd != NULL) {
*thisHeaderEnd = '\0';
}
comp = PORT_Strcasecmp(nextHeader, "content-type");
if (comp == 0) {
client->rcvContentType = PORT_Strdup(value);
} else {
comp = PORT_Strcasecmp(nextHeader, "content-length");
if (comp == 0) {
contentLength = atoi(value);
}
}
if (thisHeaderEnd != NULL) {
nextHeader = thisHeaderEnd + crlfLen;
} else {
nextHeader = NULL;
}
} while ((nextHeader != NULL) && (nextHeader < (eoh + crlfLen)));
/* Did caller provide a pointer to return content-type? */
if (client->rcv_http_content_type != NULL) {
*(client->rcv_http_content_type) = client->rcvContentType;
}
if (client->rcvContentType == NULL) {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
/* How many bytes remain in current buffer, beyond the header? */
headerLength += eohMarkLen;
client->filledupBytes -= headerLength;
/*
* The headers have passed validation. Now figure out whether the
* message is within the caller's size limit (if one was specified).
*/
switch (contentLength) {
case 0:
client->rcv_http_data_len = 0;
client->connectStatus = HTTP_COMPLETE;
*pKeepGoing = PKIX_FALSE;
break;
case HTTP_UNKNOWN_CONTENT_LENGTH:
/* Unknown contentLength indicator.Will be set by
* pkix_pl_HttpDefaultClient_RecvBody whey connection get closed */
client->rcv_http_data_len = HTTP_UNKNOWN_CONTENT_LENGTH;
contentLength = /* Try to reserve 4K+ buffer */
client->filledupBytes + HTTP_DATA_BUFSIZE;
if (client->maxResponseLen > 0 &&
contentLength > (PKIX_Int32)client->maxResponseLen) {
if (client->filledupBytes < client->maxResponseLen) {
contentLength = client->maxResponseLen;
} else {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
}
/* set available number of bytes in the buffer */
client->capacity = contentLength;
client->connectStatus = HTTP_RECV_BODY;
*pKeepGoing = PKIX_TRUE;
break;
default:
client->rcv_http_data_len = contentLength;
if (client->maxResponseLen > 0 &&
(PKIX_Int32)client->maxResponseLen < contentLength) {
client->connectStatus = HTTP_ERROR;
goto cleanup;
}
/*
* Do we have all of the message body, or do we need to read some more?
*/
if ((PKIX_Int32)client->filledupBytes < contentLength) {
client->connectStatus = HTTP_RECV_BODY;
*pKeepGoing = PKIX_TRUE;
} else {
client->connectStatus = HTTP_COMPLETE;
*pKeepGoing = PKIX_FALSE;
}
}
if (contentLength > 0) {
/* allocate a buffer of size contentLength for the content */
PKIX_CHECK(PKIX_PL_Malloc(contentLength, (void **)&body, plCtx),
PKIX_MALLOCFAILED);
/* copy any remaining bytes in current buffer into new buffer */
if (client->filledupBytes > 0) {
PORT_Memcpy(body, &(client->rcvBuf[headerLength]),
client->filledupBytes);
}
}
PKIX_CHECK(PKIX_PL_Free(client->rcvBuf, plCtx),
PKIX_FREEFAILED);
client->rcvBuf = body;
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: PKIX_PL_HttpDefaultClient_Create
* DESCRIPTION:
*
* This function creates a new HttpDefaultClient, and stores the result at
* "pClient".
*
* The HttpClient API does not include a plContext argument in its
* function calls. Its value at the time of this Create call must be the
* same as when the client is invoked.
*
* PARAMETERS:
* "host"
* The name of the server with which we hope to exchange messages. Must
* be non-NULL.
* "portnum"
* The port number to be used for our connection to the server.
* "pClient"
* The address at which the created HttpDefaultClient is to be stored.
* Must be non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in
* a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_Create(
const char *host,
PRUint16 portnum,
PKIX_PL_HttpDefaultClient **pClient,
void *plCtx)
{
PKIX_PL_HttpDefaultClient *client = NULL;
PKIX_ENTER(HTTPDEFAULTCLIENT, "PKIX_PL_HttpDefaultClient_Create");
PKIX_NULLCHECK_TWO(pClient, host);
/* allocate an HttpDefaultClient */
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_HTTPDEFAULTCLIENT_TYPE,
sizeof (PKIX_PL_HttpDefaultClient),
(PKIX_PL_Object **)&client,
plCtx),
PKIX_COULDNOTCREATEHTTPDEFAULTCLIENTOBJECT);
/* Client timeout is overwritten in HttpDefaultClient_RequestCreate
* function. Default value will be ignored. */
client->timeout = 0;
client->connectStatus = HTTP_NOT_CONNECTED;
client->portnum = portnum;
client->bytesToWrite = 0;
client->send_http_data_len = 0;
client->rcv_http_data_len = 0;
client->capacity = 0;
client->filledupBytes = 0;
client->responseCode = 0;
client->maxResponseLen = 0;
client->GETLen = 0;
client->POSTLen = 0;
client->pRcv_http_data_len = NULL;
client->callbackList = NULL;
client->GETBuf = NULL;
client->POSTBuf = NULL;
client->rcvBuf = NULL;
/* "host" is a parsing result by CERT_GetURL function that adds
* "end of line" to the value. OK to dup the string. */
client->host = PORT_Strdup(host);
if (!client->host) {
PKIX_ERROR(PKIX_ALLOCERROR);
}
client->path = NULL;
client->rcvContentType = NULL;
client->rcvHeaders = NULL;
client->send_http_method = HTTP_POST_METHOD;
client->send_http_content_type = NULL;
client->send_http_data = NULL;
client->rcv_http_response_code = NULL;
client->rcv_http_content_type = NULL;
client->rcv_http_headers = NULL;
client->rcv_http_data = NULL;
client->socket = NULL;
/*
* The HttpClient API does not include a plCtx argument in its
* function calls. Save it here.
*/
client->plContext = plCtx;
*pClient = client;
cleanup:
if (PKIX_ERROR_RECEIVED) {
PKIX_DECREF(client);
}
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: pkix_pl_HttpDefaultClient_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_Destroy(
PKIX_PL_Object *object,
void *plCtx)
{
PKIX_PL_HttpDefaultClient *client = NULL;
PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_Destroy");
PKIX_NULLCHECK_ONE(object);
PKIX_CHECK(pkix_CheckType
(object, PKIX_HTTPDEFAULTCLIENT_TYPE, plCtx),
PKIX_OBJECTNOTANHTTPDEFAULTCLIENT);
client = (PKIX_PL_HttpDefaultClient *)object;
if (client->rcvHeaders) {
PKIX_PL_Free(client->rcvHeaders, plCtx);
client->rcvHeaders = NULL;
}
if (client->rcvContentType) {
PORT_Free(client->rcvContentType);
client->rcvContentType = NULL;
}
if (client->GETBuf != NULL) {
PR_smprintf_free(client->GETBuf);
client->GETBuf = NULL;
}
if (client->POSTBuf != NULL) {
PKIX_PL_Free(client->POSTBuf, plCtx);
client->POSTBuf = NULL;
}
if (client->rcvBuf != NULL) {
PKIX_PL_Free(client->rcvBuf, plCtx);
client->rcvBuf = NULL;
}
if (client->host) {
PORT_Free(client->host);
client->host = NULL;
}
if (client->path) {
PORT_Free(client->path);
client->path = NULL;
}
PKIX_DECREF(client->socket);
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: pkix_pl_HttpDefaultClient_RegisterSelf
*
* DESCRIPTION:
* Registers PKIX_PL_HTTPDEFAULTCLIENT_TYPE and its related
* functions with systemClasses[]
*
* THREAD SAFETY:
* Not Thread Safe - for performance and complexity reasons
*
* Since this function is only called by PKIX_PL_Initialize, which should
* only be called once, it is acceptable that this function is not
* thread-safe.
*/
PKIX_Error *
pkix_pl_HttpDefaultClient_RegisterSelf(void *plCtx)
{
extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
pkix_ClassTable_Entry *entry =
&systemClasses[PKIX_HTTPDEFAULTCLIENT_TYPE];
PKIX_ENTER(HTTPDEFAULTCLIENT,
"pkix_pl_HttpDefaultClient_RegisterSelf");
entry->description = "HttpDefaultClient";
entry->typeObjectSize = sizeof(PKIX_PL_HttpDefaultClient);
entry->destructor = pkix_pl_HttpDefaultClient_Destroy;
httpClient.version = 1;
httpClient.fcnTable.ftable1 = vtable;
(void)SEC_RegisterDefaultHttpClient(&httpClient);
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/* --Private-HttpDefaultClient-I/O-Functions---------------------------- */
/*
* FUNCTION: pkix_pl_HttpDefaultClient_ConnectContinue
* DESCRIPTION:
*
* This function determines whether a socket Connect initiated earlier for the
* HttpDefaultClient "client" has completed, and stores in "pKeepGoing" a flag
* indicating whether processing can continue without further input.
*
* PARAMETERS:
* "client"
* The address of the HttpDefaultClient object. Must be non-NULL.
* "pKeepGoing"
* The address at which the Boolean state machine flag is stored to
* indicate whether processing can continue without further input.
* Must be non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in a
* non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_ConnectContinue(
PKIX_PL_HttpDefaultClient *client,
PKIX_Boolean *pKeepGoing,
void *plCtx)
{
PRErrorCode status;
PKIX_Boolean keepGoing = PKIX_FALSE;
PKIX_PL_Socket_Callback *callbackList = NULL;
PKIX_ENTER
(HTTPDEFAULTCLIENT,
"pkix_pl_HttpDefaultClient_ConnectContinue");
PKIX_NULLCHECK_ONE(client);
callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
PKIX_CHECK(callbackList->connectcontinueCallback
(client->socket, &status, plCtx),
PKIX_SOCKETCONNECTCONTINUEFAILED);
if (status == 0) {
client->connectStatus = HTTP_CONNECTED;
keepGoing = PKIX_TRUE;
} else if (status != PR_IN_PROGRESS_ERROR) {
PKIX_ERROR(PKIX_UNEXPECTEDERRORINESTABLISHINGCONNECTION);
}
*pKeepGoing = keepGoing;
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: pkix_pl_HttpDefaultClient_Send
* DESCRIPTION:
*
* This function creates and sends HTTP-protocol headers and, if applicable,
* data, for the HttpDefaultClient "client", and stores in "pKeepGoing" a flag
* indicating whether processing can continue without further input, and at
* "pBytesTransferred" the number of bytes sent.
*
* If "pBytesTransferred" is zero, it indicates that non-blocking I/O is in use
* and that transmission has not completed.
*
* PARAMETERS:
* "client"
* The address of the HttpDefaultClient object. Must be non-NULL.
* "pKeepGoing"
* The address at which the Boolean state machine flag is stored to
* indicate whether processing can continue without further input.
* Must be non-NULL.
* "pBytesTransferred"
* The address at which the number of bytes sent is stored. Must be
* non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in a
* non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_Send(
PKIX_PL_HttpDefaultClient *client,
PKIX_Boolean *pKeepGoing,
PKIX_UInt32 *pBytesTransferred,
void *plCtx)
{
PKIX_Int32 bytesWritten = 0;
PKIX_Int32 lenToWrite = 0;
PKIX_PL_Socket_Callback *callbackList = NULL;
char *dataToWrite = NULL;
PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_Send");
PKIX_NULLCHECK_THREE(client, pKeepGoing, pBytesTransferred);
*pKeepGoing = PKIX_FALSE;
/* Do we have anything waiting to go? */
if ((client->GETBuf) || (client->POSTBuf)) {
if (client->GETBuf) {
dataToWrite = client->GETBuf;
lenToWrite = client->GETLen;
} else {
dataToWrite = client->POSTBuf;
lenToWrite = client->POSTLen;
}
callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
PKIX_CHECK(callbackList->sendCallback
(client->socket,
dataToWrite,
lenToWrite,
&bytesWritten,
plCtx),
PKIX_SOCKETSENDFAILED);
client->rcvBuf = NULL;
client->capacity = 0;
client->filledupBytes = 0;
/*
* If the send completed we can proceed to try for the
* response. If the send did not complete we will have
* to poll for completion later.
*/
if (bytesWritten >= 0) {
client->connectStatus = HTTP_RECV_HDR;
*pKeepGoing = PKIX_TRUE;
} else {
client->connectStatus = HTTP_SEND_PENDING;
*pKeepGoing = PKIX_FALSE;
}
}
*pBytesTransferred = bytesWritten;
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: pkix_pl_HttpDefaultClient_SendContinue
* DESCRIPTION:
*
* This function determines whether the sending of the HTTP message for the
* HttpDefaultClient "client" has completed, and stores in "pKeepGoing" a
* flag indicating whether processing can continue without further input, and
* at "pBytesTransferred" the number of bytes sent.
*
* If "pBytesTransferred" is zero, it indicates that non-blocking I/O is in use
* and that transmission has not completed.
*
* PARAMETERS:
* "client"
* The address of the HttpDefaultClient object. Must be non-NULL.
* "pKeepGoing"
* The address at which the Boolean state machine flag is stored to
* indicate whether processing can continue without further input.
* Must be non-NULL.
* "pBytesTransferred"
* The address at which the number of bytes sent is stored. Must be
* non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in a
* non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_SendContinue(
PKIX_PL_HttpDefaultClient *client,
PKIX_Boolean *pKeepGoing,
PKIX_UInt32 *pBytesTransferred,
void *plCtx)
{
PKIX_Int32 bytesWritten = 0;
PKIX_PL_Socket_Callback *callbackList = NULL;
PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_SendContinue");
PKIX_NULLCHECK_THREE(client, pKeepGoing, pBytesTransferred);
*pKeepGoing = PKIX_FALSE;
callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
PKIX_CHECK(callbackList->pollCallback
(client->socket, &bytesWritten, NULL, plCtx),
PKIX_SOCKETPOLLFAILED);
/*
* If the send completed we can proceed to try for the
* response. If the send did not complete we will have
* continue to poll.
*/
if (bytesWritten >= 0) {
client->connectStatus = HTTP_RECV_HDR;
*pKeepGoing = PKIX_TRUE;
}
*pBytesTransferred = bytesWritten;
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: pkix_pl_HttpDefaultClient_RecvHdr
* DESCRIPTION:
*
* This function receives HTTP headers for the HttpDefaultClient "client", and
* stores in "pKeepGoing" a flag indicating whether processing can continue
* without further input.
*
* PARAMETERS:
* "client"
* The address of the HttpDefaultClient object. Must be non-NULL.
* "pKeepGoing"
* The address at which the Boolean state machine flag is stored to
* indicate whether processing can continue without further input.
* Must be non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in a
* non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_RecvHdr(
PKIX_PL_HttpDefaultClient *client,
PKIX_Boolean *pKeepGoing,
void *plCtx)
{
PKIX_UInt32 bytesToRead = 0;
PKIX_Int32 bytesRead = 0;
PKIX_PL_Socket_Callback *callbackList = NULL;
PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_RecvHdr");
PKIX_NULLCHECK_TWO(client, pKeepGoing);
/*
* rcvbuf, capacity, and filledupBytes were
* initialized when we wrote the headers. We begin by reading
* HTTP_HEADER_BUFSIZE bytes, repeatedly increasing the buffersize and
* reading again if necessary, until we have read the end-of-header
* marker, "\r\n\r\n", or have reached our maximum.
*/
client->capacity += HTTP_HEADER_BUFSIZE;
PKIX_CHECK(PKIX_PL_Realloc
(client->rcvBuf,
client->capacity,
(void **)&(client->rcvBuf),
plCtx),
PKIX_REALLOCFAILED);
bytesToRead = client->capacity - client->filledupBytes;
callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
PKIX_CHECK(callbackList->recvCallback
(client->socket,
(void *)&(client->rcvBuf[client->filledupBytes]),
bytesToRead,
&bytesRead,
plCtx),
PKIX_SOCKETRECVFAILED);
if (bytesRead > 0) {
/* client->filledupBytes will be adjusted by
* pkix_pl_HttpDefaultClient_HdrCheckComplete */
PKIX_CHECK(
pkix_pl_HttpDefaultClient_HdrCheckComplete(client, bytesRead,
pKeepGoing,
plCtx),
PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED);
} else {
client->connectStatus = HTTP_RECV_HDR_PENDING;
*pKeepGoing = PKIX_FALSE;
}
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: pkix_pl_HttpDefaultClient_RecvHdrContinue
* DESCRIPTION:
*
* This function determines whether the receiving of the HTTP headers for the
* HttpDefaultClient "client" has completed, and stores in "pKeepGoing" a flag
* indicating whether processing can continue without further input.
*
* PARAMETERS:
* "client"
* The address of the HttpDefaultClient object. Must be non-NULL.
* "pKeepGoing"
* The address at which the Boolean state machine flag is stored to
* indicate whether processing can continue without further input.
* Must be non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in a
* non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_RecvHdrContinue(
PKIX_PL_HttpDefaultClient *client,
PKIX_Boolean *pKeepGoing,
void *plCtx)
{
PKIX_Int32 bytesRead = 0;
PKIX_PL_Socket_Callback *callbackList = NULL;
PKIX_ENTER
(HTTPDEFAULTCLIENT,
"pkix_pl_HttpDefaultClient_RecvHdrContinue");
PKIX_NULLCHECK_TWO(client, pKeepGoing);
callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
PKIX_CHECK(callbackList->pollCallback
(client->socket, NULL, &bytesRead, plCtx),
PKIX_SOCKETPOLLFAILED);
if (bytesRead > 0) {
client->filledupBytes += bytesRead;
PKIX_CHECK(pkix_pl_HttpDefaultClient_HdrCheckComplete
(client, bytesRead, pKeepGoing, plCtx),
PKIX_HTTPDEFAULTCLIENTHDRCHECKCOMPLETEFAILED);
} else {
*pKeepGoing = PKIX_FALSE;
}
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: pkix_pl_HttpDefaultClient_RecvBody
* DESCRIPTION:
*
* This function processes the contents of the first buffer of a received
* HTTP-protocol message for the HttpDefaultClient "client", and stores in
* "pKeepGoing" a flag indicating whether processing can continue without
* further input.
*
* PARAMETERS:
* "client"
* The address of the HttpDefaultClient object. Must be non-NULL.
* "pKeepGoing"
* The address at which the Boolean state machine flag is stored to
* indicate whether processing can continue without further input.
* Must be non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in a
* non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_RecvBody(
PKIX_PL_HttpDefaultClient *client,
PKIX_Boolean *pKeepGoing,
void *plCtx)
{
PKIX_Int32 bytesRead = 0;
PKIX_Int32 bytesToRead = 0;
PKIX_PL_Socket_Callback *callbackList = NULL;
PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_RecvBody");
PKIX_NULLCHECK_TWO(client, pKeepGoing);
callbackList = (PKIX_PL_Socket_Callback *)client->callbackList;
if (client->rcv_http_data_len != HTTP_UNKNOWN_CONTENT_LENGTH) {
bytesToRead = client->rcv_http_data_len -
client->filledupBytes;
} else {
/* Reading till the EOF. Context length is not known.*/
/* Check the buffer capacity: increase and
* reallocate if it is low. */
int freeBuffSize = client->capacity - client->filledupBytes;
if (freeBuffSize < HTTP_MIN_AVAILABLE_BUFFER_SIZE) {
/* New length will be consist of available(downloaded) bytes,
* plus remaining capacity, plus new expansion. */
int currBuffSize = client->capacity;
/* Try to increase the buffer by 4K */
unsigned int newLength = currBuffSize + HTTP_DATA_BUFSIZE;
if (client->maxResponseLen > 0 &&
newLength > client->maxResponseLen) {
newLength = client->maxResponseLen;
}
/* Check if we can grow the buffer and report an error if
* new size is not larger than the current size of the buffer.*/
if (newLength <= client->filledupBytes) {
client->rcv_http_data_len = client->filledupBytes;
client->connectStatus = HTTP_ERROR;
*pKeepGoing = PKIX_FALSE;
goto cleanup;
}
if (client->capacity < newLength) {
client->capacity = newLength;
PKIX_CHECK(
PKIX_PL_Realloc(client->rcvBuf, newLength,
(void**)&client->rcvBuf, plCtx),
PKIX_REALLOCFAILED);
freeBuffSize = client->capacity -
client->filledupBytes;
}
}
bytesToRead = freeBuffSize;
}
/* Use poll callback if waiting on non-blocking IO */
if (client->connectStatus == HTTP_RECV_BODY_PENDING) {
PKIX_CHECK(callbackList->pollCallback
(client->socket, NULL, &bytesRead, plCtx),
PKIX_SOCKETPOLLFAILED);
} else {
PKIX_CHECK(callbackList->recvCallback
(client->socket,
(void *)&(client->rcvBuf[client->filledupBytes]),
bytesToRead,
&bytesRead,
plCtx),
PKIX_SOCKETRECVFAILED);
}
/* If bytesRead < 0, an error will be thrown by recvCallback, so
* need to handle >= 0 cases. */
/* bytesRead == 0 - IO was blocked. */
if (bytesRead == 0) {
client->connectStatus = HTTP_RECV_BODY_PENDING;
*pKeepGoing = PKIX_TRUE;
goto cleanup;
}
/* We got something. Did we get it all? */
client->filledupBytes += bytesRead;
/* continue if not enough bytes read or if complete size of
* transfer is unknown */
if (bytesToRead > bytesRead ||
client->rcv_http_data_len == HTTP_UNKNOWN_CONTENT_LENGTH) {
*pKeepGoing = PKIX_TRUE;
goto cleanup;
}
client->connectStatus = HTTP_COMPLETE;
*pKeepGoing = PKIX_FALSE;
cleanup:
if (pkixErrorResult && pkixErrorResult->errCode ==
PKIX_PRRECVREPORTSNETWORKCONNECTIONCLOSED) {
if (client->rcv_http_data_len == HTTP_UNKNOWN_CONTENT_LENGTH) {
client->rcv_http_data_len = client->filledupBytes;
client->connectStatus = HTTP_COMPLETE;
*pKeepGoing = PKIX_FALSE;
PKIX_DECREF(pkixErrorResult);
} else {
client->connectStatus = HTTP_ERROR;
}
}
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* FUNCTION: pkix_pl_HttpDefaultClient_Dispatch
* DESCRIPTION:
*
* This function is the state machine dispatcher for the HttpDefaultClient
* pointed to by "client". Results are returned by changes to various fields
* in the context.
*
* PARAMETERS:
* "client"
* The address of the HttpDefaultClient object. Must be non-NULL.
* "plCtx"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HttpDefaultClient Error if the function fails in a
* non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_HttpDefaultClient_Dispatch(
PKIX_PL_HttpDefaultClient *client,
void *plCtx)
{
PKIX_UInt32 bytesTransferred = 0;
PKIX_Boolean keepGoing = PKIX_TRUE;
PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_Dispatch");
PKIX_NULLCHECK_ONE(client);
while (keepGoing) {
switch (client->connectStatus) {
case HTTP_CONNECT_PENDING:
PKIX_CHECK(pkix_pl_HttpDefaultClient_ConnectContinue
(client, &keepGoing, plCtx),
PKIX_HTTPDEFAULTCLIENTCONNECTCONTINUEFAILED);
break;
case HTTP_CONNECTED:
PKIX_CHECK(pkix_pl_HttpDefaultClient_Send
(client, &keepGoing, &bytesTransferred, plCtx),
PKIX_HTTPDEFAULTCLIENTSENDFAILED);
break;
case HTTP_SEND_PENDING:
PKIX_CHECK(pkix_pl_HttpDefaultClient_SendContinue
(client, &keepGoing, &bytesTransferred, plCtx),
PKIX_HTTPDEFAULTCLIENTSENDCONTINUEFAILED);
break;
case HTTP_RECV_HDR:
PKIX_CHECK(pkix_pl_HttpDefaultClient_RecvHdr
(client, &keepGoing, plCtx),
PKIX_HTTPDEFAULTCLIENTRECVHDRFAILED);
break;
case HTTP_RECV_HDR_PENDING:
PKIX_CHECK(pkix_pl_HttpDefaultClient_RecvHdrContinue
(client, &keepGoing, plCtx),
PKIX_HTTPDEFAULTCLIENTRECVHDRCONTINUEFAILED);
break;
case HTTP_RECV_BODY:
case HTTP_RECV_BODY_PENDING:
PKIX_CHECK(pkix_pl_HttpDefaultClient_RecvBody
(client, &keepGoing, plCtx),
PKIX_HTTPDEFAULTCLIENTRECVBODYFAILED);
break;
case HTTP_ERROR:
case HTTP_COMPLETE:
keepGoing = PKIX_FALSE;
break;
case HTTP_NOT_CONNECTED:
default:
PKIX_ERROR(PKIX_HTTPDEFAULTCLIENTINILLEGALSTATE);
}
}
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
/*
* --HttpClient vtable functions
* See comments in ocspt.h for the function (wrappers) that return SECStatus.
* The functions that return PKIX_Error* are the libpkix implementations.
*/
PKIX_Error *
pkix_pl_HttpDefaultClient_CreateSession(
const char *host,
PRUint16 portnum,
SEC_HTTP_SERVER_SESSION *pSession,
void *plCtx)
{
PKIX_PL_HttpDefaultClient *client = NULL;
PKIX_ENTER
(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_CreateSession");
PKIX_NULLCHECK_TWO(host, pSession);
PKIX_CHECK(pkix_pl_HttpDefaultClient_Create
(host, portnum, &client, plCtx),
PKIX_HTTPDEFAULTCLIENTCREATEFAILED);
*pSession = (SEC_HTTP_SERVER_SESSION)client;
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
PKIX_Error *
pkix_pl_HttpDefaultClient_KeepAliveSession(
SEC_HTTP_SERVER_SESSION session,
PRPollDesc **pPollDesc,
void *plCtx)
{
PKIX_ENTER
(HTTPDEFAULTCLIENT,
"pkix_pl_HttpDefaultClient_KeepAliveSession");
PKIX_NULLCHECK_TWO(session, pPollDesc);
PKIX_CHECK(pkix_CheckType
((PKIX_PL_Object *)session,
PKIX_HTTPDEFAULTCLIENT_TYPE,
plCtx),
PKIX_SESSIONNOTANHTTPDEFAULTCLIENT);
/* XXX Not implemented */
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
PKIX_Error *
pkix_pl_HttpDefaultClient_RequestCreate(
SEC_HTTP_SERVER_SESSION session,
const char *http_protocol_variant, /* usually "http" */
const char *path_and_query_string,
const char *http_request_method,
const PRIntervalTime timeout,
SEC_HTTP_REQUEST_SESSION *pRequest,
void *plCtx)
{
PKIX_PL_HttpDefaultClient *client = NULL;
PKIX_PL_Socket *socket = NULL;
PKIX_PL_Socket_Callback *callbackList = NULL;
PRFileDesc *fileDesc = NULL;
PRErrorCode status = 0;
PKIX_ENTER
(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_RequestCreate");
PKIX_NULLCHECK_TWO(session, pRequest);
PKIX_CHECK(pkix_CheckType
((PKIX_PL_Object *)session,
PKIX_HTTPDEFAULTCLIENT_TYPE,
plCtx),
PKIX_SESSIONNOTANHTTPDEFAULTCLIENT);
client = (PKIX_PL_HttpDefaultClient *)session;
/* We only know how to do http */
if (PORT_Strncasecmp(http_protocol_variant, "http", 4) != 0) {
PKIX_ERROR(PKIX_UNRECOGNIZEDPROTOCOLREQUESTED);
}
if (PORT_Strncasecmp(http_request_method, "POST", 4) == 0) {
client->send_http_method = HTTP_POST_METHOD;
} else if (PORT_Strncasecmp(http_request_method, "GET", 3) == 0) {
client->send_http_method = HTTP_GET_METHOD;
} else {
/* We only know how to do POST and GET */
PKIX_ERROR(PKIX_UNRECOGNIZEDREQUESTMETHOD);
}
if (path_and_query_string) {
/* "path_and_query_string" is a parsing result by CERT_GetURL
* function that adds "end of line" to the value. OK to dup
* the string. */
client->path = PORT_Strdup(path_and_query_string);
if (!client->path) {
PKIX_ERROR(PKIX_ALLOCERROR);
}
}
client->timeout = timeout;
#if 0
PKIX_CHECK(pkix_HttpCertStore_FindSocketConnection
(timeout,
"variation.red.iplanet.com", /* (char *)client->host, */
2001, /* client->portnum, */
&status,
&socket,
plCtx),
PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED);
#else
PKIX_CHECK(pkix_HttpCertStore_FindSocketConnection
(timeout,
(char *)client->host,
client->portnum,
&status,
&socket,
plCtx),
PKIX_HTTPCERTSTOREFINDSOCKETCONNECTIONFAILED);
#endif
client->socket = socket;
PKIX_CHECK(pkix_pl_Socket_GetCallbackList
(socket, &callbackList, plCtx),
PKIX_SOCKETGETCALLBACKLISTFAILED);
client->callbackList = (void *)callbackList;
PKIX_CHECK(pkix_pl_Socket_GetPRFileDesc
(socket, &fileDesc, plCtx),
PKIX_SOCKETGETPRFILEDESCFAILED);
client->pollDesc.fd = fileDesc;
client->pollDesc.in_flags = 0;
client->pollDesc.out_flags = 0;
client->send_http_data = NULL;
client->send_http_data_len = 0;
client->send_http_content_type = NULL;
client->connectStatus =
((status == 0) ? HTTP_CONNECTED : HTTP_CONNECT_PENDING);
/* Request object is the same object as Session object */
PKIX_INCREF(client);
*pRequest = client;
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
PKIX_Error *
pkix_pl_HttpDefaultClient_SetPostData(
SEC_HTTP_REQUEST_SESSION request,
const char *http_data,
const PRUint32 http_data_len,
const char *http_content_type,
void *plCtx)
{
PKIX_PL_HttpDefaultClient *client = NULL;
PKIX_ENTER
(HTTPDEFAULTCLIENT,
"pkix_pl_HttpDefaultClient_SetPostData");
PKIX_NULLCHECK_ONE(request);
PKIX_CHECK(pkix_CheckType
((PKIX_PL_Object *)request,
PKIX_HTTPDEFAULTCLIENT_TYPE,
plCtx),
PKIX_REQUESTNOTANHTTPDEFAULTCLIENT);
client = (PKIX_PL_HttpDefaultClient *)request;
client->send_http_data = http_data;
client->send_http_data_len = http_data_len;
client->send_http_content_type = http_content_type;
/* Caller is allowed to give NULL or empty string for content_type */
if ((client->send_http_content_type == NULL) ||
(*(client->send_http_content_type) == '\0')) {
client->send_http_content_type = "application/ocsp-request";
}
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
PKIX_Error *
pkix_pl_HttpDefaultClient_TrySendAndReceive(
SEC_HTTP_REQUEST_SESSION request,
PRUint16 *http_response_code,
const char **http_response_content_type,
const char **http_response_headers,
const char **http_response_data,
PRUint32 *http_response_data_len,
PRPollDesc **pPollDesc,
SECStatus *pSECReturn,
void *plCtx)
{
PKIX_PL_HttpDefaultClient *client = NULL;
PKIX_UInt32 postLen = 0;
PRPollDesc *pollDesc = NULL;
char *sendbuf = NULL;
char portstr[16];
PKIX_ENTER
(HTTPDEFAULTCLIENT,
"pkix_pl_HttpDefaultClient_TrySendAndReceive");
PKIX_NULLCHECK_ONE(request);
PKIX_CHECK(pkix_CheckType
((PKIX_PL_Object *)request,
PKIX_HTTPDEFAULTCLIENT_TYPE,
plCtx),
PKIX_REQUESTNOTANHTTPDEFAULTCLIENT);
client = (PKIX_PL_HttpDefaultClient *)request;
if (!pPollDesc && client->timeout == 0) {
PKIX_ERROR_FATAL(PKIX_NULLARGUMENT);
}
if (pPollDesc) {
pollDesc = *pPollDesc;
}
/* if not continuing from an earlier WOULDBLOCK return... */
if (pollDesc == NULL) {
if (!((client->connectStatus == HTTP_CONNECTED) ||
(client->connectStatus == HTTP_CONNECT_PENDING))) {
PKIX_ERROR(PKIX_HTTPCLIENTININVALIDSTATE);
}
/* Did caller provide a value for response length? */
if (http_response_data_len != NULL) {
client->pRcv_http_data_len = http_response_data_len;
client->maxResponseLen = *http_response_data_len;
}
client->rcv_http_response_code = http_response_code;
client->rcv_http_content_type = http_response_content_type;
client->rcv_http_headers = http_response_headers;
client->rcv_http_data = http_response_data;
/* prepare the message */
portstr[0] = '\0';
if (client->portnum != 80) {
PR_snprintf(portstr, sizeof(portstr), ":%d",
client->portnum);
}
if (client->send_http_method == HTTP_POST_METHOD) {
sendbuf = PR_smprintf
("POST %s HTTP/1.0\r\nHost: %s%s\r\n"
"Content-Type: %s\r\nContent-Length: %u\r\n\r\n",
client->path,
client->host,
portstr,
client->send_http_content_type,
client->send_http_data_len);
postLen = PORT_Strlen(sendbuf);
client->POSTLen = postLen + client->send_http_data_len;
/* allocate postBuffer big enough for header + data */
PKIX_CHECK(PKIX_PL_Malloc
(client->POSTLen,
(void **)&(client->POSTBuf),
plCtx),
PKIX_MALLOCFAILED);
/* copy header into postBuffer */
PORT_Memcpy(client->POSTBuf, sendbuf, postLen);
/* append data after header */
PORT_Memcpy(&client->POSTBuf[postLen],
client->send_http_data,
client->send_http_data_len);
/* PR_smprintf_free original header buffer */
PR_smprintf_free(sendbuf);
sendbuf = NULL;
} else if (client->send_http_method == HTTP_GET_METHOD) {
client->GETBuf = PR_smprintf
("GET %s HTTP/1.0\r\nHost: %s%s\r\n\r\n",
client->path,
client->host,
portstr);
client->GETLen = PORT_Strlen(client->GETBuf);
}
}
/* continue according to state */
PKIX_CHECK(pkix_pl_HttpDefaultClient_Dispatch(client, plCtx),
PKIX_HTTPDEFAULTCLIENTDISPATCHFAILED);
switch (client->connectStatus) {
case HTTP_CONNECT_PENDING:
case HTTP_SEND_PENDING:
case HTTP_RECV_HDR_PENDING:
case HTTP_RECV_BODY_PENDING:
pollDesc = &(client->pollDesc);
*pSECReturn = SECWouldBlock;
break;
case HTTP_ERROR:
/* Did caller provide a pointer for length? */
if (client->pRcv_http_data_len != NULL) {
/* Was error "response too big?" */
if (client->rcv_http_data_len !=
HTTP_UNKNOWN_CONTENT_LENGTH &&
client->maxResponseLen >=
client->rcv_http_data_len) {
/* Yes, report needed space */
*(client->pRcv_http_data_len) =
client->rcv_http_data_len;
} else {
/* No, report problem other than size */
*(client->pRcv_http_data_len) = 0;
}
}
pollDesc = NULL;
*pSECReturn = SECFailure;
break;
case HTTP_COMPLETE:
*(client->rcv_http_response_code) =
client->responseCode;
if (client->pRcv_http_data_len != NULL) {
*http_response_data_len =
client->rcv_http_data_len;
}
if (client->rcv_http_data != NULL) {
*(client->rcv_http_data) = client->rcvBuf;
}
pollDesc = NULL;
*pSECReturn = SECSuccess;
break;
case HTTP_NOT_CONNECTED:
case HTTP_CONNECTED:
case HTTP_RECV_HDR:
case HTTP_RECV_BODY:
default:
pollDesc = NULL;
*pSECReturn = SECFailure;
PKIX_ERROR(PKIX_HTTPCLIENTININVALIDSTATE);
break;
}
if (pPollDesc) {
*pPollDesc = pollDesc;
}
cleanup:
if (sendbuf) {
PR_smprintf_free(sendbuf);
}
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
PKIX_Error *
pkix_pl_HttpDefaultClient_Cancel(
SEC_HTTP_REQUEST_SESSION request,
void *plCtx)
{
PKIX_ENTER(HTTPDEFAULTCLIENT, "pkix_pl_HttpDefaultClient_Cancel");
PKIX_NULLCHECK_ONE(request);
PKIX_CHECK(pkix_CheckType
((PKIX_PL_Object *)request,
PKIX_HTTPDEFAULTCLIENT_TYPE,
plCtx),
PKIX_REQUESTNOTANHTTPDEFAULTCLIENT);
/* XXX Not implemented */
cleanup:
PKIX_RETURN(HTTPDEFAULTCLIENT);
}
SECStatus
pkix_pl_HttpDefaultClient_CreateSessionFcn(
const char *host,
PRUint16 portnum,
SEC_HTTP_SERVER_SESSION *pSession)
{
PKIX_Error *err = pkix_pl_HttpDefaultClient_CreateSession
(host, portnum, pSession, plContext);
if (err) {
PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
return SECFailure;
}
return SECSuccess;
}
SECStatus
pkix_pl_HttpDefaultClient_KeepAliveSessionFcn(
SEC_HTTP_SERVER_SESSION session,
PRPollDesc **pPollDesc)
{
PKIX_Error *err = pkix_pl_HttpDefaultClient_KeepAliveSession
(session, pPollDesc, plContext);
if (err) {
PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
return SECFailure;
}
return SECSuccess;
}
SECStatus
pkix_pl_HttpDefaultClient_FreeSessionFcn(
SEC_HTTP_SERVER_SESSION session)
{
PKIX_Error *err =
PKIX_PL_Object_DecRef((PKIX_PL_Object *)(session), plContext);
if (err) {
PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
return SECFailure;
}
return SECSuccess;
}
SECStatus
pkix_pl_HttpDefaultClient_RequestCreateFcn(
SEC_HTTP_SERVER_SESSION session,
const char *http_protocol_variant, /* usually "http" */
const char *path_and_query_string,
const char *http_request_method,
const PRIntervalTime timeout,
SEC_HTTP_REQUEST_SESSION *pRequest)
{
PKIX_Error *err = pkix_pl_HttpDefaultClient_RequestCreate
(session,
http_protocol_variant,
path_and_query_string,
http_request_method,
timeout,
pRequest,
plContext);
if (err) {
PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
return SECFailure;
}
return SECSuccess;
}
SECStatus
pkix_pl_HttpDefaultClient_SetPostDataFcn(
SEC_HTTP_REQUEST_SESSION request,
const char *http_data,
const PRUint32 http_data_len,
const char *http_content_type)
{
PKIX_Error *err =
pkix_pl_HttpDefaultClient_SetPostData(request, http_data,
http_data_len,
http_content_type,
plContext);
if (err) {
PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
return SECFailure;
}
return SECSuccess;
}
SECStatus
pkix_pl_HttpDefaultClient_AddHeaderFcn(
SEC_HTTP_REQUEST_SESSION request,
const char *http_header_name,
const char *http_header_value)
{
/* Not supported */
return SECFailure;
}
SECStatus
pkix_pl_HttpDefaultClient_TrySendAndReceiveFcn(
SEC_HTTP_REQUEST_SESSION request,
PRPollDesc **pPollDesc,
PRUint16 *http_response_code,
const char **http_response_content_type,
const char **http_response_headers,
const char **http_response_data,
PRUint32 *http_response_data_len)
{
SECStatus rv = SECFailure;
PKIX_Error *err = pkix_pl_HttpDefaultClient_TrySendAndReceive
(request,
http_response_code,
http_response_content_type,
http_response_headers,
http_response_data,
http_response_data_len,
pPollDesc,
&rv,
plContext);
if (err) {
PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
return rv;
}
return SECSuccess;
}
SECStatus
pkix_pl_HttpDefaultClient_CancelFcn(
SEC_HTTP_REQUEST_SESSION request)
{
PKIX_Error *err = pkix_pl_HttpDefaultClient_Cancel(request, plContext);
if (err) {
PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
return SECFailure;
}
return SECSuccess;
}
SECStatus
pkix_pl_HttpDefaultClient_FreeFcn(
SEC_HTTP_REQUEST_SESSION request)
{
PKIX_Error *err =
PKIX_PL_Object_DecRef((PKIX_PL_Object *)(request), plContext);
if (err) {
PKIX_PL_Object_DecRef((PKIX_PL_Object *)err, plContext);
return SECFailure;
}
return SECSuccess;
}