Signed-off-by: Hans Leidekker <hans(a)codeweavers.com>
---
dlls/winhttp/cookie.c | 11 +-
dlls/winhttp/net.c | 177 +++++-----
dlls/winhttp/request.c | 572 ++++++++++++++++-----------------
dlls/winhttp/session.c | 2 +-
dlls/winhttp/winhttp_private.h | 16 +-
5 files changed, 385 insertions(+), 393 deletions(-)
diff --git a/dlls/winhttp/cookie.c b/dlls/winhttp/cookie.c
index 83efc7f85c..6247e379ec 100644
--- a/dlls/winhttp/cookie.c
+++ b/dlls/winhttp/cookie.c
@@ -319,10 +319,11 @@ end:
return ret;
}
-BOOL add_cookie_headers( struct request *request )
+DWORD add_cookie_headers( struct request *request )
{
struct list *domain_cursor;
struct session *session = request->connect->session;
+ DWORD ret = ERROR_SUCCESS;
EnterCriticalSection( &session->cs );
@@ -351,7 +352,7 @@ BOOL add_cookie_headers( struct request *request )
if (!(header = heap_alloc( (len + 1) * sizeof(WCHAR) )))
{
LeaveCriticalSection( &session->cs );
- return FALSE;
+ return ERROR_OUTOFMEMORY;
}
memcpy( header, cookieW, len_cookie * sizeof(WCHAR) );
@@ -363,8 +364,8 @@ BOOL add_cookie_headers( struct request *request )
}
TRACE("%s\n", debugstr_w(header));
- add_request_headers( request, header, len,
- WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
+ ret = add_request_headers( request, header, len,
+ WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
heap_free( header );
}
}
@@ -372,5 +373,5 @@ BOOL add_cookie_headers( struct request *request )
}
LeaveCriticalSection( &session->cs );
- return TRUE;
+ return ret;
}
diff --git a/dlls/winhttp/net.c b/dlls/winhttp/net.c
index c9da098f52..c88def5b51 100644
--- a/dlls/winhttp/net.c
+++ b/dlls/winhttp/net.c
@@ -176,23 +176,24 @@ static void set_blocking( struct netconn *conn, BOOL blocking )
ioctlsocket( conn->socket, FIONBIO, &state );
}
-struct netconn *netconn_create( struct hostdata *host, const struct sockaddr_storage *sockaddr, int timeout )
+DWORD netconn_create( struct hostdata *host, const struct sockaddr_storage *sockaddr, int timeout,
+ struct netconn **ret_conn )
{
struct netconn *conn;
unsigned int addr_len;
- BOOL ret = FALSE;
+ DWORD ret;
winsock_init();
- conn = heap_alloc_zero(sizeof(*conn));
- if (!conn) return NULL;
+ if (!(conn = heap_alloc_zero( sizeof(*conn) ))) return ERROR_OUTOFMEMORY;
conn->host = host;
conn->sockaddr = *sockaddr;
if ((conn->socket = socket( sockaddr->ss_family, SOCK_STREAM, 0 )) == -1)
{
- WARN("unable to create socket (%u)\n", WSAGetLastError());
- heap_free(conn);
- return NULL;
+ ret = WSAGetLastError();
+ WARN("unable to create socket (%u)\n", ret);
+ heap_free( conn );
+ return ret;
}
switch (conn->sockaddr.ss_family)
@@ -206,16 +207,16 @@ struct netconn *netconn_create( struct hostdata *host, const struct sockaddr_sto
default:
ERR( "unhandled family %u\n", conn->sockaddr.ss_family );
heap_free( conn );
- return NULL;
+ return ERROR_INVALID_PARAMETER;
}
if (timeout > 0) set_blocking( conn, FALSE );
- if (!connect( conn->socket, (const struct sockaddr *)&conn->sockaddr, addr_len )) ret = TRUE;
+ if (!connect( conn->socket, (const struct sockaddr *)&conn->sockaddr, addr_len )) ret = ERROR_SUCCESS;
else
{
- DWORD err = WSAGetLastError();
- if (err == WSAEWOULDBLOCK || err == WSAEINPROGRESS)
+ ret = WSAGetLastError();
+ if (ret == WSAEWOULDBLOCK || ret == WSAEINPROGRESS)
{
FD_SET set;
TIMEVAL timeval = { 0, timeout * 1000 };
@@ -223,21 +224,23 @@ struct netconn *netconn_create( struct hostdata *host, const struct sockaddr_sto
FD_ZERO( &set );
FD_SET( conn->socket, &set );
- if ((res = select( conn->socket + 1, NULL, &set, NULL, &timeval )) > 0) ret = TRUE;
- else if (!res) SetLastError( ERROR_WINHTTP_TIMEOUT );
+ if ((res = select( conn->socket + 1, NULL, &set, NULL, &timeval )) > 0) ret = ERROR_SUCCESS;
+ else if (!res) ret = ERROR_WINHTTP_TIMEOUT;
}
}
if (timeout > 0) set_blocking( conn, TRUE );
- if (!ret)
+ if (ret)
{
- WARN("unable to connect to host (%u)\n", GetLastError());
+ WARN("unable to connect to host (%u)\n", ret);
closesocket( conn->socket );
heap_free( conn );
- return NULL;
+ return ret;
}
- return conn;
+
+ *ret_conn = conn;
+ return ERROR_SUCCESS;
}
void netconn_close( struct netconn *conn )
@@ -254,8 +257,8 @@ void netconn_close( struct netconn *conn )
heap_free(conn);
}
-BOOL netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD security_flags, CredHandle *cred_handle,
- BOOL check_revocation)
+DWORD netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD security_flags, CredHandle *cred_handle,
+ BOOL check_revocation )
{
SecBuffer out_buf = {0, SECBUFFER_TOKEN, NULL}, in_bufs[2] = {{0, SECBUFFER_TOKEN}, {0, SECBUFFER_EMPTY}};
SecBufferDesc out_desc = {SECBUFFER_VERSION, 1, &out_buf}, in_desc = {SECBUFFER_VERSION, 2, in_bufs};
@@ -271,9 +274,7 @@ BOOL netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD securi
const DWORD isc_req_flags = ISC_REQ_ALLOCATE_MEMORY|ISC_REQ_USE_SESSION_KEY|ISC_REQ_CONFIDENTIALITY
|ISC_REQ_SEQUENCE_DETECT|ISC_REQ_REPLAY_DETECT|ISC_REQ_MANUAL_CRED_VALIDATION;
- read_buf = heap_alloc(read_buf_size);
- if(!read_buf)
- return FALSE;
+ if (!(read_buf = heap_alloc( read_buf_size ))) return ERROR_OUTOFMEMORY;
status = InitializeSecurityContextW(cred_handle, NULL, hostname, isc_req_flags, 0, 0, NULL, 0,
&ctx, &out_desc, &attrs, NULL);
@@ -364,7 +365,7 @@ BOOL netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD securi
conn->ssl_buf = heap_alloc(conn->ssl_sizes.cbHeader + conn->ssl_sizes.cbMaximumMessage + conn->ssl_sizes.cbTrailer);
if(!conn->ssl_buf) {
- res = GetLastError();
+ res = ERROR_OUTOFMEMORY;
break;
}
}
@@ -377,18 +378,17 @@ BOOL netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD securi
heap_free(conn->ssl_buf);
conn->ssl_buf = NULL;
DeleteSecurityContext(&ctx);
- SetLastError(res ? res : ERROR_WINHTTP_SECURE_CHANNEL_ERROR);
- return FALSE;
+ return ERROR_WINHTTP_SECURE_CHANNEL_ERROR;
}
TRACE("established SSL connection\n");
conn->secure = TRUE;
conn->ssl_ctx = ctx;
- return TRUE;
+ return ERROR_SUCCESS;
}
-static BOOL send_ssl_chunk(struct netconn *conn, const void *msg, size_t size)
+static DWORD send_ssl_chunk( struct netconn *conn, const void *msg, size_t size )
{
SecBuffer bufs[4] = {
{conn->ssl_sizes.cbHeader, SECBUFFER_STREAM_HEADER, conn->ssl_buf},
@@ -399,46 +399,50 @@ static BOOL send_ssl_chunk(struct netconn *conn, const void *msg, size_t size)
SecBufferDesc buf_desc = {SECBUFFER_VERSION, ARRAY_SIZE(bufs), bufs};
SECURITY_STATUS res;
- memcpy(bufs[1].pvBuffer, msg, size);
- res = EncryptMessage(&conn->ssl_ctx, 0, &buf_desc, 0);
- if(res != SEC_E_OK) {
- WARN("EncryptMessage failed\n");
- return FALSE;
+ memcpy( bufs[1].pvBuffer, msg, size );
+ if ((res = EncryptMessage(&conn->ssl_ctx, 0, &buf_desc, 0)) != SEC_E_OK)
+ {
+ WARN("EncryptMessage failed: %08x\n", res);
+ return res;
}
- if(sock_send(conn->socket, conn->ssl_buf, bufs[0].cbBuffer+bufs[1].cbBuffer+bufs[2].cbBuffer, 0) < 1) {
+ if (sock_send( conn->socket, conn->ssl_buf, bufs[0].cbBuffer + bufs[1].cbBuffer + bufs[2].cbBuffer, 0 ) < 1)
+ {
WARN("send failed\n");
- return FALSE;
+ return WSAGetLastError();
}
- return TRUE;
+ return ERROR_SUCCESS;
}
-BOOL netconn_send( struct netconn *conn, const void *msg, size_t len, int *sent )
+DWORD netconn_send( struct netconn *conn, const void *msg, size_t len, int *sent )
{
if (conn->secure)
{
const BYTE *ptr = msg;
size_t chunk_size;
+ DWORD res;
*sent = 0;
-
- while(len) {
- chunk_size = min(len, conn->ssl_sizes.cbMaximumMessage);
- if(!send_ssl_chunk(conn, ptr, chunk_size))
- return FALSE;
+ while (len)
+ {
+ chunk_size = min( len, conn->ssl_sizes.cbMaximumMessage );
+ if ((res = send_ssl_chunk( conn, ptr, chunk_size )))
+ return res;
*sent += chunk_size;
ptr += chunk_size;
len -= chunk_size;
}
- return TRUE;
+ return ERROR_SUCCESS;
}
- return ((*sent = sock_send( conn->socket, msg, len, 0 )) != -1);
+
+ if ((*sent = sock_send( conn->socket, msg, len, 0 )) < 0) return WSAGetLastError();
+ return ERROR_SUCCESS;
}
-static BOOL read_ssl_chunk(struct netconn *conn, void *buf, SIZE_T buf_size, SIZE_T *ret_size, BOOL *eof)
+static DWORD read_ssl_chunk( struct netconn *conn, void *buf, SIZE_T buf_size, SIZE_T *ret_size, BOOL *eof )
{
const SIZE_T ssl_buf_size = conn->ssl_sizes.cbHeader+conn->ssl_sizes.cbMaximumMessage+conn->ssl_sizes.cbTrailer;
SecBuffer bufs[4];
@@ -456,13 +460,13 @@ static BOOL read_ssl_chunk(struct netconn *conn, void *buf, SIZE_T buf_size, SIZ
heap_free(conn->extra_buf);
conn->extra_buf = NULL;
}else {
- buf_len = sock_recv(conn->socket, conn->ssl_buf+conn->extra_len, ssl_buf_size-conn->extra_len, 0);
- if(buf_len < 0)
- return FALSE;
+ if ((buf_len = sock_recv( conn->socket, conn->ssl_buf + conn->extra_len, ssl_buf_size - conn->extra_len, 0)) < 0)
+ return WSAGetLastError();
- if(!buf_len) {
+ if (!buf_len)
+ {
*eof = TRUE;
- return TRUE;
+ return ERROR_SUCCESS;
}
}
@@ -475,28 +479,30 @@ static BOOL read_ssl_chunk(struct netconn *conn, void *buf, SIZE_T buf_size, SIZ
bufs[0].cbBuffer = buf_len;
bufs[0].pvBuffer = conn->ssl_buf;
- res = DecryptMessage(&conn->ssl_ctx, &buf_desc, 0, NULL);
- switch(res) {
+ switch ((res = DecryptMessage( &conn->ssl_ctx, &buf_desc, 0, NULL )))
+ {
case SEC_E_OK:
break;
+
case SEC_I_CONTEXT_EXPIRED:
TRACE("context expired\n");
*eof = TRUE;
- return TRUE;
+ return ERROR_SUCCESS;
+
case SEC_E_INCOMPLETE_MESSAGE:
assert(buf_len < ssl_buf_size);
- size = sock_recv(conn->socket, conn->ssl_buf+buf_len, ssl_buf_size-buf_len, 0);
- if(size < 1)
- return FALSE;
+ if ((size = sock_recv( conn->socket, conn->ssl_buf + buf_len, ssl_buf_size - buf_len, 0 )) < 1)
+ return SEC_E_INCOMPLETE_MESSAGE;
buf_len += size;
continue;
+
default:
WARN("failed: %08x\n", res);
- return FALSE;
+ return res;
}
- } while(res != SEC_E_OK);
+ } while (res != SEC_E_OK);
for(i = 0; i < ARRAY_SIZE(bufs); i++) {
if(bufs[i].BufferType == SECBUFFER_DATA) {
@@ -506,7 +512,7 @@ static BOOL read_ssl_chunk(struct netconn *conn, void *buf, SIZE_T buf_size, SIZ
assert(!conn->peek_len);
conn->peek_msg_mem = conn->peek_msg = heap_alloc(bufs[i].cbBuffer - size);
if(!conn->peek_msg)
- return FALSE;
+ return ERROR_OUTOFMEMORY;
conn->peek_len = bufs[i].cbBuffer-size;
memcpy(conn->peek_msg, (char*)bufs[i].pvBuffer+size, conn->peek_len);
}
@@ -519,25 +525,26 @@ static BOOL read_ssl_chunk(struct netconn *conn, void *buf, SIZE_T buf_size, SIZ
if(bufs[i].BufferType == SECBUFFER_EXTRA) {
conn->extra_buf = heap_alloc(bufs[i].cbBuffer);
if(!conn->extra_buf)
- return FALSE;
+ return ERROR_OUTOFMEMORY;
conn->extra_len = bufs[i].cbBuffer;
memcpy(conn->extra_buf, bufs[i].pvBuffer, conn->extra_len);
}
}
- return TRUE;
+ return ERROR_SUCCESS;
}
-BOOL netconn_recv( struct netconn *conn, void *buf, size_t len, int flags, int *recvd )
+DWORD netconn_recv( struct netconn *conn, void *buf, size_t len, int flags, int *recvd )
{
*recvd = 0;
- if (!len) return TRUE;
+ if (!len) return ERROR_SUCCESS;
if (conn->secure)
{
- SIZE_T size, cread;
- BOOL res, eof;
+ SIZE_T size;
+ DWORD res;
+ BOOL eof;
if (conn->peek_msg)
{
@@ -553,32 +560,35 @@ BOOL netconn_recv( struct netconn *conn, void *buf, size_t len, int flags, int *
conn->peek_msg = NULL;
}
/* check if we have enough data from the peek buffer */
- if (!(flags & MSG_WAITALL) || *recvd == len) return TRUE;
+ if (!(flags & MSG_WAITALL) || *recvd == len) return ERROR_SUCCESS;
}
size = *recvd;
- do {
- res = read_ssl_chunk(conn, (BYTE*)buf+size, len-size, &cread, &eof);
- if(!res) {
- WARN("read_ssl_chunk failed\n");
- if(!size)
- return FALSE;
+ do
+ {
+ SIZE_T cread = 0;
+ if ((res = read_ssl_chunk( conn, (BYTE *)buf + size, len - size, &cread, &eof )))
+ {
+ WARN("read_ssl_chunk failed: %u\n", res);
+ if (!size) return res;
break;
}
-
- if(eof) {
+ if (eof)
+ {
TRACE("EOF\n");
break;
}
-
size += cread;
- }while(!size || ((flags & MSG_WAITALL) && size < len));
+
+ } while (!size || ((flags & MSG_WAITALL) && size < len));
TRACE("received %ld bytes\n", size);
*recvd = size;
- return TRUE;
+ return ERROR_SUCCESS;
}
- return ((*recvd = sock_recv( conn->socket, buf, len, flags )) != -1);
+
+ if ((*recvd = sock_recv( conn->socket, buf, len, flags )) < 0) return WSAGetLastError();
+ return ERROR_SUCCESS;
}
ULONG netconn_query_data_available( struct netconn *conn )
@@ -666,7 +676,7 @@ static void CALLBACK resolve_proc( TP_CALLBACK_INSTANCE *instance, void *ctx )
SetEvent( async->done );
}
-BOOL netconn_resolve( WCHAR *hostname, INTERNET_PORT port, struct sockaddr_storage *addr, int timeout )
+DWORD netconn_resolve( WCHAR *hostname, INTERNET_PORT port, struct sockaddr_storage *addr, int timeout )
{
DWORD ret;
@@ -678,23 +688,18 @@ BOOL netconn_resolve( WCHAR *hostname, INTERNET_PORT port, struct sockaddr_stora
async.hostname = hostname;
async.port = port;
async.addr = addr;
- if (!(async.done = CreateEventW( NULL, FALSE, FALSE, NULL ))) return FALSE;
+ if (!(async.done = CreateEventW( NULL, FALSE, FALSE, NULL ))) return GetLastError();
if (!TrySubmitThreadpoolCallback( resolve_proc, &async, NULL ))
{
CloseHandle( async.done );
- return FALSE;
+ return GetLastError();
}
if (WaitForSingleObject( async.done, timeout ) != WAIT_OBJECT_0) ret = ERROR_WINHTTP_TIMEOUT;
else ret = async.result;
CloseHandle( async.done );
}
- if (ret)
- {
- SetLastError( ret );
- return FALSE;
- }
- return TRUE;
+ return ret;
}
const void *netconn_get_certificate( struct netconn *conn )
diff --git a/dlls/winhttp/request.c b/dlls/winhttp/request.c
index 7c8e6ba89e..fbccf0228b 100644
--- a/dlls/winhttp/request.c
+++ b/dlls/winhttp/request.c
@@ -173,18 +173,18 @@ static void CALLBACK task_proc( TP_CALLBACK_INSTANCE *instance, void *ctx )
}
}
-static BOOL queue_task( struct task_header *task )
+static DWORD queue_task( struct task_header *task )
{
struct request *request = task->request;
if (!request->task_wait)
{
- if (!(request->task_wait = CreateEventW( NULL, FALSE, FALSE, NULL ))) return FALSE;
+ if (!(request->task_wait = CreateEventW( NULL, FALSE, FALSE, NULL ))) return ERROR_OUTOFMEMORY;
if (!(request->task_cancel = CreateEventW( NULL, FALSE, FALSE, NULL )))
{
CloseHandle( request->task_wait );
request->task_wait = NULL;
- return FALSE;
+ return ERROR_OUTOFMEMORY;
}
if (!TrySubmitThreadpoolCallback( task_proc, request, NULL ))
{
@@ -192,7 +192,7 @@ static BOOL queue_task( struct task_header *task )
request->task_wait = NULL;
CloseHandle( request->task_cancel );
request->task_cancel = NULL;
- return FALSE;
+ return GetLastError();
}
request->task_proc_running = TRUE;
InitializeCriticalSection( &request->task_cs );
@@ -205,7 +205,7 @@ static BOOL queue_task( struct task_header *task )
LeaveCriticalSection( &request->task_cs );
SetEvent( request->task_wait );
- return TRUE;
+ return ERROR_SUCCESS;
}
static void free_header( struct header *header )
@@ -307,7 +307,7 @@ static int get_header_index( struct request *request, const WCHAR *field, int re
return index;
}
-static BOOL insert_header( struct request *request, struct header *header )
+static DWORD insert_header( struct request *request, struct header *header )
{
DWORD count = request->num_headers + 1;
struct header *hdrs;
@@ -316,20 +316,19 @@ static BOOL insert_header( struct request *request, struct header *header )
hdrs = heap_realloc_zero( request->headers, sizeof(struct header) * count );
else
hdrs = heap_alloc_zero( sizeof(struct header) );
- if (!hdrs) return FALSE;
+ if (!hdrs) return ERROR_OUTOFMEMORY;
request->headers = hdrs;
request->headers[count - 1].field = strdupW( header->field );
request->headers[count - 1].value = strdupW( header->value );
request->headers[count - 1].is_request = header->is_request;
request->num_headers = count;
- return TRUE;
+ return ERROR_SUCCESS;
}
-static BOOL delete_header( struct request *request, DWORD index )
+static void delete_header( struct request *request, DWORD index )
{
- if (!request->num_headers) return FALSE;
- if (index >= request->num_headers) return FALSE;
+ if (!request->num_headers || index >= request->num_headers) return;
request->num_headers--;
heap_free( request->headers[index].field );
@@ -338,10 +337,9 @@ static BOOL delete_header( struct request *request, DWORD index )
memmove( &request->headers[index], &request->headers[index + 1],
(request->num_headers - index) * sizeof(struct header) );
memset( &request->headers[request->num_headers], 0, sizeof(struct header) );
- return TRUE;
}
-BOOL process_header( struct request *request, const WCHAR *field, const WCHAR *value, DWORD flags, BOOL request_only )
+DWORD process_header( struct request *request, const WCHAR *field, const WCHAR *value, DWORD flags, BOOL request_only )
{
int index;
struct header hdr;
@@ -350,7 +348,7 @@ BOOL process_header( struct request *request, const WCHAR *field, const WCHAR *v
if ((index = get_header_index( request, field, 0, request_only )) >= 0)
{
- if (flags & WINHTTP_ADDREQ_FLAG_ADD_IF_NEW) return FALSE;
+ if (flags & WINHTTP_ADDREQ_FLAG_ADD_IF_NEW) return ERROR_WINHTTP_HEADER_ALREADY_EXISTS;
}
if (flags & WINHTTP_ADDREQ_FLAG_REPLACE)
@@ -358,13 +356,9 @@ BOOL process_header( struct request *request, const WCHAR *field, const WCHAR *v
if (index >= 0)
{
delete_header( request, index );
- if (!value || !value[0]) return TRUE;
- }
- else if (!(flags & WINHTTP_ADDREQ_FLAG_ADD))
- {
- SetLastError( ERROR_WINHTTP_HEADER_NOT_FOUND );
- return FALSE;
+ if (!value || !value[0]) return ERROR_SUCCESS;
}
+ else if (!(flags & WINHTTP_ADDREQ_FLAG_ADD)) return ERROR_WINHTTP_HEADER_NOT_FOUND;
hdr.field = (LPWSTR)field;
hdr.value = (LPWSTR)value;
@@ -385,14 +379,14 @@ BOOL process_header( struct request *request, const WCHAR *field, const WCHAR *v
len_value = lstrlenW( value );
len = len_orig + len_value + 2;
- if (!(tmp = heap_realloc( header->value, (len + 1) * sizeof(WCHAR) ))) return FALSE;
+ if (!(tmp = heap_realloc( header->value, (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
header->value = tmp;
header->value[len_orig++] = (flags & WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA) ? ',' : ';';
header->value[len_orig++] = ' ';
memcpy( &header->value[len_orig], value, len_value * sizeof(WCHAR) );
header->value[len] = 0;
- return TRUE;
+ return ERROR_SUCCESS;
}
else
{
@@ -403,18 +397,18 @@ BOOL process_header( struct request *request, const WCHAR *field, const WCHAR *v
}
}
- return TRUE;
+ return ERROR_SUCCESS;
}
-BOOL add_request_headers( struct request *request, const WCHAR *headers, DWORD len, DWORD flags )
+DWORD add_request_headers( struct request *request, const WCHAR *headers, DWORD len, DWORD flags )
{
- BOOL ret = FALSE;
+ DWORD ret = ERROR_WINHTTP_INVALID_HEADER;
WCHAR *buffer, *p, *q;
struct header *header;
if (len == ~0u) len = lstrlenW( headers );
- if (!len) return TRUE;
- if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
+ if (!len) return ERROR_SUCCESS;
+ if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
memcpy( buffer, headers, len * sizeof(WCHAR) );
buffer[len] = 0;
@@ -444,7 +438,7 @@ BOOL add_request_headers( struct request *request, const WCHAR *headers, DWORD l
free_header( header );
}
p = q;
- } while (ret);
+ } while (!ret);
heap_free( buffer );
return ret;
@@ -455,7 +449,7 @@ BOOL add_request_headers( struct request *request, const WCHAR *headers, DWORD l
*/
BOOL WINAPI WinHttpAddRequestHeaders( HINTERNET hrequest, LPCWSTR headers, DWORD len, DWORD flags )
{
- BOOL ret;
+ DWORD ret;
struct request *request;
TRACE("%p, %s, %u, 0x%08x\n", hrequest, debugstr_wn(headers, len), len, flags);
@@ -480,8 +474,8 @@ BOOL WINAPI WinHttpAddRequestHeaders( HINTERNET hrequest, LPCWSTR headers, DWORD
ret = add_request_headers( request, headers, len, flags );
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
static WCHAR *build_absolute_request_path( struct request *request, const WCHAR **path )
@@ -556,13 +550,13 @@ static WCHAR *build_request_string( struct request *request )
#define QUERY_MODIFIER_MASK (WINHTTP_QUERY_FLAG_REQUEST_HEADERS | WINHTTP_QUERY_FLAG_SYSTEMTIME | WINHTTP_QUERY_FLAG_NUMBER)
-static BOOL query_headers( struct request *request, DWORD level, const WCHAR *name, void *buffer, DWORD *buflen,
- DWORD *index )
+static DWORD query_headers( struct request *request, DWORD level, const WCHAR *name, void *buffer, DWORD *buflen,
+ DWORD *index )
{
struct header *header = NULL;
- BOOL request_only, ret = FALSE;
+ BOOL request_only;
int requested_index, header_index = -1;
- DWORD attr, len;
+ DWORD attr, len, ret = ERROR_WINHTTP_HEADER_NOT_FOUND;
request_only = level & WINHTTP_QUERY_FLAG_REQUEST_HEADERS;
requested_index = index ? *index : 0;
@@ -584,11 +578,10 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
else
headers = request->raw_headers;
- if (!(p = headers)) return FALSE;
+ if (!(p = headers)) return ERROR_OUTOFMEMORY;
for (len = 0; *p; p++) if (*p != '\r') len++;
- if (!buffer || len * sizeof(WCHAR) > *buflen)
- SetLastError( ERROR_INSUFFICIENT_BUFFER );
+ if (!buffer || len * sizeof(WCHAR) > *buflen) ret = ERROR_INSUFFICIENT_BUFFER;
else
{
for (p = headers, q = buffer; *p; p++, q++)
@@ -602,7 +595,7 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
}
TRACE("returning data: %s\n", debugstr_wn(buffer, len));
if (len) len--;
- ret = TRUE;
+ ret = ERROR_SUCCESS;
}
*buflen = len * sizeof(WCHAR);
if (request_only) heap_free( headers );
@@ -617,18 +610,18 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
else
headers = request->raw_headers;
- if (!headers) return FALSE;
+ if (!headers) return ERROR_OUTOFMEMORY;
len = lstrlenW( headers ) * sizeof(WCHAR);
if (!buffer || len + sizeof(WCHAR) > *buflen)
{
len += sizeof(WCHAR);
- SetLastError( ERROR_INSUFFICIENT_BUFFER );
+ ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
memcpy( buffer, headers, len + sizeof(WCHAR) );
TRACE("returning data: %s\n", debugstr_wn(buffer, len / sizeof(WCHAR)));
- ret = TRUE;
+ ret = ERROR_SUCCESS;
}
*buflen = len;
if (request_only) heap_free( headers );
@@ -639,13 +632,13 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
if (!buffer || len + sizeof(WCHAR) > *buflen)
{
len += sizeof(WCHAR);
- SetLastError( ERROR_INSUFFICIENT_BUFFER );
+ ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
lstrcpyW( buffer, request->version );
TRACE("returning string: %s\n", debugstr_w(buffer));
- ret = TRUE;
+ ret = ERROR_SUCCESS;
}
*buflen = len;
return ret;
@@ -655,13 +648,13 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
if (!buffer || len + sizeof(WCHAR) > *buflen)
{
len += sizeof(WCHAR);
- SetLastError( ERROR_INSUFFICIENT_BUFFER );
+ ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
lstrcpyW( buffer, request->status_text );
TRACE("returning string: %s\n", debugstr_w(buffer));
- ret = TRUE;
+ ret = ERROR_SUCCESS;
}
*buflen = len;
return ret;
@@ -671,28 +664,23 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
if (!buffer || len + sizeof(WCHAR) > *buflen)
{
len += sizeof(WCHAR);
- SetLastError( ERROR_INSUFFICIENT_BUFFER );
+ ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
lstrcpyW( buffer, request->verb );
TRACE("returning string: %s\n", debugstr_w(buffer));
- ret = TRUE;
+ ret = ERROR_SUCCESS;
}
*buflen = len;
return ret;
default:
- if (attr >= ARRAY_SIZE(attribute_table))
- {
- SetLastError( ERROR_INVALID_PARAMETER );
- return FALSE;
- }
+ if (attr >= ARRAY_SIZE(attribute_table)) return ERROR_INVALID_PARAMETER;
if (!attribute_table[attr])
{
FIXME("attribute %u not implemented\n", attr);
- SetLastError( ERROR_WINHTTP_HEADER_NOT_FOUND );
- return FALSE;
+ return ERROR_WINHTTP_HEADER_NOT_FOUND;
}
TRACE("attribute %s\n", debugstr_w(attribute_table[attr]));
header_index = get_header_index( request, attribute_table[attr], requested_index, request_only );
@@ -703,38 +691,29 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
{
header = &request->headers[header_index];
}
- if (!header || (request_only && !header->is_request))
- {
- SetLastError( ERROR_WINHTTP_HEADER_NOT_FOUND );
- return FALSE;
- }
+ if (!header || (request_only && !header->is_request)) return ERROR_WINHTTP_HEADER_NOT_FOUND;
if (level & WINHTTP_QUERY_FLAG_NUMBER)
{
- if (!buffer || sizeof(int) > *buflen)
- {
- SetLastError( ERROR_INSUFFICIENT_BUFFER );
- }
+ if (!buffer || sizeof(int) > *buflen) ret = ERROR_INSUFFICIENT_BUFFER;
else
{
int *number = buffer;
*number = wcstol( header->value, NULL, 10 );
TRACE("returning number: %d\n", *number);
- ret = TRUE;
+ ret = ERROR_SUCCESS;
}
*buflen = sizeof(int);
}
else if (level & WINHTTP_QUERY_FLAG_SYSTEMTIME)
{
SYSTEMTIME *st = buffer;
- if (!buffer || sizeof(SYSTEMTIME) > *buflen)
- {
- SetLastError( ERROR_INSUFFICIENT_BUFFER );
- }
- else if ((ret = WinHttpTimeToSystemTime( header->value, st )))
+ if (!buffer || sizeof(SYSTEMTIME) > *buflen) ret = ERROR_INSUFFICIENT_BUFFER;
+ else if (WinHttpTimeToSystemTime( header->value, st ))
{
TRACE("returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
st->wYear, st->wMonth, st->wDay, st->wDayOfWeek,
st->wHour, st->wMinute, st->wSecond, st->wMilliseconds);
+ ret = ERROR_SUCCESS;
}
*buflen = sizeof(SYSTEMTIME);
}
@@ -744,17 +723,17 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
if (!buffer || len + sizeof(WCHAR) > *buflen)
{
len += sizeof(WCHAR);
- SetLastError( ERROR_INSUFFICIENT_BUFFER );
+ ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
lstrcpyW( buffer, header->value );
TRACE("returning string: %s\n", debugstr_w(buffer));
- ret = TRUE;
+ ret = ERROR_SUCCESS;
}
*buflen = len;
}
- if (ret && index) *index += 1;
+ if (!ret && index) *index += 1;
return ret;
}
@@ -763,7 +742,7 @@ static BOOL query_headers( struct request *request, DWORD level, const WCHAR *na
*/
BOOL WINAPI WinHttpQueryHeaders( HINTERNET hrequest, DWORD level, LPCWSTR name, LPVOID buffer, LPDWORD buflen, LPDWORD index )
{
- BOOL ret;
+ DWORD ret;
struct request *request;
TRACE("%p, 0x%08x, %s, %p, %p, %p\n", hrequest, level, debugstr_w(name), buffer, buflen, index);
@@ -783,8 +762,8 @@ BOOL WINAPI WinHttpQueryHeaders( HINTERNET hrequest, DWORD level, LPCWSTR name,
ret = query_headers( request, level, name, buffer, buflen, index );
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
static const struct
@@ -822,10 +801,9 @@ static DWORD auth_scheme_from_header( const WCHAR *header )
return 0;
}
-static BOOL query_auth_schemes( struct request *request, DWORD level, DWORD *supported, DWORD *first )
+static DWORD query_auth_schemes( struct request *request, DWORD level, DWORD *supported, DWORD *first )
{
- DWORD index = 0, supported_schemes = 0, first_scheme = 0;
- BOOL ret = FALSE;
+ DWORD ret, index = 0, supported_schemes = 0, first_scheme = 0;
for (;;)
{
@@ -833,14 +811,18 @@ static BOOL query_auth_schemes( struct request *request, DWORD level, DWORD *sup
DWORD size, scheme;
size = 0;
- query_headers( request, level, NULL, NULL, &size, &index );
- if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) break;
+ ret = query_headers( request, level, NULL, NULL, &size, &index );
+ if (ret != ERROR_INSUFFICIENT_BUFFER)
+ {
+ if (index) ret = ERROR_SUCCESS;
+ break;
+ }
- if (!(buffer = heap_alloc( size ))) return FALSE;
- if (!query_headers( request, level, NULL, buffer, &size, &index ))
+ if (!(buffer = heap_alloc( size ))) return ERROR_OUTOFMEMORY;
+ if ((ret = query_headers( request, level, NULL, buffer, &size, &index )))
{
heap_free( buffer );
- return FALSE;
+ return ret;
}
scheme = auth_scheme_from_header( buffer );
heap_free( buffer );
@@ -848,11 +830,9 @@ static BOOL query_auth_schemes( struct request *request, DWORD level, DWORD *sup
if (!first_scheme) first_scheme = scheme;
supported_schemes |= scheme;
-
- ret = TRUE;
}
- if (ret)
+ if (!ret)
{
*supported = supported_schemes;
*first = first_scheme;
@@ -865,7 +845,7 @@ static BOOL query_auth_schemes( struct request *request, DWORD level, DWORD *sup
*/
BOOL WINAPI WinHttpQueryAuthSchemes( HINTERNET hrequest, LPDWORD supported, LPDWORD first, LPDWORD target )
{
- BOOL ret = FALSE;
+ DWORD ret;
struct request *request;
TRACE("%p, %p, %p, %p\n", hrequest, supported, first, target);
@@ -889,21 +869,19 @@ BOOL WINAPI WinHttpQueryAuthSchemes( HINTERNET hrequest, LPDWORD supported, LPDW
}
- if (query_auth_schemes( request, WINHTTP_QUERY_WWW_AUTHENTICATE, supported, first ))
+ if (!(ret = query_auth_schemes( request, WINHTTP_QUERY_WWW_AUTHENTICATE, supported, first )))
{
*target = WINHTTP_AUTH_TARGET_SERVER;
- ret = TRUE;
}
- else if (query_auth_schemes( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, supported, first ))
+ else if (!(ret = query_auth_schemes( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, supported, first )))
{
*target = WINHTTP_AUTH_TARGET_PROXY;
- ret = TRUE;
}
- else SetLastError( ERROR_INVALID_OPERATION );
+ else ret = ERROR_INVALID_OPERATION;
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
static UINT encode_base64( const char *bin, unsigned int len, WCHAR *base64 )
@@ -1056,7 +1034,7 @@ static BOOL get_authvalue( struct request *request, DWORD level, DWORD scheme, W
for (;;)
{
size = len;
- if (!query_headers( request, level, NULL, buffer, &size, &index )) return FALSE;
+ if (query_headers( request, level, NULL, buffer, &size, &index )) return FALSE;
if (auth_scheme_from_header( buffer ) == scheme) break;
}
return TRUE;
@@ -1286,7 +1264,7 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
encode_base64( authinfo->data, authinfo->data_len, auth_reply + len_scheme + 1 );
flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE;
- ret = process_header( request, auth_target, auth_reply, flags, TRUE );
+ ret = !process_header( request, auth_target, auth_reply, flags, TRUE );
heap_free( auth_reply );
return ret;
}
@@ -1335,24 +1313,24 @@ static WCHAR *build_proxy_connect_string( struct request *request )
return ret;
}
-static BOOL read_reply( struct request *request );
+static DWORD read_reply( struct request *request );
-static BOOL secure_proxy_connect( struct request *request )
+static DWORD secure_proxy_connect( struct request *request )
{
WCHAR *str;
char *strA;
int len, bytes_sent;
- BOOL ret;
+ DWORD ret;
- if (!(str = build_proxy_connect_string( request ))) return FALSE;
+ if (!(str = build_proxy_connect_string( request ))) return ERROR_OUTOFMEMORY;
strA = strdupWA( str );
heap_free( str );
- if (!strA) return FALSE;
+ if (!strA) return ERROR_OUTOFMEMORY;
len = strlen( strA );
ret = netconn_send( request->netconn, strA, len, &bytes_sent );
heap_free( strA );
- if (ret) ret = read_reply( request );
+ if (!ret) ret = read_reply( request );
return ret;
}
@@ -1476,11 +1454,11 @@ static DWORD map_secure_protocols( DWORD mask )
return ret;
}
-static BOOL ensure_cred_handle( struct request *request )
+static DWORD ensure_cred_handle( struct request *request )
{
SECURITY_STATUS status = SEC_E_OK;
- if (request->cred_handle_initialized) return TRUE;
+ if (request->cred_handle_initialized) return ERROR_SUCCESS;
if (!request->cred_handle_initialized)
{
@@ -1502,12 +1480,12 @@ static BOOL ensure_cred_handle( struct request *request )
if (status != SEC_E_OK)
{
WARN( "AcquireCredentialsHandleW failed: 0x%08x\n", status );
- return FALSE;
+ return status;
}
- return TRUE;
+ return ERROR_SUCCESS;
}
-static BOOL open_connection( struct request *request )
+static DWORD open_connection( struct request *request )
{
BOOL is_secure = request->hdr.flags & WINHTTP_FLAG_SECURE;
struct hostdata *host = NULL, *iter;
@@ -1515,7 +1493,7 @@ static BOOL open_connection( struct request *request )
struct connect *connect;
WCHAR *addressW = NULL;
INTERNET_PORT port;
- DWORD len;
+ DWORD ret, len;
if (request->netconn) goto done;
@@ -1556,7 +1534,7 @@ static BOOL open_connection( struct request *request )
LeaveCriticalSection( &connection_pool_cs );
- if (!host) return FALSE;
+ if (!host) return ERROR_OUTOFMEMORY;
for (;;)
{
@@ -1586,17 +1564,17 @@ static BOOL open_connection( struct request *request )
len = lstrlenW( host->hostname ) + 1;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, host->hostname, len );
- if (!netconn_resolve( host->hostname, port, &connect->sockaddr, request->resolve_timeout ))
+ if ((ret = netconn_resolve( host->hostname, port, &connect->sockaddr, request->resolve_timeout )))
{
release_host( host );
- return FALSE;
+ return ret;
}
connect->resolved = TRUE;
if (!(addressW = addr_to_str( &connect->sockaddr )))
{
release_host( host );
- return FALSE;
+ return ERROR_OUTOFMEMORY;
}
len = lstrlenW( addressW ) + 1;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, addressW, len );
@@ -1607,18 +1585,18 @@ static BOOL open_connection( struct request *request )
if (!addressW && !(addressW = addr_to_str( &connect->sockaddr )))
{
release_host( host );
- return FALSE;
+ return ERROR_OUTOFMEMORY;
}
TRACE("connecting to %s:%u\n", debugstr_w(addressW), port);
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, addressW, 0 );
- if (!(netconn = netconn_create( host, &connect->sockaddr, request->connect_timeout )))
+ if ((ret = netconn_create( host, &connect->sockaddr, request->connect_timeout, &netconn )))
{
heap_free( addressW );
release_host( host );
- return FALSE;
+ return ret;
}
netconn_set_timeout( netconn, TRUE, request->send_timeout );
netconn_set_timeout( netconn, FALSE, request->receive_response_timeout );
@@ -1627,29 +1605,28 @@ static BOOL open_connection( struct request *request )
if (is_secure)
{
- if (connect->session->proxy_server &&
- wcsicmp( connect->hostname, connect->servername ))
+ if (connect->session->proxy_server && wcsicmp( connect->hostname, connect->servername ))
{
- if (!secure_proxy_connect( request ))
+ if ((ret = secure_proxy_connect( request )))
{
request->netconn = NULL;
heap_free( addressW );
netconn_close( netconn );
- return FALSE;
+ return ret;
}
}
CertFreeCertificateContext( request->server_cert );
request->server_cert = NULL;
- if (!ensure_cred_handle( request ) ||
- !netconn_secure_connect( netconn, connect->hostname, request->security_flags,
- &request->cred_handle, request->check_revocation ))
+ if ((ret = ensure_cred_handle( request )) ||
+ (ret = netconn_secure_connect( netconn, connect->hostname, request->security_flags,
+ &request->cred_handle, request->check_revocation )))
{
request->netconn = NULL;
heap_free( addressW );
netconn_close( netconn );
- return FALSE;
+ return ret;
}
}
@@ -1668,7 +1645,7 @@ static BOOL open_connection( struct request *request )
{
heap_free( addressW );
netconn_close( netconn );
- return FALSE;
+ return ERROR_WINHTTP_SECURE_FAILURE;
}
done:
@@ -1677,7 +1654,7 @@ done:
request->read_chunked_size = ~0u;
request->read_chunked_eof = FALSE;
heap_free( addressW );
- return TRUE;
+ return ERROR_SUCCESS;
}
void close_connection( struct request *request )
@@ -1690,10 +1667,9 @@ void close_connection( struct request *request )
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, 0, 0 );
}
-static BOOL add_host_header( struct request *request, DWORD modifier )
+static DWORD add_host_header( struct request *request, DWORD modifier )
{
- BOOL ret;
- DWORD len;
+ DWORD ret, len;
WCHAR *host;
struct connect *connect = request->connect;
INTERNET_PORT port;
@@ -1705,7 +1681,7 @@ static BOOL add_host_header( struct request *request, DWORD modifier )
return process_header( request, L"Host", connect->hostname, modifier, TRUE );
}
len = lstrlenW( connect->hostname ) + 7; /* sizeof(":65335") */
- if (!(host = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
+ if (!(host = heap_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
swprintf( host, len, L"%s:%u", connect->hostname, port );
ret = process_header( request, L"Host", host, modifier, TRUE );
heap_free( host );
@@ -1734,12 +1710,12 @@ static void remove_data( struct request *request, int count )
}
/* read some more data into the read buffer */
-static BOOL read_more_data( struct request *request, int maxlen, BOOL notify )
+static DWORD read_more_data( struct request *request, int maxlen, BOOL notify )
{
int len;
- BOOL ret;
+ DWORD ret;
- if (request->read_chunked_eof) return FALSE;
+ if (request->read_chunked_eof) return ERROR_INSUFFICIENT_BUFFER;
if (request->read_size && request->read_pos)
{
@@ -1761,8 +1737,9 @@ static BOOL read_more_data( struct request *request, int maxlen, BOOL notify )
}
/* discard data contents until we reach end of line */
-static BOOL discard_eol( struct request *request, BOOL notify )
+static DWORD discard_eol( struct request *request, BOOL notify )
{
+ DWORD ret;
do
{
char *eol = memchr( request->read_buf + request->read_pos, '\n', request->read_size );
@@ -1772,22 +1749,22 @@ static BOOL discard_eol( struct request *request, BOOL notify )
break;
}
request->read_pos = request->read_size = 0; /* discard everything */
- if (!read_more_data( request, -1, notify )) return FALSE;
+ if ((ret = read_more_data( request, -1, notify ))) return ret;
} while (request->read_size);
- return TRUE;
+ return ERROR_SUCCESS;
}
/* read the size of the next chunk */
-static BOOL start_next_chunk( struct request *request, BOOL notify )
+static DWORD start_next_chunk( struct request *request, BOOL notify )
{
- DWORD chunk_size = 0;
+ DWORD ret, chunk_size = 0;
assert(!request->read_chunked_size || request->read_chunked_size == ~0u);
- if (request->read_chunked_eof) return FALSE;
+ if (request->read_chunked_eof) return ERROR_INSUFFICIENT_BUFFER;
/* read terminator for the previous chunk */
- if (!request->read_chunked_size && !discard_eol( request, notify )) return FALSE;
+ if (!request->read_chunked_size && (ret = discard_eol( request, notify ))) return ret;
for (;;)
{
@@ -1811,26 +1788,27 @@ static BOOL start_next_chunk( struct request *request, BOOL notify )
}
remove_data( request, 1 );
}
- if (!read_more_data( request, -1, notify )) return FALSE;
+ if ((ret = read_more_data( request, -1, notify ))) return ret;
if (!request->read_size)
{
request->content_length = request->content_read = 0;
request->read_chunked_size = 0;
- return TRUE;
+ return ERROR_SUCCESS;
}
}
}
-static BOOL refill_buffer( struct request *request, BOOL notify )
+static DWORD refill_buffer( struct request *request, BOOL notify )
{
int len = sizeof(request->read_buf);
+ DWORD ret;
if (request->read_chunked)
{
- if (request->read_chunked_eof) return FALSE;
+ if (request->read_chunked_eof) return ERROR_INSUFFICIENT_BUFFER;
if (request->read_chunked_size == ~0u || !request->read_chunked_size)
{
- if (!start_next_chunk( request, notify )) return FALSE;
+ if ((ret = start_next_chunk( request, notify ))) return ret;
}
len = min( len, request->read_chunked_size );
}
@@ -1839,10 +1817,10 @@ static BOOL refill_buffer( struct request *request, BOOL notify )
len = min( len, request->content_length - request->content_read );
}
- if (len <= request->read_size) return TRUE;
- if (!read_more_data( request, len, notify )) return FALSE;
+ if (len <= request->read_size) return ERROR_SUCCESS;
+ if ((ret = read_more_data( request, len, notify ))) return ret;
if (!request->read_size) request->content_length = request->content_read = 0;
- return TRUE;
+ return ERROR_SUCCESS;
}
static void finished_reading( struct request *request )
@@ -1854,8 +1832,8 @@ static void finished_reading( struct request *request )
if (!request->netconn) return;
if (request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE) close = TRUE;
- else if (query_headers( request, WINHTTP_QUERY_CONNECTION, NULL, connection, &size, NULL ) ||
- query_headers( request, WINHTTP_QUERY_PROXY_CONNECTION, NULL, connection, &size, NULL ))
+ else if (!query_headers( request, WINHTTP_QUERY_CONNECTION, NULL, connection, &size, NULL ) ||
+ !query_headers( request, WINHTTP_QUERY_PROXY_CONNECTION, NULL, connection, &size, NULL ))
{
if (!wcsicmp( connection, L"close" )) close = TRUE;
}
@@ -1886,10 +1864,10 @@ static BOOL end_of_read_data( struct request *request )
return (request->content_length == request->content_read);
}
-static BOOL read_data( struct request *request, void *buffer, DWORD size, DWORD *read, BOOL async )
+static DWORD read_data( struct request *request, void *buffer, DWORD size, DWORD *read, BOOL async )
{
int count, bytes_read = 0;
- BOOL ret = TRUE;
+ DWORD ret = ERROR_SUCCESS;
if (end_of_read_data( request )) goto done;
@@ -1897,7 +1875,7 @@ static BOOL read_data( struct request *request, void *buffer, DWORD size, DWORD
{
if (!(count = get_available_data( request )))
{
- if (!(ret = refill_buffer( request, async ))) goto done;
+ if ((ret = refill_buffer( request, async ))) goto done;
if (!(count = get_available_data( request ))) goto done;
}
count = min( count, size );
@@ -1915,17 +1893,17 @@ done:
TRACE( "retrieved %u bytes (%u/%u)\n", bytes_read, request->content_read, request->content_length );
if (async)
{
- if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, buffer, bytes_read );
+ if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, buffer, bytes_read );
else
{
WINHTTP_ASYNC_RESULT result;
result.dwResult = API_READ_DATA;
- result.dwError = GetLastError();
+ result.dwError = ret;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
}
}
- if (ret && read) *read = bytes_read;
+ if (!ret && read) *read = bytes_read;
if (end_of_read_data( request )) finished_reading( request );
return ret;
}
@@ -1945,7 +1923,7 @@ static void drain_content( struct request *request )
if (bytes_total >= bytes_left) return;
size = min( sizeof(buffer), bytes_left - bytes_total );
}
- if (!read_data( request, buffer, size, &bytes_read, FALSE ) || !bytes_read) return;
+ if (read_data( request, buffer, size, &bytes_read, FALSE ) || !bytes_read) return;
bytes_total += bytes_read;
}
}
@@ -2120,15 +2098,14 @@ static char *build_wire_request( struct request *request, DWORD *len )
return ret;
}
-static BOOL send_request( struct request *request, const WCHAR *headers, DWORD headers_len, void *optional,
- DWORD optional_len, DWORD total_len, DWORD_PTR context, BOOL async )
+static DWORD send_request( struct request *request, const WCHAR *headers, DWORD headers_len, void *optional,
+ DWORD optional_len, DWORD total_len, DWORD_PTR context, BOOL async )
{
- BOOL ret = FALSE;
struct connect *connect = request->connect;
struct session *session = connect->session;
char *wire_req;
int bytes_sent;
- DWORD len;
+ DWORD ret, len;
clear_response_headers( request );
drain_content( request );
@@ -2157,32 +2134,37 @@ static BOOL send_request( struct request *request, const WCHAR *headers, DWORD h
process_header( request, L"Pragma", L"no-cache", WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
process_header( request, L"Cache-Control", L"no-cache", WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
}
- if (headers && !add_request_headers( request, headers, headers_len, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))
+ if (headers && (ret = add_request_headers( request, headers, headers_len,
+ WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE )))
{
- TRACE("failed to add request headers\n");
- return FALSE;
+ TRACE("failed to add request headers: %u\n", ret);
+ return ret;
}
- if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES) && !add_cookie_headers( request ))
+ if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES) && (ret = add_cookie_headers( request )))
{
- WARN("failed to add cookie headers\n");
- return FALSE;
+ WARN("failed to add cookie headers: %u\n", ret);
+ return ret;
}
if (context) request->hdr.context = context;
- if (!(ret = open_connection( request ))) goto end;
- if (!(wire_req = build_wire_request( request, &len ))) goto end;
+ if ((ret = open_connection( request ))) goto end;
+ if (!(wire_req = build_wire_request( request, &len )))
+ {
+ ret = ERROR_OUTOFMEMORY;
+ goto end;
+ }
TRACE("full request: %s\n", debugstr_a(wire_req));
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST, NULL, 0 );
ret = netconn_send( request->netconn, wire_req, len, &bytes_sent );
heap_free( wire_req );
- if (!ret) goto end;
+ if (ret) goto end;
if (optional_len)
{
- if (!netconn_send( request->netconn, optional, optional_len, &bytes_sent )) goto end;
+ if ((ret = netconn_send( request->netconn, optional, optional_len, &bytes_sent ))) goto end;
request->optional = optional;
request->optional_len = optional_len;
len += optional_len;
@@ -2192,12 +2174,12 @@ static BOOL send_request( struct request *request, const WCHAR *headers, DWORD h
end:
if (async)
{
- if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NULL, 0 );
+ if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NULL, 0 );
else
{
WINHTTP_ASYNC_RESULT result;
result.dwResult = API_SEND_REQUEST;
- result.dwError = GetLastError();
+ result.dwError = ret;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
}
}
@@ -2217,7 +2199,7 @@ static void task_send_request( struct task_header *task )
BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD headers_len,
LPVOID optional, DWORD optional_len, DWORD total_len, DWORD_PTR context )
{
- BOOL ret;
+ DWORD ret;
struct request *request;
TRACE("%p, %s, %u, %p, %u, %u, %lx\n", hrequest, debugstr_wn(headers, headers_len), headers_len, optional,
@@ -2258,19 +2240,18 @@ BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD heade
ret = send_request( request, headers, headers_len, optional, optional_len, total_len, context, FALSE );
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
-static BOOL set_credentials( struct request *request, DWORD target, DWORD scheme_flag, const WCHAR *username,
- const WCHAR *password )
+static DWORD set_credentials( struct request *request, DWORD target, DWORD scheme_flag, const WCHAR *username,
+ const WCHAR *password )
{
enum auth_scheme scheme = scheme_from_flag( scheme_flag );
if (scheme == SCHEME_INVALID || ((scheme == SCHEME_BASIC || scheme == SCHEME_DIGEST) && (!username || !password)))
{
- SetLastError( ERROR_INVALID_PARAMETER );
- return FALSE;
+ return ERROR_INVALID_PARAMETER;
}
switch (target)
{
@@ -2278,29 +2259,29 @@ static BOOL set_credentials( struct request *request, DWORD target, DWORD scheme
{
heap_free( request->creds[TARGET_SERVER][scheme].username );
if (!username) request->creds[TARGET_SERVER][scheme].username = NULL;
- else if (!(request->creds[TARGET_SERVER][scheme].username = strdupW( username ))) return FALSE;
+ else if (!(request->creds[TARGET_SERVER][scheme].username = strdupW( username ))) return ERROR_OUTOFMEMORY;
heap_free( request->creds[TARGET_SERVER][scheme].password );
if (!password) request->creds[TARGET_SERVER][scheme].password = NULL;
- else if (!(request->creds[TARGET_SERVER][scheme].password = strdupW( password ))) return FALSE;
+ else if (!(request->creds[TARGET_SERVER][scheme].password = strdupW( password ))) return ERROR_OUTOFMEMORY;
break;
}
case WINHTTP_AUTH_TARGET_PROXY:
{
heap_free( request->creds[TARGET_PROXY][scheme].username );
if (!username) request->creds[TARGET_PROXY][scheme].username = NULL;
- else if (!(request->creds[TARGET_PROXY][scheme].username = strdupW( username ))) return FALSE;
+ else if (!(request->creds[TARGET_PROXY][scheme].username = strdupW( username ))) return ERROR_OUTOFMEMORY;
heap_free( request->creds[TARGET_PROXY][scheme].password );
if (!password) request->creds[TARGET_PROXY][scheme].password = NULL;
- else if (!(request->creds[TARGET_PROXY][scheme].password = strdupW( password ))) return FALSE;
+ else if (!(request->creds[TARGET_PROXY][scheme].password = strdupW( password ))) return ERROR_OUTOFMEMORY;
break;
}
default:
WARN("unknown target %u\n", target);
- return FALSE;
+ return ERROR_INVALID_PARAMETER;
}
- return TRUE;
+ return ERROR_SUCCESS;
}
/***********************************************************************
@@ -2309,7 +2290,7 @@ static BOOL set_credentials( struct request *request, DWORD target, DWORD scheme
BOOL WINAPI WinHttpSetCredentials( HINTERNET hrequest, DWORD target, DWORD scheme, LPCWSTR username,
LPCWSTR password, LPVOID params )
{
- BOOL ret;
+ DWORD ret;
struct request *request;
TRACE("%p, %x, 0x%08x, %s, %p, %p\n", hrequest, target, scheme, debugstr_w(username), password, params);
@@ -2329,13 +2310,13 @@ BOOL WINAPI WinHttpSetCredentials( HINTERNET hrequest, DWORD target, DWORD schem
ret = set_credentials( request, target, scheme, username, password );
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
-static BOOL handle_authorization( struct request *request, DWORD status )
+static DWORD handle_authorization( struct request *request, DWORD status )
{
- DWORD i, schemes, first, level, target;
+ DWORD ret, i, schemes, first, level, target;
switch (status)
{
@@ -2350,24 +2331,24 @@ static BOOL handle_authorization( struct request *request, DWORD status )
break;
default:
- WARN("unhandled status %u\n", status);
- return FALSE;
+ ERR("unhandled status %u\n", status);
+ return ERROR_WINHTTP_INTERNAL_ERROR;
}
- if (!query_auth_schemes( request, level, &schemes, &first )) return FALSE;
- if (do_authorization( request, target, first )) return TRUE;
+ if ((ret = query_auth_schemes( request, level, &schemes, &first ))) return ret;
+ if (do_authorization( request, target, first )) return ERROR_SUCCESS;
schemes &= ~first;
for (i = 0; i < ARRAY_SIZE( auth_schemes ); i++)
{
if (!(schemes & auth_schemes[i].scheme)) continue;
- if (do_authorization( request, target, auth_schemes[i].scheme )) return TRUE;
+ if (do_authorization( request, target, auth_schemes[i].scheme )) return ERROR_SUCCESS;
}
- return FALSE;
+ return ERROR_WINHTTP_LOGIN_FAILURE;
}
/* set the request content length based on the headers */
-static DWORD set_content_length( struct request *request, DWORD status )
+static void set_content_length( struct request *request, DWORD status )
{
WCHAR encoding[20];
DWORD buflen = sizeof(request->content_length);
@@ -2376,12 +2357,12 @@ static DWORD set_content_length( struct request *request, DWORD status )
request->content_length = 0;
else
{
- if (!query_headers( request, WINHTTP_QUERY_CONTENT_LENGTH|WINHTTP_QUERY_FLAG_NUMBER,
- NULL, &request->content_length, &buflen, NULL ))
+ if (query_headers( request, WINHTTP_QUERY_CONTENT_LENGTH|WINHTTP_QUERY_FLAG_NUMBER,
+ NULL, &request->content_length, &buflen, NULL ))
request->content_length = ~0u;
buflen = sizeof(encoding);
- if (query_headers( request, WINHTTP_QUERY_TRANSFER_ENCODING, NULL, encoding, &buflen, NULL ) &&
+ if (!query_headers( request, WINHTTP_QUERY_TRANSFER_ENCODING, NULL, encoding, &buflen, NULL ) &&
!wcsicmp( encoding, L"chunked" ))
{
request->content_length = ~0u;
@@ -2391,12 +2372,12 @@ static DWORD set_content_length( struct request *request, DWORD status )
}
}
request->content_read = 0;
- return request->content_length;
}
-static BOOL read_line( struct request *request, char *buffer, DWORD *len )
+static DWORD read_line( struct request *request, char *buffer, DWORD *len )
{
int count, bytes_read, pos = 0;
+ DWORD ret;
for (;;)
{
@@ -2414,12 +2395,12 @@ static BOOL read_line( struct request *request, char *buffer, DWORD *len )
remove_data( request, bytes_read );
if (eol) break;
- if (!read_more_data( request, -1, TRUE )) return FALSE;
+ if ((ret = read_more_data( request, -1, TRUE ))) return ret;
if (!request->read_size)
{
*len = 0;
TRACE("returning empty string\n");
- return FALSE;
+ return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
}
}
if (pos < *len)
@@ -2429,32 +2410,32 @@ static BOOL read_line( struct request *request, char *buffer, DWORD *len )
}
buffer[*len - 1] = 0;
TRACE("returning %s\n", debugstr_a(buffer));
- return TRUE;
+ return ERROR_SUCCESS;
}
#define MAX_REPLY_LEN 1460
#define INITIAL_HEADER_BUFFER_LEN 512
-static BOOL read_reply( struct request *request )
+static DWORD read_reply( struct request *request )
{
char buffer[MAX_REPLY_LEN];
- DWORD buflen, len, offset, crlf_len = 2; /* lstrlenW(crlf) */
+ DWORD ret, buflen, len, offset, crlf_len = 2; /* lstrlenW(crlf) */
char *status_code, *status_text;
WCHAR *versionW, *status_textW, *raw_headers;
WCHAR status_codeW[4]; /* sizeof("nnn") */
- if (!request->netconn) return FALSE;
+ if (!request->netconn) return ERROR_WINHTTP_INCORRECT_HANDLE_STATE;
do
{
buflen = MAX_REPLY_LEN;
- if (!read_line( request, buffer, &buflen )) return FALSE;
+ if ((ret = read_line( request, buffer, &buflen ))) return ret;
/* first line should look like 'HTTP/1.x nnn OK' where nnn is the status code */
- if (!(status_code = strchr( buffer, ' ' ))) return FALSE;
+ if (!(status_code = strchr( buffer, ' ' ))) return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
status_code++;
- if (!(status_text = strchr( status_code, ' ' ))) return FALSE;
- if ((len = status_text - status_code) != sizeof("nnn") - 1) return FALSE;
+ if (!(status_text = strchr( status_code, ' ' ))) return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
+ if ((len = status_text - status_code) != sizeof("nnn") - 1) return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
status_text++;
TRACE("version [%s] status code [%s] status text [%s]\n",
@@ -2467,12 +2448,11 @@ static BOOL read_reply( struct request *request )
/* we rely on the fact that the protocol is ascii */
MultiByteToWideChar( CP_ACP, 0, status_code, len, status_codeW, len );
status_codeW[len] = 0;
- if (!(process_header( request, L"Status", status_codeW,
- WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, FALSE )))
- return FALSE;
+ if ((ret = process_header( request, L"Status", status_codeW,
+ WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, FALSE ))) return ret;
len = status_code - buffer;
- if (!(versionW = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
+ if (!(versionW = heap_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
MultiByteToWideChar( CP_ACP, 0, buffer, len - 1, versionW, len -1 );
versionW[len - 1] = 0;
@@ -2480,14 +2460,14 @@ static BOOL read_reply( struct request *request )
request->version = versionW;
len = buflen - (status_text - buffer);
- if (!(status_textW = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
+ if (!(status_textW = heap_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
MultiByteToWideChar( CP_ACP, 0, status_text, len, status_textW, len );
heap_free( request->status_text );
request->status_text = status_textW;
len = max( buflen + crlf_len, INITIAL_HEADER_BUFFER_LEN );
- if (!(raw_headers = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
+ if (!(raw_headers = heap_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
MultiByteToWideChar( CP_ACP, 0, buffer, buflen, raw_headers, buflen );
memcpy( raw_headers + buflen - 1, L"\r\n", sizeof(L"\r\n") );
@@ -2500,14 +2480,14 @@ static BOOL read_reply( struct request *request )
struct header *header;
buflen = MAX_REPLY_LEN;
- if (!read_line( request, buffer, &buflen )) return TRUE;
+ if (read_line( request, buffer, &buflen )) return ERROR_SUCCESS;
if (!*buffer) buflen = 1;
while (len - offset < buflen + crlf_len)
{
WCHAR *tmp;
len *= 2;
- if (!(tmp = heap_realloc( raw_headers, len * sizeof(WCHAR) ))) return FALSE;
+ if (!(tmp = heap_realloc( raw_headers, len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
request->raw_headers = raw_headers = tmp;
}
if (!*buffer)
@@ -2518,7 +2498,7 @@ static BOOL read_reply( struct request *request )
MultiByteToWideChar( CP_ACP, 0, buffer, buflen, raw_headers + offset, buflen );
if (!(header = parse_header( raw_headers + offset ))) break;
- if (!(process_header( request, header->field, header->value, WINHTTP_ADDREQ_FLAG_ADD, FALSE )))
+ if ((ret = process_header( request, header->field, header->value, WINHTTP_ADDREQ_FLAG_ADD, FALSE )))
{
free_header( header );
break;
@@ -2529,7 +2509,7 @@ static BOOL read_reply( struct request *request )
}
TRACE("raw headers: %s\n", debugstr_w(raw_headers));
- return TRUE;
+ return ret;
}
static void record_cookies( struct request *request )
@@ -2546,31 +2526,34 @@ static void record_cookies( struct request *request )
}
}
-static WCHAR *get_redirect_url( struct request *request, DWORD *len )
+static DWORD get_redirect_url( struct request *request, WCHAR **ret_url, DWORD *ret_len )
{
- DWORD size;
- WCHAR *ret;
+ DWORD size, ret;
+ WCHAR *url;
- query_headers( request, WINHTTP_QUERY_LOCATION, NULL, NULL, &size, NULL );
- if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return NULL;
- if (!(ret = heap_alloc( size ))) return NULL;
- *len = size / sizeof(WCHAR) - 1;
- if (query_headers( request, WINHTTP_QUERY_LOCATION, NULL, ret, &size, NULL )) return ret;
- heap_free( ret );
- return NULL;
+ ret = query_headers( request, WINHTTP_QUERY_LOCATION, NULL, NULL, &size, NULL );
+ if (ret != ERROR_INSUFFICIENT_BUFFER) return ret;
+ if (!(url = heap_alloc( size ))) return ERROR_OUTOFMEMORY;
+ if ((ret = query_headers( request, WINHTTP_QUERY_LOCATION, NULL, url, &size, NULL )))
+ {
+ heap_free( url );
+ return ret;
+ }
+ *ret_url = url;
+ *ret_len = size / sizeof(WCHAR);
+ return ERROR_SUCCESS;
}
-static BOOL handle_redirect( struct request *request, DWORD status )
+static DWORD handle_redirect( struct request *request, DWORD status )
{
- BOOL ret = FALSE;
- DWORD len, len_loc;
+ DWORD ret, len, len_loc = 0;
URL_COMPONENTS uc;
struct connect *connect = request->connect;
INTERNET_PORT port;
- WCHAR *hostname = NULL, *location;
+ WCHAR *hostname = NULL, *location = NULL;
int index;
- if (!(location = get_redirect_url( request, &len_loc ))) return FALSE;
+ if ((ret = get_redirect_url( request, &location, &len_loc ))) return ret;
memset( &uc, 0, sizeof(uc) );
uc.dwStructSize = sizeof(uc);
@@ -2580,6 +2563,7 @@ static BOOL handle_redirect( struct request *request, DWORD status )
{
WCHAR *path, *p;
+ ret = ERROR_OUTOFMEMORY;
if (location[0] == '/')
{
if (!(path = heap_alloc( (len_loc + 1) * sizeof(WCHAR) ))) goto end;
@@ -2605,7 +2589,11 @@ static BOOL handle_redirect( struct request *request, DWORD status )
{
if (uc.nScheme == INTERNET_SCHEME_HTTP && request->hdr.flags & WINHTTP_FLAG_SECURE)
{
- if (request->hdr.redirect_policy == WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP) goto end;
+ if (request->hdr.redirect_policy == WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP)
+ {
+ ret = ERROR_WINHTTP_REDIRECT_FAILED;
+ goto end;
+ }
TRACE("redirect from secure page to non-secure page\n");
request->hdr.flags &= ~WINHTTP_FLAG_SECURE;
}
@@ -2618,7 +2606,11 @@ static BOOL handle_redirect( struct request *request, DWORD status )
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REDIRECT, location, len_loc + 1 );
len = uc.dwHostNameLength;
- if (!(hostname = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
+ if (!(hostname = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ {
+ ret = ERROR_OUTOFMEMORY;
+ goto end;
+ }
memcpy( hostname, uc.lpszHostName, len * sizeof(WCHAR) );
hostname[len] = 0;
@@ -2628,7 +2620,11 @@ static BOOL handle_redirect( struct request *request, DWORD status )
heap_free( connect->hostname );
connect->hostname = hostname;
connect->hostport = port;
- if (!(ret = set_server_for_hostname( connect, hostname, port ))) goto end;
+ if (!set_server_for_hostname( connect, hostname, port ))
+ {
+ ret = ERROR_OUTOFMEMORY;
+ goto end;
+ }
netconn_close( request->netconn );
request->netconn = NULL;
@@ -2638,8 +2634,8 @@ static BOOL handle_redirect( struct request *request, DWORD status )
}
else heap_free( hostname );
- if (!(ret = add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))) goto end;
- if (!(ret = open_connection( request ))) goto end;
+ if ((ret = add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))) goto end;
+ if ((ret = open_connection( request ))) goto end;
heap_free( request->path );
request->path = NULL;
@@ -2664,7 +2660,6 @@ static BOOL handle_redirect( struct request *request, DWORD status )
request->optional = NULL;
request->optional_len = 0;
}
- ret = TRUE;
end:
heap_free( location );
@@ -2678,7 +2673,7 @@ static BOOL is_passport_request( struct request *request )
DWORD len = ARRAY_SIZE(buf);
if (!(request->connect->session->passport_flags & WINHTTP_ENABLE_PASSPORT_AUTH) ||
- !query_headers( request, WINHTTP_QUERY_WWW_AUTHENTICATE, NULL, buf, &len, NULL )) return FALSE;
+ query_headers( request, WINHTTP_QUERY_WWW_AUTHENTICATE, NULL, buf, &len, NULL )) return FALSE;
if (!wcsnicmp( buf, passportW, ARRAY_SIZE(passportW) ) &&
(buf[ARRAY_SIZE(passportW)] == ' ' || !buf[ARRAY_SIZE(passportW)])) return TRUE;
@@ -2686,13 +2681,13 @@ static BOOL is_passport_request( struct request *request )
return FALSE;
}
-static BOOL handle_passport_redirect( struct request *request )
+static DWORD handle_passport_redirect( struct request *request )
{
- DWORD flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE;
+ DWORD ret, flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE;
int i, len = lstrlenW( request->raw_headers );
WCHAR *p = request->raw_headers;
- if (!process_header( request, L"Status", L"401", flags, FALSE )) return FALSE;
+ if ((ret = process_header( request, L"Status", L"401", flags, FALSE ))) return ret;
for (i = 0; i < len; i++)
{
@@ -2703,31 +2698,23 @@ static BOOL handle_passport_redirect( struct request *request )
break;
}
}
- return TRUE;
+ return ERROR_SUCCESS;
}
-static BOOL receive_response( struct request *request, BOOL async )
+static DWORD receive_response( struct request *request, BOOL async )
{
- BOOL ret;
- DWORD size, query, status;
+ DWORD ret, size, query, status;
- if (!request->netconn)
- {
- SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_STATE );
- return FALSE;
- }
+ if (!request->netconn) return ERROR_WINHTTP_INCORRECT_HANDLE_STATE;
netconn_set_timeout( request->netconn, FALSE, request->receive_response_timeout );
for (;;)
{
- if (!(ret = read_reply( request )))
- {
- SetLastError( ERROR_WINHTTP_INVALID_SERVER_RESPONSE );
- break;
- }
+ if ((ret = read_reply( request ))) break;
+
size = sizeof(DWORD);
query = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
- if (!(ret = query_headers( request, query, NULL, &status, &size, NULL ))) break;
+ if ((ret = query_headers( request, query, NULL, &status, &size, NULL ))) break;
set_content_length( request, status );
@@ -2742,19 +2729,19 @@ static BOOL receive_response( struct request *request, BOOL async )
if (request->hdr.disable_flags & WINHTTP_DISABLE_REDIRECTS ||
request->hdr.redirect_policy == WINHTTP_OPTION_REDIRECT_POLICY_NEVER) break;
- if (!(ret = handle_redirect( request, status ))) break;
+ if ((ret = handle_redirect( request, status ))) break;
/* recurse synchronously */
- if ((ret = send_request( request, NULL, 0, request->optional, request->optional_len, 0, 0, FALSE ))) continue;
+ if (!(ret = send_request( request, NULL, 0, request->optional, request->optional_len, 0, 0, FALSE ))) continue;
}
else if (status == HTTP_STATUS_DENIED || status == HTTP_STATUS_PROXY_AUTH_REQ)
{
if (request->hdr.disable_flags & WINHTTP_DISABLE_AUTHENTICATION) break;
- if (!handle_authorization( request, status )) break;
+ if ((ret = handle_authorization( request, status ))) break;
/* recurse synchronously */
- if ((ret = send_request( request, NULL, 0, request->optional, request->optional_len, 0, 0, FALSE ))) continue;
+ if (!(ret = send_request( request, NULL, 0, request->optional, request->optional_len, 0, 0, FALSE ))) continue;
}
break;
}
@@ -2764,12 +2751,12 @@ static BOOL receive_response( struct request *request, BOOL async )
if (async)
{
- if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NULL, 0 );
+ if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NULL, 0 );
else
{
WINHTTP_ASYNC_RESULT result;
result.dwResult = API_RECEIVE_RESPONSE;
- result.dwError = GetLastError();
+ result.dwError = ret;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
}
}
@@ -2787,7 +2774,7 @@ static void task_receive_response( struct task_header *task )
*/
BOOL WINAPI WinHttpReceiveResponse( HINTERNET hrequest, LPVOID reserved )
{
- BOOL ret;
+ DWORD ret;
struct request *request;
TRACE("%p, %p\n", hrequest, reserved);
@@ -2819,14 +2806,13 @@ BOOL WINAPI WinHttpReceiveResponse( HINTERNET hrequest, LPVOID reserved )
ret = receive_response( request, FALSE );
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
-static BOOL query_data_available( struct request *request, DWORD *available, BOOL async )
+static DWORD query_data_available( struct request *request, DWORD *available, BOOL async )
{
- DWORD count = 0;
- BOOL ret = TRUE;
+ DWORD ret = ERROR_SUCCESS, count = 0;
if (end_of_read_data( request )) goto done;
@@ -2834,7 +2820,7 @@ static BOOL query_data_available( struct request *request, DWORD *available, BOO
if (!request->read_chunked && request->netconn) count += netconn_query_data_available( request->netconn );
if (!count)
{
- if (!(ret = refill_buffer( request, async ))) goto done;
+ if ((ret = refill_buffer( request, async ))) goto done;
count = get_available_data( request );
if (!request->read_chunked && request->netconn) count += netconn_query_data_available( request->netconn );
}
@@ -2843,17 +2829,17 @@ done:
TRACE("%u bytes available\n", count);
if (async)
{
- if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE, &count, sizeof(count) );
+ if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE, &count, sizeof(count) );
else
{
WINHTTP_ASYNC_RESULT result;
result.dwResult = API_QUERY_DATA_AVAILABLE;
- result.dwError = GetLastError();
+ result.dwError = ret;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
}
}
- if (ret && available) *available = count;
+ if (!ret && available) *available = count;
return ret;
}
@@ -2868,7 +2854,7 @@ static void task_query_data_available( struct task_header *task )
*/
BOOL WINAPI WinHttpQueryDataAvailable( HINTERNET hrequest, LPDWORD available )
{
- BOOL ret;
+ DWORD ret;
struct request *request;
TRACE("%p, %p\n", hrequest, available);
@@ -2901,8 +2887,8 @@ BOOL WINAPI WinHttpQueryDataAvailable( HINTERNET hrequest, LPDWORD available )
ret = query_data_available( request, available, FALSE );
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
static void task_read_data( struct task_header *task )
@@ -2916,7 +2902,7 @@ static void task_read_data( struct task_header *task )
*/
BOOL WINAPI WinHttpReadData( HINTERNET hrequest, LPVOID buffer, DWORD to_read, LPDWORD read )
{
- BOOL ret;
+ DWORD ret;
struct request *request;
TRACE("%p, %p, %d, %p\n", hrequest, buffer, to_read, read);
@@ -2951,29 +2937,29 @@ BOOL WINAPI WinHttpReadData( HINTERNET hrequest, LPVOID buffer, DWORD to_read, L
ret = read_data( request, buffer, to_read, read, FALSE );
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
-static BOOL write_data( struct request *request, const void *buffer, DWORD to_write, DWORD *written, BOOL async )
+static DWORD write_data( struct request *request, const void *buffer, DWORD to_write, DWORD *written, BOOL async )
{
- BOOL ret;
+ DWORD ret;
int num_bytes;
ret = netconn_send( request->netconn, buffer, to_write, &num_bytes );
if (async)
{
- if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE, &num_bytes, sizeof(num_bytes) );
+ if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE, &num_bytes, sizeof(num_bytes) );
else
{
WINHTTP_ASYNC_RESULT result;
result.dwResult = API_WRITE_DATA;
- result.dwError = GetLastError();
+ result.dwError = ret;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
}
}
- if (ret && written) *written = num_bytes;
+ if (!ret && written) *written = num_bytes;
return ret;
}
@@ -2988,7 +2974,7 @@ static void task_write_data( struct task_header *task )
*/
BOOL WINAPI WinHttpWriteData( HINTERNET hrequest, LPCVOID buffer, DWORD to_write, LPDWORD written )
{
- BOOL ret;
+ DWORD ret;
struct request *request;
TRACE("%p, %p, %d, %p\n", hrequest, buffer, to_write, written);
@@ -3023,8 +3009,8 @@ BOOL WINAPI WinHttpWriteData( HINTERNET hrequest, LPCVOID buffer, DWORD to_write
ret = write_data( request, buffer, to_write, written, FALSE );
release_object( &request->hdr );
- if (ret) SetLastError( ERROR_SUCCESS );
- return ret;
+ SetLastError( ret );
+ return !ret;
}
enum request_state
diff --git a/dlls/winhttp/session.c b/dlls/winhttp/session.c
index dabbe9b195..24455d858a 100644
--- a/dlls/winhttp/session.c
+++ b/dlls/winhttp/session.c
@@ -1063,7 +1063,7 @@ static BOOL add_accept_types_header( struct request *request, const WCHAR **type
if (!types) return TRUE;
while (*types)
{
- if (!process_header( request, L"Accept", *types, flags, TRUE )) return FALSE;
+ if (process_header( request, L"Accept", *types, flags, TRUE )) return FALSE;
types++;
}
return TRUE;
diff --git a/dlls/winhttp/winhttp_private.h b/dlls/winhttp/winhttp_private.h
index b3f7092d85..657f82f642 100644
--- a/dlls/winhttp/winhttp_private.h
+++ b/dlls/winhttp/winhttp_private.h
@@ -256,27 +256,27 @@ void send_callback( struct object_header *, DWORD, LPVOID, DWORD ) DECLSPEC_HIDD
void close_connection( struct request * ) DECLSPEC_HIDDEN;
void netconn_close( struct netconn * ) DECLSPEC_HIDDEN;
-struct netconn *netconn_create( struct hostdata *, const struct sockaddr_storage *, int ) DECLSPEC_HIDDEN;
+DWORD netconn_create( struct hostdata *, const struct sockaddr_storage *, int, struct netconn ** ) DECLSPEC_HIDDEN;
void netconn_unload( void ) DECLSPEC_HIDDEN;
ULONG netconn_query_data_available( struct netconn * ) DECLSPEC_HIDDEN;
-BOOL netconn_recv( struct netconn *, void *, size_t, int, int * ) DECLSPEC_HIDDEN;
-BOOL netconn_resolve( WCHAR *, INTERNET_PORT, struct sockaddr_storage *, int ) DECLSPEC_HIDDEN;
-BOOL netconn_secure_connect( struct netconn *, WCHAR *, DWORD, CredHandle *, BOOL ) DECLSPEC_HIDDEN;
-BOOL netconn_send( struct netconn *, const void *, size_t, int * ) DECLSPEC_HIDDEN;
+DWORD netconn_recv( struct netconn *, void *, size_t, int, int * ) DECLSPEC_HIDDEN;
+DWORD netconn_resolve( WCHAR *, INTERNET_PORT, struct sockaddr_storage *, int ) DECLSPEC_HIDDEN;
+DWORD netconn_secure_connect( struct netconn *, WCHAR *, DWORD, CredHandle *, BOOL ) DECLSPEC_HIDDEN;
+DWORD netconn_send( struct netconn *, const void *, size_t, int * ) DECLSPEC_HIDDEN;
DWORD netconn_set_timeout( struct netconn *, BOOL, int ) DECLSPEC_HIDDEN;
BOOL netconn_is_alive( struct netconn * ) DECLSPEC_HIDDEN;
const void *netconn_get_certificate( struct netconn * ) DECLSPEC_HIDDEN;
int netconn_get_cipher_strength( struct netconn * ) DECLSPEC_HIDDEN;
BOOL set_cookies( struct request *, const WCHAR * ) DECLSPEC_HIDDEN;
-BOOL add_cookie_headers( struct request * ) DECLSPEC_HIDDEN;
-BOOL add_request_headers( struct request *, const WCHAR *, DWORD, DWORD ) DECLSPEC_HIDDEN;
+DWORD add_cookie_headers( struct request * ) DECLSPEC_HIDDEN;
+DWORD add_request_headers( struct request *, const WCHAR *, DWORD, DWORD ) DECLSPEC_HIDDEN;
void destroy_cookies( struct session * ) DECLSPEC_HIDDEN;
BOOL set_server_for_hostname( struct connect *, const WCHAR *, INTERNET_PORT ) DECLSPEC_HIDDEN;
void destroy_authinfo( struct authinfo * ) DECLSPEC_HIDDEN;
void release_host( struct hostdata * ) DECLSPEC_HIDDEN;
-BOOL process_header( struct request *, const WCHAR *, const WCHAR *, DWORD, BOOL ) DECLSPEC_HIDDEN;
+DWORD process_header( struct request *, const WCHAR *, const WCHAR *, DWORD, BOOL ) DECLSPEC_HIDDEN;
extern HRESULT WinHttpRequest_create( void ** ) DECLSPEC_HIDDEN;
void release_typelib( void ) DECLSPEC_HIDDEN;
--
2.20.1
