Open-source Xbox-inspired desktop launcher for Xodus on Linux
TypeScript
WinHTTP response decompression and server certificate chain backport.
Based on Wine upstream commits by Hans Leidekker and Michael Green:
20b34866f318617c854818dc59fa7b8e8b87c0c6 (stream prerequisite),
335ae4237c72f09408e9b1b26b1d5f3891ed9a3c (decompression),
a1a13c25374dd5e80b5837fe574cfa967ac53efb (certificate chain),
93ef2498b391902e560f0e4aa64a7c74abe40b4a (handle state),
f27d14a21cfef776cbd5c7871a269066e3f1dc87 (retain verified TLS chain).
Adapted to the pinned Wine/HTTP2 transport. Decode only opted-in encodings,
keep query/read byte counts decoded, and reject invalid/truncated gzip data.
Wine LGPL-2.1-or-later notices remain in the corresponding source files.
diff --git a/dlls/winhttp/Makefile.in b/dlls/winhttp/Makefile.in
index c0f6080..cf7118b 100644
--- a/dlls/winhttp/Makefile.in
+++ b/dlls/winhttp/Makefile.in
@@ -1,8 +1,8 @@
EXTRADEFS = -D_WINHTTP_INTERNAL_
-EXTRAINCL = -I$(srcdir)/../../include
+EXTRAINCL = -I$(srcdir)/../../include $(ZLIB_PE_CFLAGS)
MODULE = winhttp.dll
IMPORTLIB = winhttp
-IMPORTS = uuid jsproxy user32 advapi32 ws2_32
+IMPORTS = $(ZLIB_PE_LIBS) uuid jsproxy user32 advapi32 ws2_32
DELAYIMPORTS = oleaut32 crypt32 secur32 iphlpapi dhcpcsvc
SOURCES = \
diff --git a/dlls/winhttp/net.c b/dlls/winhttp/net.c
index 4614426..b003eea 100644
--- a/dlls/winhttp/net.c
+++ b/dlls/winhttp/net.c
@@ -81,7 +81,8 @@ static int sock_recv(int fd, void *msg, size_t len, int flags)
return ret;
}
-static DWORD netconn_verify_cert( PCCERT_CONTEXT cert, WCHAR *server, DWORD security_flags, BOOL check_revocation )
+static DWORD netconn_verify_cert( PCCERT_CONTEXT cert, WCHAR *server, DWORD security_flags, BOOL check_revocation,
+ PCCERT_CHAIN_CONTEXT *ret_chain )
{
HCERTSTORE store = cert->hCertStore;
BOOL ret;
@@ -92,6 +93,7 @@ static DWORD netconn_verify_cert( PCCERT_CONTEXT cert, WCHAR *server, DWORD secu
DWORD err = ERROR_SUCCESS;
TRACE("verifying %s\n", debugstr_w( server ));
+ *ret_chain = NULL;
chainPara.RequestedUsage.Usage.cUsageIdentifier = 1;
chainPara.RequestedUsage.Usage.rgpszUsageIdentifier = server_auth;
ret = CertGetCertificateChain( NULL, cert, NULL, store, &chainPara,
@@ -169,7 +171,7 @@ static DWORD netconn_verify_cert( PCCERT_CONTEXT cert, WCHAR *server, DWORD secu
err = ERROR_WINHTTP_SECURE_INVALID_CERT;
}
}
- CertFreeCertificateChain( chain );
+ *ret_chain = chain;
}
else
err = ERROR_WINHTTP_SECURE_CHANNEL_ERROR;
@@ -301,6 +303,7 @@ void netconn_release( struct netconn *conn )
}
if (conn->socket != -1)
closesocket( conn->socket );
+ CertFreeCertificateChain( conn->chain );
release_host( conn->host );
if (conn->port)
CloseHandle( conn->port );
@@ -427,7 +430,7 @@ DWORD netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD secur
goto failed;
}
- res = netconn_verify_cert(cert, hostname, security_flags, check_revocation);
+ res = netconn_verify_cert(cert, hostname, security_flags, check_revocation, &conn->chain);
CertFreeCertificateContext(cert);
if(res != ERROR_SUCCESS) {
WARN( "cert verify failed: %lu\n", res );
@@ -725,6 +728,11 @@ DWORD netconn_set_timeout( struct netconn *netconn, BOOL send, int value )
return ERROR_SUCCESS;
}
+BOOL netconn_is_valid( struct netconn *netconn )
+{
+ return netconn && netconn->socket != -1;
+}
+
BOOL netconn_is_alive( struct netconn *netconn )
{
SIZE_T size;
diff --git a/dlls/winhttp/request.c b/dlls/winhttp/request.c
index a63dca8..426fb26 100644
--- a/dlls/winhttp/request.c
+++ b/dlls/winhttp/request.c
@@ -22,6 +22,7 @@
#include <assert.h>
#include <stdarg.h>
#include <wchar.h>
+#include <zlib.h>
#define COBJMACROS
#include "windef.h"
@@ -45,6 +46,551 @@ WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
#define ACTUAL_DEFAULT_RECEIVE_RESPONSE_TIMEOUT 21000
+/* return the size of data available to be read immediately */
+static DWORD query_data_stream( struct request *request )
+{
+ return request->data_stream->vtbl->query_data( request->data_stream, request );
+}
+
+static BOOL end_of_data_stream( struct request *request )
+{
+ return !request->read_size && request->data_stream->vtbl->end_of_data( request->data_stream, request );
+}
+
+static DWORD read_data_stream( struct request *request, char *buf, DWORD to_read, DWORD *read )
+{
+ DWORD ret = request->data_stream->vtbl->read_data( request->data_stream, request, buf, to_read, read );
+ if (ret) *read = 0;
+ request->content_read += *read;
+ return ret;
+}
+
+static void finished_reading( struct request *request );
+
+static DWORD drain_data_stream( struct request *request )
+{
+ DWORD ret;
+ if (!request->netconn) return ERROR_SUCCESS;
+ ret = request->data_stream->vtbl->drain_data( request->data_stream, request );
+ if (ret) close_connection( request );
+ else finished_reading( request );
+ return ret;
+}
+
+void destroy_data_stream( struct data_stream *stream )
+{
+ stream->vtbl->destroy( stream );
+}
+
+static void reset_data_stream( struct request *request )
+{
+ destroy_data_stream( request->data_stream );
+ request->data_stream = &request->netconn_stream.data_stream;
+ request->read_pos = request->read_size = request->netconn_stream.content_read = 0;
+}
+
+static DWORD netconn_query_data( struct data_stream *stream, struct request *request )
+{
+ if (!request->netconn) return request->read_size;
+ return request->read_size + (request->netconn->http2 ? http2_available( request->netconn ) :
+ netconn_query_data_available( request->netconn ));
+}
+
+static BOOL netconn_end_of_data( struct data_stream *stream, struct request *request )
+{
+ struct netconn_stream *netconn_stream = (struct netconn_stream *)stream;
+ return netconn_stream->content_read == netconn_stream->content_length || !netconn_is_valid( request->netconn );
+}
+
+static DWORD netconn_read_data( struct data_stream *stream, struct request *request, char *buf, DWORD to_read, DWORD *read )
+{
+ struct netconn_stream *netconn_stream = (struct netconn_stream *)stream;
+ DWORD size = 0, ret = ERROR_SUCCESS;
+ int received = 0;
+
+ to_read = min( to_read, netconn_stream->content_length - netconn_stream->content_read );
+
+ if (request->read_size)
+ {
+ size = min( to_read, request->read_size );
+ memcpy( buf, request->read_buf + request->read_pos, size );
+ request->read_size -= size;
+ request->read_pos += size;
+ to_read -= size;
+ netconn_stream->content_read += size;
+ }
+
+ if (to_read && netconn_is_valid( request->netconn ))
+ {
+ ret = request->netconn->http2 ? http2_read_data( request->netconn, buf + size, to_read, &received ) :
+ netconn_recv( request->netconn, buf + size, to_read, 0, &received );
+ if (!ret)
+ {
+ if (!received) netconn_stream->content_length = netconn_stream->content_read;
+ netconn_stream->content_read += received;
+ }
+ }
+
+ *read = size + received;
+ return ret;
+}
+
+static DWORD netconn_drain_data( struct data_stream *stream, struct request *request )
+{
+ struct netconn_stream *netconn_stream = (struct netconn_stream *)stream;
+
+ while (netconn_stream->content_read < netconn_stream->content_length)
+ {
+ DWORD ret, to_read, read;
+ char buf[1024];
+
+ to_read = min( sizeof(buf), netconn_stream->content_length - netconn_stream->content_read );
+ if ((ret = netconn_read_data( stream, request, buf, to_read, &read ))) return ret;
+ if (!read) return WSAECONNABORTED;
+ }
+ return ERROR_SUCCESS;
+}
+
+static void netconn_destroy( struct data_stream *stream )
+{
+}
+
+const struct data_stream_vtbl netconn_stream_vtbl =
+{
+ netconn_query_data,
+ netconn_end_of_data,
+ netconn_read_data,
+ netconn_drain_data,
+ netconn_destroy
+};
+
+struct chunked_stream
+{
+ struct data_stream data_stream;
+ char buf[READ_BUFFER_SIZE];
+ DWORD buf_size;
+ DWORD buf_pos;
+ DWORD chunk_size;
+ BOOL trailer_line_nonempty;
+ enum
+ {
+ CHUNKED_STREAM_STATE_READING_CHUNK_SIZE,
+ CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE,
+ CHUNKED_STREAM_STATE_READING_CHUNK,
+ CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA,
+ CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END,
+ CHUNKED_STREAM_STATE_END_OF_STREAM,
+ CHUNKED_STREAM_STATE_ERROR
+ } state;
+};
+
+static DWORD chunked_query_data( struct data_stream *stream, struct request *request )
+{
+ struct chunked_stream *chunked_stream = (struct chunked_stream *)stream;
+
+ if (chunked_stream->state != CHUNKED_STREAM_STATE_READING_CHUNK ) return 0;
+ return min( chunked_stream->chunk_size, chunked_stream->buf_size );
+}
+
+static BOOL chunked_end_of_data( struct data_stream *stream, struct request *request )
+{
+ struct chunked_stream *chunked_stream = (struct chunked_stream *)stream;
+
+ switch (chunked_stream->state)
+ {
+ case CHUNKED_STREAM_STATE_END_OF_STREAM:
+ return TRUE;
+ default:
+ return FALSE;
+ }
+}
+
+static char next_chunked_data_char( struct chunked_stream *stream )
+{
+ assert( stream->buf_size );
+ stream->buf_size--;
+ return stream->buf[stream->buf_pos++];
+}
+
+static DWORD chunked_read_data( struct data_stream *stream, struct request *request, char *buf, DWORD to_read, DWORD *read )
+{
+ struct chunked_stream *chunked_stream = (struct chunked_stream *)stream;
+ DWORD ret_read = 0, ret = ERROR_SUCCESS;
+ BOOL continue_read = TRUE;
+ int read_bytes;
+ char ch;
+ int digit;
+
+ do
+ {
+ TRACE( "state %d\n", chunked_stream->state );
+
+ /* ensure that we have data in the buffer for states that need it */
+ if (!chunked_stream->buf_size)
+ {
+ switch (chunked_stream->state)
+ {
+ case CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END:
+ case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE:
+ case CHUNKED_STREAM_STATE_READING_CHUNK_SIZE:
+ case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA:
+ chunked_stream->buf_pos = 0;
+ ret = netconn_recv( request->netconn, chunked_stream->buf, sizeof(chunked_stream->buf), 0, &read_bytes );
+ if (ret == ERROR_SUCCESS && read_bytes)
+ chunked_stream->buf_size += read_bytes;
+ else
+ {
+ if (!ret) ret = ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
+ chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ switch (chunked_stream->state)
+ {
+ case CHUNKED_STREAM_STATE_READING_CHUNK_SIZE:
+ ch = next_chunked_data_char( chunked_stream );
+
+ digit = ch >= '0' && ch <= '9' ? ch - '0' :
+ ch >= 'a' && ch <= 'f' ? ch - 'a' + 10 :
+ ch >= 'A' && ch <= 'F' ? ch - 'A' + 10 : -1;
+ if (digit >= 0)
+ {
+ if (chunked_stream->chunk_size > (~0u - digit) / 16)
+ chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
+ else chunked_stream->chunk_size = chunked_stream->chunk_size * 16 + digit;
+ }
+ else if (ch == ';' || ch == '\r' || ch == '\n')
+ {
+ TRACE( "reading %lu byte chunk\n", chunked_stream->chunk_size );
+ chunked_stream->buf_size++;
+ chunked_stream->buf_pos--;
+ chunked_stream->state = CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE;
+ }
+ else chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
+ break;
+
+ case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE:
+ ch = next_chunked_data_char( chunked_stream );
+ if (ch == '\n')
+ {
+ if (chunked_stream->chunk_size)
+ chunked_stream->state = CHUNKED_STREAM_STATE_READING_CHUNK;
+ else
+ chunked_stream->state = CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END;
+ }
+ else if (ch != '\r') WARN( "unexpected char '%c'\n", ch );
+ break;
+
+ case CHUNKED_STREAM_STATE_READING_CHUNK:
+ assert( chunked_stream->chunk_size );
+ if (!to_read)
+ {
+ continue_read = FALSE;
+ break;
+ }
+ read_bytes = min( to_read, chunked_stream->chunk_size );
+
+ if (chunked_stream->buf_size)
+ {
+ if (read_bytes > chunked_stream->buf_size) read_bytes = chunked_stream->buf_size;
+
+ memcpy( buf + ret_read, chunked_stream->buf + chunked_stream->buf_pos, read_bytes );
+ chunked_stream->buf_pos += read_bytes;
+ chunked_stream->buf_size -= read_bytes;
+ }
+ else
+ {
+ ret = netconn_recv( request->netconn, buf + ret_read, read_bytes, 0, (int *)&read_bytes );
+ if (ret != ERROR_SUCCESS)
+ {
+ continue_read = FALSE;
+ break;
+ }
+ if (!read_bytes)
+ {
+ chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
+ continue;
+ }
+ }
+
+ chunked_stream->chunk_size -= read_bytes;
+ to_read -= read_bytes;
+ ret_read += read_bytes;
+ if (!chunked_stream->chunk_size) chunked_stream->state = CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA;
+ break;
+
+ case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA:
+ ch = next_chunked_data_char( chunked_stream );
+ if (ch == '\n') chunked_stream->state = CHUNKED_STREAM_STATE_READING_CHUNK_SIZE;
+ else if (ch != '\r') WARN( "unexpected char '%c'\n", ch );
+ break;
+
+ case CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END:
+ ch = next_chunked_data_char( chunked_stream );
+ if (ch == '\n')
+ {
+ if (!chunked_stream->trailer_line_nonempty)
+ chunked_stream->state = CHUNKED_STREAM_STATE_END_OF_STREAM;
+ chunked_stream->trailer_line_nonempty = FALSE;
+ }
+ else if (ch != '\r') chunked_stream->trailer_line_nonempty = TRUE;
+ break;
+
+ case CHUNKED_STREAM_STATE_END_OF_STREAM:
+ continue_read = FALSE;
+ break;
+ case CHUNKED_STREAM_STATE_ERROR:
+ if (!ret) ret = ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
+ continue_read = FALSE;
+ break;
+ }
+ } while (continue_read);
+
+ if (ret_read) ret = ERROR_SUCCESS;
+ if (ret != ERROR_SUCCESS) return ret;
+
+ *read = ret_read;
+ return ERROR_SUCCESS;
+}
+
+static DWORD chunked_buffer_data( struct data_stream *stream, struct request *request, DWORD *available )
+{
+ struct chunked_stream *chunked_stream = (struct chunked_stream *)stream;
+ DWORD ret, ignored;
+ int size;
+
+ *available = 0;
+ if ((ret = chunked_read_data( stream, request, NULL, 0, &ignored ))) return ret;
+ if (chunked_stream->state == CHUNKED_STREAM_STATE_READING_CHUNK && !chunked_stream->buf_size)
+ {
+ chunked_stream->buf_pos = 0;
+ ret = netconn_recv( request->netconn, chunked_stream->buf,
+ min( sizeof(chunked_stream->buf), chunked_stream->chunk_size ), 0, &size );
+ if (ret || !size)
+ {
+ chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
+ return ret ? ret : ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
+ }
+ chunked_stream->buf_size = size;
+ }
+ *available = chunked_query_data( stream, request );
+ return ERROR_SUCCESS;
+}
+
+static DWORD chunked_drain_data( struct data_stream *stream, struct request *request )
+{
+ struct chunked_stream *chunked_stream = (struct chunked_stream *)stream;
+ char buf[1024];
+ DWORD size, ret;
+
+ while (chunked_stream->state != CHUNKED_STREAM_STATE_END_OF_STREAM &&
+ chunked_stream->state != CHUNKED_STREAM_STATE_ERROR)
+ {
+ if ((ret = chunked_read_data( stream, request, buf, sizeof(buf), &size ))) return ret;
+ }
+
+ if (chunked_stream->state != CHUNKED_STREAM_STATE_END_OF_STREAM) return ERROR_NO_DATA;
+ return ERROR_SUCCESS;
+}
+
+static void chunked_destroy( struct data_stream *stream )
+{
+ struct chunked_stream *chunked_stream = (struct chunked_stream *)stream;
+ free( chunked_stream );
+}
+
+const struct data_stream_vtbl chunked_stream_vtbl =
+{
+ chunked_query_data,
+ chunked_end_of_data,
+ chunked_read_data,
+ chunked_drain_data,
+ chunked_destroy
+};
+
+struct gzip_stream
+{
+ struct data_stream data_stream;
+ struct data_stream *parent_stream;
+ z_stream zstream;
+ BYTE buf[READ_BUFFER_SIZE];
+ DWORD buf_size;
+ DWORD buf_pos;
+ BOOL end_of_data;
+ BOOL inflate_active;
+ DWORD error;
+ BYTE decoded[READ_BUFFER_SIZE];
+ DWORD decoded_pos, decoded_size;
+};
+
+static DWORD gzip_query_data( struct data_stream *stream, struct request *request )
+{
+ struct gzip_stream *gzip_stream = (struct gzip_stream *)stream;
+ return gzip_stream->decoded_size;
+}
+
+static BOOL gzip_end_of_data( struct data_stream *stream, struct request *request )
+{
+ struct gzip_stream *gzip_stream = (struct gzip_stream *)stream;
+ return gzip_stream->end_of_data && !gzip_stream->decoded_size;
+}
+
+static DWORD gzip_read_raw( struct data_stream *stream, struct request *request, char *buf, DWORD to_read, DWORD *read )
+{
+ struct gzip_stream *gzip_stream = (struct gzip_stream *)stream;
+ z_stream *zstream = &gzip_stream->zstream;
+ DWORD size, ret_read = 0;
+ int zres;
+ DWORD ret = ERROR_SUCCESS;
+
+ *read = 0;
+ if (gzip_stream->error) return gzip_stream->error;
+ while (to_read && !gzip_stream->end_of_data)
+ {
+ if (!gzip_stream->buf_size)
+ {
+ if (gzip_stream->buf_pos)
+ {
+ if (gzip_stream->buf_size)
+ memmove( gzip_stream->buf, gzip_stream->buf + gzip_stream->buf_pos, gzip_stream->buf_size );
+ gzip_stream->buf_pos = 0;
+ }
+ ret = gzip_stream->parent_stream->vtbl->read_data( gzip_stream->parent_stream, request,
+ (char *)gzip_stream->buf + gzip_stream->buf_size,
+ sizeof(gzip_stream->buf) - gzip_stream->buf_size, &size );
+ if (ret) break;
+ gzip_stream->buf_size += size;
+ if (!size)
+ {
+ WARN( "unexpected end of data\n" );
+ ret = ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
+ break;
+ }
+ }
+
+ zstream->next_in = gzip_stream->buf + gzip_stream->buf_pos;
+ zstream->avail_in = gzip_stream->buf_size;
+ zstream->next_out = (Bytef *)buf + ret_read;
+ zstream->avail_out = to_read;
+ zres = inflate( &gzip_stream->zstream, 0 );
+ size = to_read - zstream->avail_out;
+ to_read -= size;
+ ret_read += size;
+ gzip_stream->buf_size -= zstream->next_in - (gzip_stream->buf + gzip_stream->buf_pos);
+ gzip_stream->buf_pos = zstream->next_in - gzip_stream->buf;
+ if (zres == Z_STREAM_END)
+ {
+ TRACE( "end of data\n" );
+ gzip_stream->end_of_data = TRUE;
+ inflateEnd( zstream );
+ gzip_stream->inflate_active = FALSE;
+ }
+ else if (zres != Z_OK)
+ {
+ WARN( "inflate failed %d: %s\n", zres, debugstr_a(zstream->msg) );
+ ret = ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
+ break;
+ }
+ }
+
+ if (ret) gzip_stream->error = ret;
+ if (ret_read) ret = ERROR_SUCCESS;
+ *read = ret_read;
+ return ret;
+}
+
+static DWORD gzip_read( struct data_stream *stream, struct request *request, char *buf, DWORD to_read, DWORD *read )
+{
+ struct gzip_stream *gzip_stream = (struct gzip_stream *)stream;
+ if (gzip_stream->decoded_size)
+ {
+ DWORD size = min( to_read, gzip_stream->decoded_size );
+ memcpy( buf, gzip_stream->decoded + gzip_stream->decoded_pos, size );
+ gzip_stream->decoded_pos += size;
+ gzip_stream->decoded_size -= size;
+ *read = size;
+ return ERROR_SUCCESS;
+ }
+ return gzip_read_raw( stream, request, buf, to_read, read );
+}
+
+static DWORD gzip_buffer_data( struct data_stream *stream, struct request *request, DWORD *available )
+{
+ struct gzip_stream *gzip_stream = (struct gzip_stream *)stream;
+ DWORD ret = ERROR_SUCCESS;
+ if (!gzip_stream->decoded_size)
+ {
+ gzip_stream->decoded_pos = 0;
+ ret = gzip_read_raw( stream, request, (char *)gzip_stream->decoded,
+ sizeof(gzip_stream->decoded), &gzip_stream->decoded_size );
+ }
+ *available = gzip_stream->decoded_size;
+ return ret;
+}
+
+static DWORD gzip_drain_content( struct data_stream *stream, struct request *request )
+{
+ struct gzip_stream *gzip_stream = (struct gzip_stream *)stream;
+ return gzip_stream->parent_stream->vtbl->drain_data( gzip_stream->parent_stream, request );
+}
+
+static void gzip_destroy( struct data_stream *stream )
+{
+ struct gzip_stream *gzip_stream = (struct gzip_stream *)stream;
+ destroy_data_stream( gzip_stream->parent_stream );
+ if (gzip_stream->inflate_active) inflateEnd( &gzip_stream->zstream );
+ free( gzip_stream );
+}
+
+static const struct data_stream_vtbl gzip_stream_vtbl =
+{
+ gzip_query_data,
+ gzip_end_of_data,
+ gzip_read,
+ gzip_drain_content,
+ gzip_destroy
+};
+
+static voidpf gzip_zalloc( voidpf opaque, uInt items, uInt size )
+{
+ if (size && items > ~(SIZE_T)0 / size) return NULL;
+ return malloc( (SIZE_T)items * size );
+}
+
+static void gzip_zfree( voidpf opaque, voidpf address )
+{
+ free( address );
+}
+
+static DWORD init_gzip_stream( struct request *request, BOOL is_gzip )
+{
+ struct gzip_stream *gzip_stream;
+ int zres;
+
+ if (!(gzip_stream = calloc( 1, sizeof(*gzip_stream) ))) return ERROR_OUTOFMEMORY;
+
+ gzip_stream->data_stream.vtbl = &gzip_stream_vtbl;
+ gzip_stream->zstream.zalloc = gzip_zalloc;
+ gzip_stream->zstream.zfree = gzip_zfree;
+
+ zres = inflateInit2( &gzip_stream->zstream, is_gzip ? 31 : -15 );
+ if (zres != Z_OK)
+ {
+ ERR( "inflateInit failed: %d\n", zres );
+ free( gzip_stream );
+ return ERROR_OUTOFMEMORY;
+ }
+ gzip_stream->inflate_active = TRUE;
+
+ gzip_stream->parent_stream = request->data_stream;
+ request->data_stream = &gzip_stream->data_stream;
+ return ERROR_SUCCESS;
+}
+
static int request_receive_response_timeout( struct request *req )
{
if (req->receive_response_timeout == -1) return ACTUAL_DEFAULT_RECEIVE_RESPONSE_TIMEOUT;
@@ -64,7 +610,7 @@ static const WCHAR *attribute_table[] =
L"Public", /* WINHTTP_QUERY_PUBLIC = 8 */
L"Date", /* WINHTTP_QUERY_DATE = 9 */
L"Expires", /* WINHTTP_QUERY_EXPIRES = 10 */
- L"Last-Modified", /* WINHTTP_QUERY_LAST_MODIFIEDcw = 11 */
+ L"Last-Modified", /* WINHTTP_QUERY_LAST_MODIFIED = 11 */
NULL, /* WINHTTP_QUERY_MESSAGE_ID = 12 */
L"URI", /* WINHTTP_QUERY_URI = 13 */
L"From", /* WINHTTP_QUERY_DERIVED_FROM = 14 */
@@ -417,6 +963,12 @@ static void delete_header( struct request *request, DWORD index )
memset( &request->headers[request->num_headers], 0, sizeof(struct header) );
}
+static void remove_header( struct request *request, const WCHAR *header, BOOL request_only )
+{
+ int index = get_header_index( request, header, 0, request_only );
+ if (index != -1) delete_header( request, index );
+}
+
DWORD process_header( struct request *request, const WCHAR *field, const WCHAR *value, DWORD flags, BOOL request_only )
{
int index;
@@ -1730,10 +2282,7 @@ static DWORD open_connection( struct request *request )
done:
request->http_protocol_used = request->netconn && request->netconn->http2 ? WINHTTP_PROTOCOL_FLAG_HTTP2 : 0;
- request->read_pos = request->read_size = 0;
- request->read_chunked = FALSE;
- request->read_chunked_size = ~0u;
- request->read_chunked_eof = FALSE;
+ reset_data_stream( request );
free( addressW );
return ERROR_SUCCESS;
}
@@ -1781,161 +2330,6 @@ static void clear_response_headers( struct request *request )
}
}
-/* remove some amount of data from the read buffer */
-static void remove_data( struct request *request, int count )
-{
- if (!(request->read_size -= count)) request->read_pos = 0;
- else request->read_pos += count;
-}
-
-/* read some more data into the read buffer */
-static DWORD read_more_data( struct request *request, int maxlen, BOOL notify )
-{
- int len;
- DWORD ret;
-
- if (request->read_chunked_eof) return ERROR_INSUFFICIENT_BUFFER;
-
- if (request->read_size && request->read_pos)
- {
- /* move existing data to the start of the buffer */
- memmove( request->read_buf, request->read_buf + request->read_pos, request->read_size );
- request->read_pos = 0;
- }
- if (maxlen == -1) maxlen = sizeof(request->read_buf);
-
- if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NULL, 0 );
-
- if (request->netconn && request->netconn->http2)
- ret = http2_read_data( request->netconn, request->read_buf + request->read_size,
- maxlen - request->read_size, &len );
- else ret = netconn_recv( request->netconn, request->read_buf + request->read_size,
- maxlen - request->read_size, 0, &len );
-
- if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, &len, sizeof(len) );
- request->read_reply_len += len;
-
- request->read_size += len;
- return ret;
-}
-
-/* discard data contents until we reach end of line */
-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 );
- if (eol)
- {
- remove_data( request, (eol + 1) - (request->read_buf + request->read_pos) );
- break;
- }
- request->read_pos = request->read_size = 0; /* discard everything */
- if ((ret = read_more_data( request, -1, notify ))) return ret;
- } while (request->read_size);
- return ERROR_SUCCESS;
-}
-
-static void update_value_from_digit( DWORD *value, char ch )
-{
- if (ch >= '0' && ch <= '9') *value = *value * 16 + ch - '0';
- else if (ch >= 'a' && ch <= 'f') *value = *value * 16 + ch - 'a' + 10;
- else if (ch >= 'A' && ch <= 'F') *value = *value * 16 + ch - 'A' + 10;
-}
-
-/* read chunk size if already in the read buffer */
-static BOOL get_chunk_size( struct request *request )
-{
- DWORD chunk_size;
- char *p, *eol;
-
- if (request->read_chunked_size != ~0ul) return TRUE;
-
- eol = memchr( request->read_buf + request->read_pos, '\n', request->read_size );
- if (!eol) return FALSE;
-
- chunk_size = 0;
- for (p = request->read_buf + request->read_pos; p != eol; ++p)
- {
- if (*p == ';' || *p == '\r') break;
- update_value_from_digit( &chunk_size, *p );
- }
-
- request->read_chunked_size = chunk_size;
- if (!chunk_size) request->read_chunked_eof = TRUE;
-
- remove_data( request, (eol + 1) - (request->read_buf + request->read_pos) );
- return TRUE;
-}
-
-/* read the size of the next chunk */
-static DWORD start_next_chunk( struct request *request, BOOL notify )
-{
- DWORD ret, chunk_size = 0;
-
- assert(!request->read_chunked_size || request->read_chunked_size == ~0u);
-
- if (request->read_chunked_eof) return ERROR_INSUFFICIENT_BUFFER;
-
- /* read terminator for the previous chunk */
- if (!request->read_chunked_size && (ret = discard_eol( request, notify ))) return ret;
-
- for (;;)
- {
- while (request->read_size)
- {
- char ch = request->read_buf[request->read_pos];
-
- if (ch == ';' || ch == '\r' || ch == '\n')
- {
- TRACE( "reading %lu byte chunk\n", chunk_size );
-
- if (request->content_length == ~0u) request->content_length = chunk_size;
- else request->content_length += chunk_size;
-
- request->read_chunked_size = chunk_size;
- if (!chunk_size) request->read_chunked_eof = TRUE;
-
- return discard_eol( request, notify );
- }
- update_value_from_digit( &chunk_size, ch );
- remove_data( request, 1 );
- }
- 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 ERROR_SUCCESS;
- }
- }
-}
-
-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 ERROR_INSUFFICIENT_BUFFER;
- if (request->read_chunked_size == ~0u || !request->read_chunked_size)
- {
- if ((ret = start_next_chunk( request, notify ))) return ret;
- }
- len = min( len, request->read_chunked_size );
- }
- else if (request->content_length != ~0u)
- {
- len = min( len, request->content_length - request->content_read );
- }
-
- 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 ERROR_SUCCESS;
-}
static void finished_reading( struct request *request )
{
@@ -1945,6 +2339,11 @@ static void finished_reading( struct request *request )
if (!request->netconn) return;
+ if (request->data_stream->vtbl == &gzip_stream_vtbl)
+ {
+ struct gzip_stream *stream = (struct gzip_stream *)request->data_stream;
+ if (stream->buf_size || !stream->parent_stream->vtbl->end_of_data( stream->parent_stream, request )) close = TRUE;
+ }
if (request->netconn->http2 || request->netconn->socket == -1) close = TRUE;
else if (request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE) close = TRUE;
else if (!query_headers( request, WINHTTP_QUERY_CONNECTION, NULL, connection, &size, NULL ) ||
@@ -1970,57 +2369,48 @@ static void finished_reading( struct request *request )
request->netconn = NULL;
}
-/* return the size of data available to be read immediately */
-static DWORD get_available_data( struct request *request )
+/* read some more data into the read buffer */
+static DWORD read_more_data( struct request *request, int max_len, BOOL notify )
{
- if (request->read_chunked)
+ int len;
+ DWORD ret;
+
+ if (request->read_pos)
{
- if (!get_chunk_size( request )) return 0;
- return min( request->read_chunked_size, request->read_size );
+ if (request->read_size) memmove( request->read_buf, request->read_buf + request->read_pos, request->read_size );
+ request->read_pos = 0;
}
- return request->read_size;
+ if (max_len == -1) max_len = sizeof(request->read_buf);
+
+ if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NULL, 0 );
+
+ ret = request->netconn->http2 ?
+ http2_read_data( request->netconn, request->read_buf + request->read_size, max_len - request->read_size, &len ) :
+ netconn_recv( request->netconn, request->read_buf + request->read_size, max_len - request->read_size, 0, &len );
+
+ if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, &len, sizeof(len) );
+
+ request->read_reply_len += len;
+ request->read_size += len;
+ return ret;
}
-/* check if we have reached the end of the data to read */
-static BOOL end_of_read_data( struct request *request )
+static DWORD refill_buffer( struct request *request, BOOL notify )
{
- if (!request->content_length) return TRUE;
- if (request->read_chunked) return request->read_chunked_eof;
- if (request->content_length == ~0ull) return FALSE;
- return (request->content_length == request->content_read);
+ DWORD ret;
+ if ((ret = read_more_data( request, -1, notify ))) return ret;
+ if (!request->read_size) request->content_length = request->content_read = 0;
+ return ERROR_SUCCESS;
}
static DWORD read_data( struct request *request, void *buffer, DWORD size, DWORD *read, BOOL async )
{
- int count, bytes_read = 0;
- DWORD ret = ERROR_SUCCESS;
+ DWORD bytes_read = 0, ret;
- if (request->read_chunked && request->read_chunked_size == ~0u
- && (ret = start_next_chunk( request, async ))) goto done;
+ ret = read_data_stream( request, buffer, size, &bytes_read );
- if (end_of_read_data( request )) goto done;
-
- while (size)
- {
- if (!(count = get_available_data( request )))
- {
- if ((ret = refill_buffer( request, async ))) goto done;
- if (!(count = get_available_data( request ))) goto done;
- }
- count = min( count, size );
- memcpy( (char *)buffer + bytes_read, request->read_buf + request->read_pos, count );
- remove_data( request, count );
- if (request->read_chunked) request->read_chunked_size -= count;
- size -= count;
- bytes_read += count;
- request->content_read += count;
- if (end_of_read_data( request )) goto done;
- }
- if (request->read_chunked && !request->read_chunked_size) ret = refill_buffer( request, async );
-
-done:
- TRACE( "retrieved %u bytes (%I64u/%I64u)\n", bytes_read, request->content_read, request->content_length );
- if (end_of_read_data( request )) finished_reading( request );
+ TRACE( "retrieved %lu bytes (%I64u/%I64u)\n", bytes_read, request->content_read, request->content_length );
+ if (end_of_data_stream( request )) finished_reading( request );
if (async)
{
if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, buffer, bytes_read );
@@ -2037,23 +2427,6 @@ done:
return ret;
}
-/* read any content returned by the server so that the connection can be reused */
-static void drain_content( struct request *request )
-{
- DWORD size, bytes_read, bytes_total = 0, bytes_left = request->content_length - request->content_read;
- char buffer[2048];
-
- refill_buffer( request, FALSE );
- for (;;)
- {
- if (request->read_chunked) size = sizeof(buffer);
- else size = min( sizeof(buffer), bytes_left - bytes_total );
-
- if (read_data( request, buffer, size, &bytes_read, FALSE ) || !bytes_read) return;
- bytes_total += bytes_read;
- }
-}
-
enum escape_flags
{
ESCAPE_FLAG_NON_PRINTABLE = 0x01,
@@ -2269,7 +2642,7 @@ static DWORD send_request( struct request *request, const WCHAR *headers, DWORD
goto end;
}
- drain_content( request );
+ drain_data_stream( request );
clear_response_headers( request );
if (session->agent)
@@ -2314,6 +2687,14 @@ static DWORD send_request( struct request *request, const WCHAR *headers, DWORD
TRACE( "failed to add request headers: %lu\n", ret );
return ret;
}
+ if (request->hdr.decompression)
+ {
+ WCHAR encoding[16];
+ if (request->hdr.decompression == WINHTTP_DECOMPRESSION_FLAG_ALL) wcscpy( encoding, L"gzip, deflate" );
+ else if (request->hdr.decompression == WINHTTP_DECOMPRESSION_FLAG_GZIP) wcscpy( encoding, L"gzip" );
+ else if (request->hdr.decompression == WINHTTP_DECOMPRESSION_FLAG_DEFLATE) wcscpy( encoding, L"deflate" );
+ process_header( request, L"Accept-Encoding", encoding, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, TRUE );
+ }
if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES) && (ret = add_cookie_headers( request )))
{
WARN( "failed to add cookie headers: %lu\n", ret );
@@ -2591,34 +2972,75 @@ static DWORD handle_authorization( struct request *request, DWORD status )
}
/* set the request content length based on the headers */
-static void set_content_length( struct request *request, DWORD status )
+static DWORD set_content_length( struct request *request, DWORD status )
{
WCHAR buf[21];
- DWORD buflen = sizeof(buf);
+ DWORD buflen = sizeof(buf), ret = ERROR_SUCCESS;
if (status == HTTP_STATUS_NO_CONTENT || status == HTTP_STATUS_NOT_MODIFIED ||
status == HTTP_STATUS_SWITCH_PROTOCOLS || !wcscmp( request->verb, L"HEAD" ))
{
- request->content_length = 0;
+ request->content_length = request->netconn_stream.content_length = 0;
}
else
{
if (query_headers( request, WINHTTP_QUERY_CONTENT_LENGTH, NULL, buf, &buflen, NULL ))
- request->content_length = ~0ull;
+ request->content_length = request->netconn_stream.content_length = ~0ull;
else
request->content_length = wcstoull( buf, NULL, 10 );
+ request->netconn_stream.content_length = request->content_length;
+ request->netconn_stream.content_read = 0;
+
buflen = sizeof(buf);
if (!query_headers( request, WINHTTP_QUERY_TRANSFER_ENCODING, NULL, buf, &buflen, NULL ) &&
!wcsicmp( buf, L"chunked" ))
{
+ struct chunked_stream *chunked_stream;
+
+ if (!(chunked_stream = malloc( sizeof(*chunked_stream) ))) return ERROR_OUTOFMEMORY;
+
+ chunked_stream->data_stream.vtbl = &chunked_stream_vtbl;
+ chunked_stream->buf_size = chunked_stream->buf_pos = 0;
+ chunked_stream->chunk_size = 0;
+ chunked_stream->trailer_line_nonempty = FALSE;
+ chunked_stream->state = CHUNKED_STREAM_STATE_READING_CHUNK_SIZE;
+
+ if (request->read_size)
+ {
+ memcpy( chunked_stream->buf, request->read_buf + request->read_pos, request->read_size );
+ chunked_stream->buf_size = request->read_size;
+ request->read_size = request->read_pos = 0;
+ }
+ request->data_stream = &chunked_stream->data_stream;
request->content_length = ~0ull;
- request->read_chunked = TRUE;
- request->read_chunked_size = ~0u;
- request->read_chunked_eof = FALSE;
+ }
+
+ buflen = sizeof(buf);
+ if (request->content_length && request->hdr.decompression &&
+ !query_headers( request, WINHTTP_QUERY_CONTENT_ENCODING, NULL, buf, &buflen, NULL ))
+ {
+ BOOL decode = FALSE;
+ if (!wcsicmp( buf, L"gzip" ) && (request->hdr.decompression & WINHTTP_DECOMPRESSION_FLAG_GZIP))
+ { ret = init_gzip_stream( request, TRUE ); decode = TRUE; }
+ else if (!wcsicmp( buf, L"deflate" ) && (request->hdr.decompression & WINHTTP_DECOMPRESSION_FLAG_DEFLATE))
+ { ret = init_gzip_stream( request, FALSE ); decode = TRUE; }
+ if (decode && !ret)
+ {
+ remove_header( request, L"Content-Length", FALSE );
+ request->content_length = ~0ull;
+ }
}
}
request->content_read = 0;
+ return ret;
+}
+
+/* remove some amount of data from the read buffer */
+static void remove_data( struct request *request, int count )
+{
+ if (!(request->read_size -= count)) request->read_pos = 0;
+ else request->read_pos += count;
}
static DWORD read_line( struct request *request, char *buffer, DWORD *len )
@@ -2899,8 +3321,7 @@ static DWORD handle_redirect( struct request *request, DWORD status )
netconn_release( request->netconn );
request->netconn = NULL;
request->content_length = request->content_read = 0;
- request->read_pos = request->read_size = 0;
- request->read_chunked = request->read_chunked_eof = FALSE;
+ reset_data_stream( request );
}
else free( hostname );
@@ -3041,7 +3462,7 @@ static DWORD receive_response( struct request *request )
query = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
if ((ret = query_headers( request, query, NULL, &status, &size, NULL ))) goto done;
- set_content_length( request, status );
+ if ((ret = set_content_length( request, status ))) goto done;
if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES)) record_cookies( request );
@@ -3136,22 +3557,10 @@ BOOL WINAPI WinHttpReceiveResponse( HINTERNET hrequest, LPVOID reserved )
return !ret;
}
-static DWORD query_data_ready( struct request *request )
-{
- DWORD count;
-
- count = get_available_data( request );
- if (!request->read_chunked && request->netconn)
- count += request->netconn->http2 ? http2_available( request->netconn ) : netconn_query_data_available( request->netconn );
-
- return count;
-}
-
static BOOL skip_async_queue( struct request *request, BOOL *wont_block, DWORD to_read )
{
- if (!request->read_chunked)
- to_read = min( to_read, request->content_length - request->content_read );
- *wont_block = end_of_read_data( request ) || query_data_ready( request ) >= to_read;
+ to_read = min( to_read, request->content_length - request->content_read );
+ *wont_block = end_of_data_stream( request ) || query_data_stream( request ) >= to_read;
return request->hdr.recursion_count < 3 && *wont_block;
}
@@ -3159,12 +3568,22 @@ static DWORD query_data_available( struct request *request, DWORD *available, BO
{
DWORD ret = ERROR_SUCCESS, count = 0;
- if (end_of_read_data( request )) goto done;
+ if (!request->content_length || end_of_data_stream( request )) goto done;
- if (!(count = query_data_ready( request )))
+ if (request->data_stream->vtbl == &gzip_stream_vtbl)
+ {
+ ret = gzip_buffer_data( request->data_stream, request, &count );
+ goto done;
+ }
+ if (request->data_stream->vtbl == &chunked_stream_vtbl)
+ {
+ ret = chunked_buffer_data( request->data_stream, request, &count );
+ goto done;
+ }
+ if (!(count = query_data_stream( request )))
{
if ((ret = refill_buffer( request, async ))) goto done;
- count = query_data_ready( request );
+ count = query_data_stream( request );
}
done:
diff --git a/dlls/winhttp/session.c b/dlls/winhttp/session.c
index 33507a6..1ce2ae1 100644
--- a/dlls/winhttp/session.c
+++ b/dlls/winhttp/session.c
@@ -284,7 +284,6 @@ static BOOL session_set_option( struct object_header *hdr, DWORD option, void *b
session->websocket_receive_buffer_size = buffer_size;
return TRUE;
}
-
case WINHTTP_OPTION_WEB_SOCKET_SEND_BUFFER_SIZE:
{
DWORD buffer_size;
@@ -300,7 +299,25 @@ static BOOL session_set_option( struct object_header *hdr, DWORD option, void *b
session->websocket_send_buffer_size = buffer_size;
return TRUE;
}
+ case WINHTTP_OPTION_DECOMPRESSION:
+ {
+ DWORD decompression;
+ if (!buffer || buflen != sizeof(decompression))
+ {
+ SetLastError( ERROR_INSUFFICIENT_BUFFER );
+ return FALSE;
+ }
+ decompression = *(DWORD *)buffer;
+ if (decompression & ~WINHTTP_DECOMPRESSION_FLAG_ALL)
+ {
+ SetLastError( ERROR_INVALID_PARAMETER );
+ return FALSE;
+ }
+ TRACE( "%#lx\n", decompression );
+ session->hdr.decompression = decompression;
+ return TRUE;
+ }
default:
FIXME( "unimplemented option %lu\n", option );
SetLastError( ERROR_WINHTTP_INVALID_OPTION );
@@ -643,6 +660,7 @@ HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, const WCHAR *server, INTERN
connect->hdr.notify_mask = session->hdr.notify_mask;
connect->hdr.context = session->hdr.context;
connect->hdr.redirect_policy = session->hdr.redirect_policy;
+ connect->hdr.decompression = session->hdr.decompression;
addref_object( &session->hdr );
connect->session = session;
@@ -701,6 +719,7 @@ static void request_destroy( struct object_header *hdr )
}
}
+ destroy_data_stream( request->data_stream );
free( request );
}
@@ -836,6 +855,21 @@ static BOOL request_query_option( struct object_header *hdr, DWORD option, void
*buflen = sizeof(cert);
return TRUE;
}
+ case WINHTTP_OPTION_SERVER_CERT_CHAIN_CONTEXT:
+ {
+ const CERT_CHAIN_CONTEXT *chain;
+ if (!validate_buffer( buffer, buflen, sizeof(chain) )) return FALSE;
+ if (!request->netconn || !request->netconn->chain)
+ {
+ *(const CERT_CHAIN_CONTEXT **)buffer = NULL;
+ SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_STATE );
+ return FALSE;
+ }
+ if (!(chain = CertDuplicateCertificateChain( request->netconn->chain ))) return FALSE;
+ *(const CERT_CHAIN_CONTEXT **)buffer = chain;
+ *buflen = sizeof(chain);
+ return TRUE;
+ }
case WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT:
{
const CERT_CONTEXT *cert = request->server_cert;
@@ -1237,7 +1271,6 @@ static BOOL request_set_option( struct object_header *hdr, DWORD option, void *b
request->websocket_receive_buffer_size = buffer_size;
return TRUE;
}
-
case WINHTTP_OPTION_WEB_SOCKET_SEND_BUFFER_SIZE:
{
DWORD buffer_size;
@@ -1254,11 +1287,21 @@ static BOOL request_set_option( struct object_header *hdr, DWORD option, void *b
return TRUE;
}
- // Asphalt Legends set this option and fails if this returns an error.
- // While actually not requireing this feature.
case WINHTTP_OPTION_DECOMPRESSION:
{
- FIXME("WINHTTP_OPTION_DECOMPRESSION: stub!\n");
+ DWORD decompression;
+ if (!buffer || buflen != sizeof(decompression))
+ {
+ SetLastError( ERROR_INSUFFICIENT_BUFFER );
+ return FALSE;
+ }
+ decompression = *(DWORD *)buffer;
+ if (decompression & ~WINHTTP_DECOMPRESSION_FLAG_ALL)
+ {
+ SetLastError( ERROR_INVALID_PARAMETER );
+ return FALSE;
+ }
+ request->hdr.decompression = decompression;
return TRUE;
}
@@ -1352,6 +1395,7 @@ HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, const WCHAR *verb, cons
request->hdr.notify_mask = connect->hdr.notify_mask;
request->hdr.context = connect->hdr.context;
request->hdr.redirect_policy = connect->hdr.redirect_policy;
+ request->hdr.decompression = connect->hdr.decompression;
init_queue( &request->queue );
addref_object( &connect->hdr );
@@ -1368,6 +1412,8 @@ HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, const WCHAR *verb, cons
request->websocket_send_buffer_size = connect->session->websocket_send_buffer_size;
request->websocket_set_send_buffer_size = request->websocket_send_buffer_size;
request->read_reply_status = ERROR_WINHTTP_INCORRECT_HANDLE_STATE;
+ request->netconn_stream.data_stream.vtbl = &netconn_stream_vtbl;
+ request->data_stream = &request->netconn_stream.data_stream;
if (!verb || !verb[0]) verb = L"GET";
if (!(request->verb = wcsdup( verb ))) goto end;
@@ -1498,11 +1544,6 @@ static BOOL set_option( struct object_header *hdr, DWORD option, void *buffer, D
hdr->context = *(DWORD_PTR *)buffer;
return TRUE;
}
-
- case WINHTTP_OPTION_DECOMPRESSION:
- FIXME( "WINHTTP_OPTION_DECOMPRESSION, %#lx stub.\n", *(DWORD *)buffer );
- return TRUE;
-
default:
if (hdr->vtbl->set_option) ret = hdr->vtbl->set_option( hdr, option, buffer, buflen );
else
diff --git a/dlls/winhttp/tests/winhttp.c b/dlls/winhttp/tests/winhttp.c
index d4590ea..4e83cf2 100644
--- a/dlls/winhttp/tests/winhttp.c
+++ b/dlls/winhttp/tests/winhttp.c
@@ -6299,6 +6299,58 @@ static void test_connection_cache(int port)
WinHttpCloseHandle(ses);
}
+static void test_decompression(void)
+{
+ HINTERNET ses, req, con;
+ DWORD decompression, len, status, size;
+ BOOL ret;
+
+ ses = WinHttpOpen( L"winetest", WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0 );
+ ok( ses != NULL, "got %lu\n", GetLastError() );
+
+ decompression = WINHTTP_DECOMPRESSION_FLAG_ALL;
+ ret = WinHttpSetOption( ses, WINHTTP_OPTION_DECOMPRESSION, &decompression, sizeof(decompression) );
+ ok( ret, "got %lu\n", GetLastError() );
+
+ con = WinHttpConnect( ses, L"test.winehq.org", 0, 0 );
+ ok( con != NULL, "got %lu\n", GetLastError() );
+
+ req = WinHttpOpenRequest( con, NULL, L"tests/gzip.php", NULL, NULL, NULL, 0 );
+ ok( req != NULL, "got %lu\n", GetLastError() );
+
+ ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
+ ok( ret, "got %lu\n", GetLastError() );
+
+ ret = WinHttpReceiveResponse( req, NULL );
+ ok( ret, "got %lu\n", GetLastError() );
+
+ status = 0xdeadbeef;
+ size = sizeof(status);
+ ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL );
+ ok( ret, "got %lu\n", GetLastError() );
+ ok( status == HTTP_STATUS_OK, "got %lu\n", status );
+
+ len = 0xdeadbeef;
+ size = sizeof(len);
+ ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER, NULL, &len, &size, 0 );
+ ok( !ret && GetLastError() == ERROR_WINHTTP_HEADER_NOT_FOUND, "got %lu\n", GetLastError() );
+ ok( len == 0xdeadbeef, "got %lu\n", len );
+
+ for (;;)
+ {
+ char buf[4096];
+
+ size = 0;
+ ret = WinHttpReadData( req, buf, sizeof(buf), &size );
+ ok( ret, "got %lu\n", GetLastError() );
+ if (!ret || !size) break;
+ }
+
+ WinHttpCloseHandle( req );
+ WinHttpCloseHandle( con );
+ WinHttpCloseHandle( ses );
+}
+
START_TEST (winhttp)
{
struct server_info si;
@@ -6333,6 +6385,7 @@ START_TEST (winhttp)
test_WinHttpGetIEProxyConfigForCurrentUser();
test_chunked_read();
test_max_http_automatic_redirects();
+ test_decompression();
si.event = CreateEventW(NULL, 0, 0, NULL);
si.port = 7532;
diff --git a/dlls/winhttp/winhttp_private.h b/dlls/winhttp/winhttp_private.h
index 5e0ba2c..ab40a51 100644
--- a/dlls/winhttp/winhttp_private.h
+++ b/dlls/winhttp/winhttp_private.h
@@ -46,6 +46,7 @@ struct object_header
DWORD logon_policy;
DWORD redirect_policy;
DWORD error;
+ DWORD decompression;
DWORD_PTR context;
LONG refs;
WINHTTP_STATUS_CALLBACK callback;
@@ -117,6 +118,7 @@ struct netconn
struct hostdata *host;
ULONGLONG keep_until;
CtxtHandle ssl_ctx;
+ const CERT_CHAIN_CONTEXT *chain;
SecPkgContext_StreamSizes ssl_sizes;
char *ssl_read_buf, *ssl_write_buf;
char *extra_buf;
@@ -191,6 +193,34 @@ enum request_response_state
REQUEST_RESPONSE_STATE_RESPONSE_RECEIVED,
};
+#define READ_BUFFER_SIZE 8192
+
+struct data_stream;
+struct request;
+
+struct data_stream_vtbl
+{
+ DWORD (*query_data)( struct data_stream *, struct request * );
+ BOOL (*end_of_data)( struct data_stream *, struct request * );
+ DWORD (*read_data)( struct data_stream *, struct request *, char *, DWORD, DWORD * );
+ DWORD (*drain_data)( struct data_stream *, struct request * );
+ void (*destroy)( struct data_stream * );
+};
+
+struct data_stream
+{
+ const struct data_stream_vtbl *vtbl;
+};
+
+struct netconn_stream
+{
+ struct data_stream data_stream;
+ UINT64 content_length;
+ UINT64 content_read;
+};
+
+extern const struct data_stream_vtbl netconn_stream_vtbl;
+
struct request
{
struct object_header hdr;
@@ -219,12 +249,11 @@ struct request
WCHAR *status_text;
UINT64 content_length; /* total number of bytes to be read */
UINT64 content_read; /* bytes read so far */
- BOOL read_chunked; /* are we reading in chunked mode? */
- BOOL read_chunked_eof; /* end of stream in chunked mode */
- BOOL read_chunked_size; /* chunk size remaining */
DWORD read_pos; /* current read position in read_buf */
DWORD read_size; /* valid data size in read_buf */
- char read_buf[8192]; /* buffer for already read but not returned data */
+ char read_buf[READ_BUFFER_SIZE]; /* buffer for already read but not returned data */
+ struct data_stream *data_stream;
+ struct netconn_stream netconn_stream;
struct header *headers;
DWORD num_headers;
struct authinfo *authinfo;
@@ -422,6 +451,7 @@ BOOL netconn_wait_overlapped_result( struct netconn *conn, WSAOVERLAPPED *ovr, D
void netconn_cancel_io( struct netconn *conn );
DWORD netconn_set_timeout( struct netconn *, BOOL, int );
BOOL netconn_is_alive( struct netconn * );
+BOOL netconn_is_valid( struct netconn * );
const void *netconn_get_certificate( struct netconn * );
int netconn_get_cipher_strength( struct netconn * );
@@ -431,6 +461,7 @@ DWORD add_request_headers( struct request *, const WCHAR *, DWORD, DWORD );
void destroy_cookies( struct session * );
BOOL set_server_for_hostname( struct connect *, const WCHAR *, INTERNET_PORT );
void destroy_authinfo( struct authinfo * );
+void destroy_data_stream( struct data_stream * );
void release_host( struct hostdata * );
DWORD process_header( struct request *, const WCHAR *, const WCHAR *, DWORD, BOOL );