#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include "windef.h"
#include "winbase.h"
#include "wininet.h"
#include "winineti.h"
#include "winsock2.h"
#include "wine/test.h"

Include dependency graph for http.c:

Classes
struct	test_data_t

struct	test_request_t

struct	server_info

struct	http_status_test_t

struct	large_test

struct	cert_struct_test_t

struct	context

struct	notification

struct	info

struct	notification_data

Macros
#define	_SECURITY_FLAG_CERT_REV_FAILED 0x00800000

#define	_SECURITY_FLAG_CERT_INVALID_CA 0x01000000

#define	_SECURITY_FLAG_CERT_INVALID_CN 0x02000000

#define	_SECURITY_FLAG_CERT_INVALID_DATE 0x04000000

#define	TEST_URL "http://test.winehq.org/tests/hello.html"

#define	SET_EXPECT2(status, num) expect[status] = num

#define	SET_EXPECT(status) SET_EXPECT2(status, 1)

#define	SET_OPTIONAL2(status, num) optional[status] = num

#define	SET_OPTIONAL(status) SET_OPTIONAL2(status, 1)

#define	SET_WINE_ALLOW2(status, num) wine_allow[status] = num

#define	SET_WINE_ALLOW(status) SET_WINE_ALLOW2(status, 1)

#define	CHECK_EXPECT(status)

#define	CLEAR_NOTIFIED(status) expect[status] = optional[status] = wine_allow[status] = notified[status] = 0;

#define	CHECK_NOTIFIED2(status, num)

#define	CHECK_NOTIFIED(status) CHECK_NOTIFIED2(status, 1)

#define	CHECK_NOT_NOTIFIED(status) CHECK_NOTIFIED2(status, 0)

#define	MAX_INTERNET_STATUS (INTERNET_STATUS_COOKIE_HISTORY+1)

#define	TESTF_REDIRECT 0x01

#define	TESTF_COMPRESSED 0x02

#define	TESTF_CHUNKED 0x04

#define	test_status_code(a, b) _test_status_code(__LINE__,a,b, FALSE)

#define	test_status_code_todo(a, b) _test_status_code(__LINE__,a,b, TRUE)

#define	test_request_flags(a, b) _test_request_flags(__LINE__,a,b,FALSE)

#define	test_request_flags_todo(a, b) _test_request_flags(__LINE__,a,b,TRUE)

#define	test_request_url(a, b) _test_request_url(__LINE__,a,b)

#define	test_http_version(a) _test_http_version(__LINE__,a)

#define	open_simple_request(a, b, c, d, e) _open_simple_request(__LINE__,a,b,c,d,e)

#define	close_request(a) _close_request(__LINE__,a)

#define	receive_simple_request(a, b, c) _receive_simple_request(__LINE__,a,b,c)

#define	server_read_request(a) _server_read_request(__LINE__,a)

#define	readex_expect_sync_data_len(a, b, c, d, e, f, g) _readex_expect_sync_data_len(__LINE__,a,b,c,d,e,f,g)

#define	readex_expect_sync_data(a, b, c, d, e, f) _readex_expect_sync_data(__LINE__,a,b,c,d,e,f)

#define	read_expect_sync_data_len(a, b, c, d, e) _read_expect_sync_data_len(__LINE__,a,b,c,d,e)

#define	read_expect_sync_data(a, b, c, d) _read_expect_sync_data(__LINE__,a,b,c,d)

#define	send_response_and_wait(a, b, c, d, e, f, g, h) _send_response_and_wait(__LINE__,a,b,c,d,e,f,g,h)

#define	send_response_ex_and_wait(a, b, c, d, e, f) _send_response_ex_and_wait(__LINE__,a,b,c,d,e,f)

#define	readex_expect_async(a, b, c, d, e) _readex_expect_async(__LINE__,a,b,c,d,e)

#define	expect_data_available(a, b) _expect_data_available(__LINE__,a,b)

#define	async_query_data_available(a, b) _async_query_data_available(__LINE__,a,b)

#define	test_security_info(a, b, c) _test_security_info(__LINE__,a,b,c)

#define	test_secflags_option(a, b, c) _test_secflags_option(__LINE__,a,b,c)

#define	set_secflags(a, b, c) _set_secflags(__LINE__,a,b,c)

#define	STATUS_STRING(status) status_string[status] = #status

Enumerations
enum	api { winhttp_connect = 1 , winhttp_open_request , winhttp_send_request , winhttp_receive_response , winhttp_query_data , winhttp_read_data , winhttp_write_data , winhttp_close_handle , internet_connect = 1 , http_open_request , http_send_request_ex , internet_writefile , http_end_request , internet_close_handle }

Functions
static	INTERNET_STATUS_CALLBACK (WINAPI *pInternetSetStatusCallbackA)(HINTERNET

static	BOOL (WINAPI *pInternetGetSecurityInfoByURLA)(LPSTR

static PCCERT_CHAIN_CONTEXT DWORD *static BOOL	is_lang_english (void)

static int	strcmp_wa (LPCWSTR strw, const char *stra)

static BOOL	proxy_active (void)

static void	init_events (void)

static void	free_events (void)

static void	reset_events (void)

static void	_test_status_code (unsigned line, HINTERNET req, DWORD excode, BOOL is_todo)

static void	_test_request_flags (unsigned line, HINTERNET req, DWORD exflags, BOOL is_todo)

static void	_test_request_url (unsigned line, HINTERNET req, const char *expected_url)

static void	_test_http_version (unsigned line, HINTERNET req)

static VOID WINAPI	callback (HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInformation, DWORD dwStatusInformationLength)

static void	_open_simple_request (unsigned line, test_request_t req, const char host, int port, const char verb, const char url)

static void	_close_request (unsigned line, test_request_t *req)

static DWORD	_receive_simple_request (unsigned line, HINTERNET req, char *buf, size_t buf_size)

static void	close_async_handle (HINTERNET handle, int handle_cnt)

static void	InternetReadFile_test (int flags, const test_data_t *test)

static void	InternetReadFile_chunked_test (void)

static void	InternetReadFileExA_test (int flags)

static void	InternetOpenUrlA_test (void)

static void	HttpSendRequestEx_test (void)

static void	InternetOpenRequest_test (void)

static void	test_cache_read (void)

static void	test_http_cache (void)

static void	InternetLockRequestFile_test (void)

static void	HttpHeaders_test (void)

static DWORD CALLBACK	server_thread (LPVOID param)

static void	test_basic_request (int port, const char verb, const char url)

static void	test_proxy_indirect (int port)

static void	test_proxy_direct (int port)

static void	test_header_handling_order (int port)

static void	test_connection_header (int port)

static void	test_header_override (int port)

static void	test_connection_closing (int port)

static void	test_successive_HttpSendRequest (int port)

static void	test_no_content (int port)

static void	test_conn_close (int port)

static void	test_no_cache (int port)

static void	test_cache_read_gzipped (int port)

static void	test_HttpSendRequestW (int port)

static void	test_cookie_header (int port)

static void	test_basic_authentication (int port)

static void	test_premature_disconnect (int port)

static void	test_invalid_response_headers (int port)

static void	test_response_without_headers (int port)

static void	test_head_request (int port)

static void	test_HttpQueryInfo (int port)

static void	test_options (int port)

static void	test_http_status (int port)

static void	test_cache_control_verb (int port)

static void	test_request_content_length (int port)

static void	test_accept_encoding (int port)

static void	test_basic_auth_credentials_reuse (int port)

static void	test_basic_auth_credentials_end_session (int port)

static void	test_basic_auth_credentials_different (int port)

static void	test_basic_auth_credentials_manual (int port)

static void	test_basic_auth_credentials_cached_manual (int port)

static void	test_async_read (int port)

static void	server_send_string (const char *msg)

static size_t	server_read_data (char *buf, size_t buf_size)

static void	_server_read_request (unsigned line, const char *expected_request)

static void WINAPI	readex_callback (HINTERNET handle, DWORD_PTR context, DWORD status, void *info, DWORD info_size)

static void	send_socket_request (test_request_t *req, BOOL new_connection)

static void	open_socket_request (int port, test_request_t req, const char verb)

static void	open_read_test_request (int port, test_request_t req, const char response)

static void	_readex_expect_sync_data_len (unsigned line, HINTERNET req, DWORD flags, INTERNET_BUFFERSW buf, DWORD buf_size, const char exdata, DWORD len, DWORD expect_receive)

static void	_readex_expect_sync_data (unsigned line, HINTERNET req, DWORD flags, INTERNET_BUFFERSW buf, DWORD buf_size, const char exdata, DWORD expect_receive)

static void	_read_expect_sync_data_len (unsigned line, HINTERNET req, void buf, DWORD buf_size, const char exdata, DWORD len)

static void	_read_expect_sync_data (unsigned line, HINTERNET req, void buf, DWORD buf_size, const char exdata)

static void	close_connection (void)

static void	_send_response_and_wait (unsigned line, const char response, BOOL do_close_connection, void buf, DWORD ret_size, const char exdata, DWORD expected_size, DWORD expected_req_error, DWORD expected_receive_size)

static void	_send_response_ex_and_wait (unsigned line, const char response, BOOL close_connection, INTERNET_BUFFERSW buf, const char *exdata, DWORD expected_req_error, DWORD expected_receive_size)

static void	send_response_len_and_wait (unsigned len, BOOL close_connection, INTERNET_BUFFERSW *buf)

static void	_readex_expect_async (unsigned line, HINTERNET req, DWORD flags, INTERNET_BUFFERSW buf, DWORD buf_size, const char exdata)

static void	read_expect_async (HINTERNET req, void buf, DWORD buf_size, DWORD ret_size, const char *exdata)

static DWORD	_expect_data_available (unsigned line, HINTERNET req, int exsize)

static void	_async_query_data_available (unsigned line, HINTERNET req, DWORD *size)

static void	test_http_read (int port)

static void	test_connection_break (int port)

static void	test_long_url (int port)

static void	test_persistent_connection (int port)

static void	test_redirect (int port)

static void	test_remove_dot_segments (int port)

static void	test_large_content (int port)

static void	test_http_connection (void)

static void	release_cert_info (INTERNET_CERTIFICATE_INFOA *info)

static void	test_cert_struct_string (HINTERNET req, const INTERNET_CERTIFICATE_INFOA *info)

static void	test_cert_struct (HINTERNET req, const cert_struct_test_t *test)

static void	_test_security_info (unsigned line, const char *urlc, DWORD error, DWORD ex_flags)

static void	_test_secflags_option (unsigned line, HINTERNET req, DWORD ex_flags, DWORD opt_flags)

static void	_set_secflags (unsigned line, HINTERNET req, BOOL use_undoc, DWORD flags)

static void	test_security_flags (void)

static void	test_secure_connection (void)

static void	test_user_agent_header (void)

static void	test_bogus_accept_types_array (void)

static void WINAPI	cb (HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID info, DWORD size)

static void	test_open_url_async (void)

static void CALLBACK	check_notification (HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD buflen)

static void	setup_test (struct info *info, enum api function, unsigned int line, DWORD expect_result)

static void	test_async_HttpSendRequestEx (const struct notification_data *nd)

static void WINAPI	closetest_callback (HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInformation, DWORD dwStatusInformationLength)

static void	test_InternetCloseHandle (void)

static void	test_connection_failure (void)

static void	test_default_service_port (void)

static void	init_status_tests (void)

static void WINAPI	header_cb (HINTERNET handle, DWORD_PTR ctx, DWORD status, LPVOID info, DWORD len)

static void	test_concurrent_header_access (void)

static void	test_cert_string (void)

	START_TEST (http)

Variables
static BOOL	first_connection_to_test_url = TRUE

static BOOL	https_support = TRUE

static int	expect [MAX_INTERNET_STATUS]

static int	optional [MAX_INTERNET_STATUS]

static int	wine_allow [MAX_INTERNET_STATUS]

static int	notified [MAX_INTERNET_STATUS]

static const char *	status_string [MAX_INTERNET_STATUS]

static HANDLE	complete_event

static HANDLE	conn_close_event

static HANDLE	conn_wait_event

static HANDLE	server_req_rec_event

static HANDLE	request_sent_event

static DWORD	req_error

static BOOL	is_ie7plus = TRUE

static const test_data_t	test_data []

static	INTERNET_STATUS_CALLBACK

static int	close_handle_cnt

static const char	garbagemsg []

static const char	contmsg []

static const char	expandcontmsg []

static const char	okmsg []

static const char	okmsg201 []

static const char	okmsg2 []

static DWORD64	content_length

static const char	largemsg []

static const char	okmsg_cookie_path []

static const char	okmsg_cookie []

static const char	notokmsg []

static const char	noauthmsg []

static const char	noauthmsg2 []

static const char	proxymsg []

static const char	page1 []

static const char	ok_with_length []

static const char	ok_with_length2 []

static int	test_cache_gzip

static const char *	send_buffer

static int	server_socket

static const http_status_test_t	http_status_tests []

static BOOL	skip_receive_notification_tests

static DWORD	received_response_size

static const cert_struct_test_t	test_winehq_org_cert

static const cert_struct_test_t	test_winehq_com_cert

static const char *	cert_string_fmt

static CRITICAL_SECTION	notification_cs

static const struct notification	async_send_request_ex_test []

static const struct notification	async_send_request_ex_test2 []

static const struct notification	async_send_request_ex_resolve_failure_test []

static const struct notification	async_send_request_ex_chunked_test []

static const struct notification_data	notification_data []

static HINTERNET	closetest_session

static HINTERNET	closetest_req

static HINTERNET	closetest_conn

static BOOL	closetest_closed

Macro Definition Documentation

◆ _SECURITY_FLAG_CERT_INVALID_CA

#define _SECURITY_FLAG_CERT_INVALID_CA 0x01000000

Definition at line 38 of file http.c.

◆ _SECURITY_FLAG_CERT_INVALID_CN

#define _SECURITY_FLAG_CERT_INVALID_CN 0x02000000

Definition at line 39 of file http.c.

◆ _SECURITY_FLAG_CERT_INVALID_DATE

#define _SECURITY_FLAG_CERT_INVALID_DATE 0x04000000

Definition at line 40 of file http.c.

◆ _SECURITY_FLAG_CERT_REV_FAILED

#define _SECURITY_FLAG_CERT_REV_FAILED 0x00800000

Definition at line 37 of file http.c.

◆ async_query_data_available

#define async_query_data_available	(	a,
		b
	)	_async_query_data_available(__LINE__,a,b)

Definition at line 5703 of file http.c.

◆ CHECK_EXPECT

#define CHECK_EXPECT ( status )

Value:

    do { \
        if (!expect[status] && !optional[status] && wine_allow[status]) \
        { \
            todo_wine ok(expect[status], "unexpected status %d (%s)\n", status, \
                         status < MAX_INTERNET_STATUS && status_string[status] ? \
                         status_string[status] : "unknown");            \
            wine_allow[status]--; \
        } \
        else \
        { \
            ok(expect[status] || optional[status], "unexpected status %d (%s)\n", status,   \
               status < MAX_INTERNET_STATUS && status_string[status] ? \
               status_string[status] : "unknown");                      \
            if (expect[status]) expect[status]--; \
            else if(optional[status]) optional[status]--; \
        } \
        notified[status]++; \
    }while(0)

Definition at line 69 of file http.c.

◆ CHECK_NOT_NOTIFIED

#define CHECK_NOT_NOTIFIED ( status ) CHECK_NOTIFIED2(status, 0)

Definition at line 106 of file http.c.

◆ CHECK_NOTIFIED

#define CHECK_NOTIFIED ( status ) CHECK_NOTIFIED2(status, 1)

Definition at line 103 of file http.c.

◆ CHECK_NOTIFIED2

#define CHECK_NOTIFIED2	(	status,
		num
	)

Value:

    do { \
        ok(notified[status] + optional[status] == (num), \
           "expected status %d (%s) %d times, received %d times\n", \
           status, status < MAX_INTERNET_STATUS && status_string[status] ? \
           status_string[status] : "unknown", (num), notified[status]); \
        CLEAR_NOTIFIED(status);                                         \
    }while(0)

Definition at line 94 of file http.c.

◆ CLEAR_NOTIFIED

#define CLEAR_NOTIFIED ( status ) expect[status] = optional[status] = wine_allow[status] = notified[status] = 0;

Definition at line 91 of file http.c.

◆ close_request

#define close_request ( a ) _close_request(__LINE__,a)

Definition at line 547 of file http.c.

◆ expect_data_available

#define expect_data_available	(	a,
		b
	)	_expect_data_available(__LINE__,a,b)

Definition at line 5689 of file http.c.

◆ MAX_INTERNET_STATUS

#define MAX_INTERNET_STATUS (INTERNET_STATUS_COOKIE_HISTORY+1)

Definition at line 109 of file http.c.

◆ open_simple_request

#define open_simple_request	(	a,
		b,
		c,
		d,
		e
	)	_open_simple_request(__LINE__,a,b,c,d,e)

Definition at line 533 of file http.c.

◆ read_expect_sync_data

#define read_expect_sync_data	(	a,
		b,
		c,
		d
	)	_read_expect_sync_data(__LINE__,a,b,c,d)

Definition at line 5569 of file http.c.

◆ read_expect_sync_data_len

#define read_expect_sync_data_len	(	a,
		b,
		c,
		d,
		e
	)	_read_expect_sync_data_len(__LINE__,a,b,c,d,e)

Definition at line 5543 of file http.c.

◆ readex_expect_async

#define readex_expect_async	(	a,
		b,
		c,
		d,
		e
	)	_readex_expect_async(__LINE__,a,b,c,d,e)

Definition at line 5638 of file http.c.

◆ readex_expect_sync_data

#define readex_expect_sync_data	(	a,
		b,
		c,
		d,
		e,
		f
	)	_readex_expect_sync_data(__LINE__,a,b,c,d,e,f)

Definition at line 5536 of file http.c.

◆ readex_expect_sync_data_len

#define readex_expect_sync_data_len	(	a,
		b,
		c,
		d,
		e,
		f,
		g
	)	_readex_expect_sync_data_len(__LINE__,a,b,c,d,e,f,g)

Definition at line 5509 of file http.c.

◆ receive_simple_request

#define receive_simple_request	(	a,
		b,
		c
	)	_receive_simple_request(__LINE__,a,b,c)

Definition at line 560 of file http.c.

◆ send_response_and_wait

#define send_response_and_wait	(	a,
		b,
		c,
		d,
		e,
		f,
		g,
		h
	)	_send_response_and_wait(__LINE__,a,b,c,d,e,f,g,h)

Definition at line 5583 of file http.c.

◆ send_response_ex_and_wait

#define send_response_ex_and_wait	(	a,
		b,
		c,
		d,
		e,
		f
	)	_send_response_ex_and_wait(__LINE__,a,b,c,d,e,f)

Definition at line 5617 of file http.c.

◆ server_read_request

#define server_read_request ( a ) _server_read_request(__LINE__,a)

Definition at line 5388 of file http.c.

◆ SET_EXPECT

#define SET_EXPECT ( status ) SET_EXPECT2(status, 1)

Definition at line 52 of file http.c.

◆ SET_EXPECT2

#define SET_EXPECT2	(	status,
		num
	)	expect[status] = num

Definition at line 49 of file http.c.

◆ SET_OPTIONAL

#define SET_OPTIONAL ( status ) SET_OPTIONAL2(status, 1)

Definition at line 58 of file http.c.

◆ SET_OPTIONAL2

#define SET_OPTIONAL2	(	status,
		num
	)	optional[status] = num

Definition at line 55 of file http.c.

◆ set_secflags

#define set_secflags	(	a,
		b,
		c
	)	_set_secflags(__LINE__,a,b,c)

Definition at line 6611 of file http.c.

◆ SET_WINE_ALLOW

#define SET_WINE_ALLOW ( status ) SET_WINE_ALLOW2(status, 1)

Definition at line 66 of file http.c.

◆ SET_WINE_ALLOW2

#define SET_WINE_ALLOW2	(	status,
		num
	)	wine_allow[status] = num

Definition at line 63 of file http.c.

◆ STATUS_STRING

#define STATUS_STRING ( status ) status_string[status] = #status

◆ test_http_version

#define test_http_version ( a ) _test_http_version(__LINE__,a)

Definition at line 352 of file http.c.

◆ test_request_flags

#define test_request_flags	(	a,
		b
	)	_test_request_flags(__LINE__,a,b,FALSE)

Definition at line 321 of file http.c.

◆ test_request_flags_todo

#define test_request_flags_todo	(	a,
		b
	)	_test_request_flags(__LINE__,a,b,TRUE)

Definition at line 322 of file http.c.

◆ test_request_url

#define test_request_url	(	a,
		b
	)	_test_request_url(__LINE__,a,b)

Definition at line 339 of file http.c.

◆ test_secflags_option

#define test_secflags_option	(	a,
		b,
		c
	)	_test_secflags_option(__LINE__,a,b,c)

Definition at line 6589 of file http.c.

◆ test_security_info

#define test_security_info	(	a,
		b,
		c
	)	_test_security_info(__LINE__,a,b,c)

Definition at line 6549 of file http.c.

◆ test_status_code

#define test_status_code	(	a,
		b
	)	_test_status_code(__LINE__,a,b, FALSE)

Definition at line 247 of file http.c.

◆ test_status_code_todo

#define test_status_code_todo	(	a,
		b
	)	_test_status_code(__LINE__,a,b, TRUE)

Definition at line 248 of file http.c.

◆ TEST_URL

#define TEST_URL "http://test.winehq.org/tests/hello.html"

Definition at line 42 of file http.c.

◆ TESTF_CHUNKED

#define TESTF_CHUNKED 0x04

Definition at line 120 of file http.c.

◆ TESTF_COMPRESSED

#define TESTF_COMPRESSED 0x02

Definition at line 119 of file http.c.

◆ TESTF_REDIRECT

#define TESTF_REDIRECT 0x01

Definition at line 118 of file http.c.

Enumeration Type Documentation

◆ api

enum api

Enumerator
winhttp_connect
winhttp_open_request
winhttp_send_request
winhttp_receive_response
winhttp_query_data
winhttp_read_data
winhttp_write_data
winhttp_close_handle
internet_connect
http_open_request
http_send_request_ex
internet_writefile
http_end_request
internet_close_handle

Definition at line 7354 of file http.c.

{
    internet_connect = 1,
    http_open_request,
    http_send_request_ex,
    internet_writefile,
    http_end_request,
    internet_close_handle
};

Function Documentation

◆ _async_query_data_available()

static void _async_query_data_available	(	unsigned	line,
		HINTERNET	req,
		DWORD *	size
	)

static

Definition at line 5704 of file http.c.

{
    BOOL res;
 
    if(!skip_receive_notification_tests)
        SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE);
 
    *size = 0xdeadbeef;
    res = InternetQueryDataAvailable(req, size, 0, 0);
    ok_(__FILE__,line)(!res && GetLastError() == ERROR_IO_PENDING,
                       "InternetQueryDataAvailable returned: %x(%u)\n", res, GetLastError());
    ok_(__FILE__,line)(!*size, "size = %u\n", *size);
 
    if(!skip_receive_notification_tests)
        CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
}

◆ _close_request()

static void _close_request	(	unsigned	line,
		test_request_t *	req
	)

static

Definition at line 548 of file http.c.

{
    BOOL ret;
 
    ret = InternetCloseHandle(req->request);
    ok_(__FILE__,line)(ret, "InternetCloseHandle(request) failed: %u\n", GetLastError());
    ret = InternetCloseHandle(req->connection);
    ok_(__FILE__,line)(ret, "InternetCloseHandle(connection) failed: %u\n", GetLastError());
    ret = InternetCloseHandle(req->session);
    ok_(__FILE__,line)(ret, "InternetCloseHandle(session) failed: %u\n", GetLastError());
}

◆ _expect_data_available()

static DWORD _expect_data_available	(	unsigned	line,
		HINTERNET	req,
		int	exsize
	)

static

Definition at line 5690 of file http.c.

{
    DWORD size = 0;
    BOOL res;
 
    res = InternetQueryDataAvailable(req, &size, 0, 0);
    ok_(__FILE__,line)(res, "InternetQueryDataAvailable failed: %u\n", GetLastError());
    if(exsize != -1)
        ok_(__FILE__,line)(size  == exsize, "size = %u, expected %u\n", size, exsize);
 
    return size;
}

◆ _open_simple_request()

static void _open_simple_request	(	unsigned	line,
		test_request_t *	req,
		const char *	host,
		int	port,
		const char *	verb,
		const char *	url
	)

static

Definition at line 534 of file http.c.

{
    req->session = InternetOpenA(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
    ok_(__FILE__,line)(req->session != NULL, "InternetOpenA failed: %u\n", GetLastError());
 
    req->connection = InternetConnectA(req->session, host, port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
    ok_(__FILE__,line)(req->connection != NULL, "InternetConnectA failed: %u\n", GetLastError());
 
    req->request = HttpOpenRequestA(req->connection, verb, url, NULL, NULL, NULL, 0, 0);
    ok_(__FILE__,line)(req->request != NULL, "HttpOpenRequest failed: %u\n", GetLastError());
}

◆ _read_expect_sync_data()

static void _read_expect_sync_data	(	unsigned	line,
		HINTERNET	req,
		void *	buf,
		DWORD	buf_size,
		const char *	exdata
	)

static

Definition at line 5570 of file http.c.

{
    _read_expect_sync_data_len(line, req, buf, buf_size, exdata, strlen(exdata));
}

◆ _read_expect_sync_data_len()

static void _read_expect_sync_data_len	(	unsigned	line,
		HINTERNET	req,
		void *	buf,
		DWORD	buf_size,
		const char *	exdata,
		DWORD	len
	)

static

Definition at line 5544 of file http.c.

{
    DWORD ret_size = 0xdeadbeef;
    BOOL ret;
 
    SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE);
    SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED);
    SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
    received_response_size = 0xdeadbeef;
 
    memset(buf, 0xff, buf_size);
    ret = InternetReadFile(req, buf, buf_size, &ret_size);
    ok_(__FILE__,line)(ret, "InternetReadFileExW failed: %u\n", GetLastError());
    ok_(__FILE__,line)(ret_size == len, "dwBufferLength = %u, expected %u\n", ret_size, len);
    if(len && exdata)
        ok_(__FILE__,line)(!memcmp(buf, exdata, len), "Unexpected data\n");
 
    CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
    CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
    CLEAR_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
    ok_(__FILE__,line)(received_response_size == len, "received_response_size = %u\n", received_response_size);
    ok_(__FILE__,line)(!req_error, "req_error = %u\n", req_error);
}

Referenced by _read_expect_sync_data().

◆ _readex_expect_async()

static void _readex_expect_async	(	unsigned	line,
		HINTERNET	req,
		DWORD	flags,
		INTERNET_BUFFERSW *	buf,
		DWORD	buf_size,
		const char *	exdata
	)

static

Definition at line 5639 of file http.c.

{
    unsigned len = 0;
    BOOL ret;
 
    if(!skip_receive_notification_tests)
        SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE);
 
    memset(buf->lpvBuffer, 0, max(buf_size, sizeof(DWORD)));
    buf->dwBufferLength = buf_size;
    ret = InternetReadFileExW(req, buf, flags, 0xdeadbeef);
    ok_(__FILE__,line)(!ret && GetLastError() == ERROR_IO_PENDING, "InternetReadFileExW returned %x (%u)\n", ret, GetLastError());
    ok_(__FILE__,line)(buf->dwBufferLength == buf_size, "dwBufferLength = %u, expected %u\n", buf->dwBufferLength, buf_size);
    if(exdata) {
        len = strlen(exdata);
        ok_(__FILE__,line)(!memcmp(buf->lpvBuffer, exdata, len), "unexpected buffer data\n");
    }else {
        ok_(__FILE__,line)(!*(DWORD*)buf->lpvBuffer, "buffer data changed\n");
    }
 
    if(!skip_receive_notification_tests)
        CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
}

◆ _readex_expect_sync_data()

static void _readex_expect_sync_data	(	unsigned	line,
		HINTERNET	req,
		DWORD	flags,
		INTERNET_BUFFERSW *	buf,
		DWORD	buf_size,
		const char *	exdata,
		DWORD	expect_receive
	)

static

Definition at line 5537 of file http.c.

{
    _readex_expect_sync_data_len(line, req, flags, buf, buf_size, exdata, strlen(exdata), expect_receive);
}

◆ _readex_expect_sync_data_len()

static void _readex_expect_sync_data_len	(	unsigned	line,
		HINTERNET	req,
		DWORD	flags,
		INTERNET_BUFFERSW *	buf,
		DWORD	buf_size,
		const char *	exdata,
		DWORD	len,
		DWORD	expect_receive
	)

static

Definition at line 5510 of file http.c.

{
    BOOL ret;
 
    if(!skip_receive_notification_tests && expect_receive) {
        SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE);
        SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED);
        received_response_size = 0xdeadbeef;
    }
 
    memset(buf->lpvBuffer, 0xff, buf_size);
    buf->dwBufferLength = buf_size;
    ret = InternetReadFileExW(req, buf, flags, 0xdeadbeef);
    ok_(__FILE__,line)(ret, "InternetReadFileExW failed: %u\n", GetLastError());
    ok_(__FILE__,line)(buf->dwBufferLength == len, "dwBufferLength = %u, expected %u\n", buf->dwBufferLength, len);
    if(len && exdata)
        ok_(__FILE__,line)(!memcmp(buf->lpvBuffer, exdata, len), "Unexpected data\n");
 
    if(!skip_receive_notification_tests && expect_receive) {
        CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
        CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
        ok_(__FILE__,line)(received_response_size == len, "received_response_size = %u\n", received_response_size);
    }
}

Referenced by _readex_expect_sync_data().

◆ _receive_simple_request()

static DWORD _receive_simple_request	(	unsigned	line,
		HINTERNET	req,
		char *	buf,
		size_t	buf_size
	)

static

Definition at line 561 of file http.c.

{
    DWORD read = 0;
    BOOL ret;
 
    ret = InternetReadFile(req, buf, buf_size, &read);
    ok_(__FILE__,line)(ret, "InternetReadFile failed: %u\n", GetLastError());
 
    return read;
}

◆ _send_response_and_wait()

static void _send_response_and_wait	(	unsigned	line,
		const char *	response,
		BOOL	do_close_connection,
		void *	buf,
		DWORD *	ret_size,
		const char *	exdata,
		DWORD	expected_size,
		DWORD	expected_req_error,
		DWORD	expected_receive_size
	)

static

Definition at line 5584 of file http.c.

{
    if(!skip_receive_notification_tests)
        SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED);
    SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
 
    if(response)
        server_send_string(response);
 
    if(do_close_connection)
        close_connection();
 
    WaitForSingleObject(complete_event, INFINITE);
 
    if(!skip_receive_notification_tests)
        CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
    CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
    if(!skip_receive_notification_tests && expected_receive_size != -1)
        todo_wine_if(received_response_size != expected_receive_size) /* FIXME! remove when wine is fixed */
        ok_(__FILE__,line)(received_response_size == expected_receive_size,
                           "received_response_size = %u\n", received_response_size);
    ok_(__FILE__,line)(req_error == expected_req_error, "req_error = %u, expected %u\n", req_error, expected_req_error);
 
    /* If IRF_NO_WAIT is used, buffer is not changed. */
    ok_(__FILE__,line)(*ret_size == expected_size, "dwBufferLength = %u\n", *ret_size);
    if(exdata)
        ok_(__FILE__,line)(!memcmp(buf, exdata, strlen(exdata)), "unexpected buffer data\n");
    else if(buf)
        ok_(__FILE__,line)(!*(DWORD*)buf, "buffer data changed\n");
}

Referenced by _send_response_ex_and_wait().

◆ _send_response_ex_and_wait()

static void _send_response_ex_and_wait	(	unsigned	line,
		const char *	response,
		BOOL	close_connection,
		INTERNET_BUFFERSW *	buf,
		const char *	exdata,
		DWORD	expected_req_error,
		DWORD	expected_receive_size
	)

static

Definition at line 5618 of file http.c.

{
    _send_response_and_wait(line, response, close_connection, buf->lpvBuffer, &buf->dwBufferLength,
                            exdata, exdata ? strlen(exdata) : buf->dwBufferLength, expected_req_error,
                            expected_receive_size);
}

◆ _server_read_request()

static void _server_read_request	(	unsigned	line,
		const char *	expected_request
	)

static

Definition at line 5389 of file http.c.

{
    char buf[4000], *p;
    size_t size;
 
    size = server_read_data(buf, sizeof(buf) - 1);
    buf[size] = 0;
    p = strstr(buf, "\r\n");
    if(p) *p = 0;
    ok_(__FILE__,line)(p && !strcmp(buf, expected_request), "unexpected request %s\n", buf);
}

◆ _set_secflags()

static void _set_secflags	(	unsigned	line,
		HINTERNET	req,
		BOOL	use_undoc,
		DWORD	flags
	)

static

Definition at line 6612 of file http.c.

{
    BOOL res;
 
    res = InternetSetOptionW(req, use_undoc ? 99 : INTERNET_OPTION_SECURITY_FLAGS, &flags, sizeof(flags));
    ok_(__FILE__,line)(res, "InternetSetOption(INTERNET_OPTION_SECURITY_FLAGS) failed: %u\n", GetLastError());
}

◆ _test_http_version()

static void _test_http_version	(	unsigned	line,
		HINTERNET	req
	)

static

Definition at line 353 of file http.c.

{
    HTTP_VERSION_INFO v = {0xdeadbeef, 0xdeadbeef};
    DWORD size;
    BOOL res;
 
    size = sizeof(v);
    res = InternetQueryOptionW(req, INTERNET_OPTION_HTTP_VERSION, &v, &size);
    ok_(__FILE__,line)(res, "InternetQueryOptionW(INTERNET_OPTION_HTTP_VERSION) failed: %u\n", GetLastError());
    ok_(__FILE__,line)(v.dwMajorVersion == 1, "dwMajorVersion = %d\n", v.dwMajorVersion);
    ok_(__FILE__,line)(v.dwMinorVersion == 1, "dwMinorVersion = %d\n", v.dwMinorVersion);
}

◆ _test_request_flags()

static void _test_request_flags	(	unsigned	line,
		HINTERNET	req,
		DWORD	exflags,
		BOOL	is_todo
	)

static

Definition at line 323 of file http.c.

{
    DWORD flags, size;
    BOOL res;
 
    flags = 0xdeadbeef;
    size = sizeof(flags);
    res = InternetQueryOptionW(req, INTERNET_OPTION_REQUEST_FLAGS, &flags, &size);
    ok_(__FILE__,line)(res, "InternetQueryOptionW(INTERNET_OPTION_REQUEST_FLAGS) failed: %u\n", GetLastError());
 
    /* FIXME: Remove once we have INTERNET_REQFLAG_CACHE_WRITE_DISABLED implementation */
    flags &= ~INTERNET_REQFLAG_CACHE_WRITE_DISABLED;
    todo_wine_if (is_todo)
        ok_(__FILE__,line)(flags == exflags, "flags = %x, expected %x\n", flags, exflags);
}

◆ _test_request_url()

static void _test_request_url	(	unsigned	line,
		HINTERNET	req,
		const char *	expected_url
	)

static

Definition at line 340 of file http.c.

{
    char buf[INTERNET_MAX_URL_LENGTH];
    DWORD size = sizeof(buf);
    BOOL res;
 
    res = InternetQueryOptionA(req, INTERNET_OPTION_URL, buf, &size);
    ok_(__FILE__,line)(res, "InternetQueryOptionA(INTERNET_OPTION_URL) failed: %u\n", GetLastError());
    ok_(__FILE__,line)(size == strlen(expected_url), "size = %u\n", size);
    ok_(__FILE__,line)(!strcmp(buf, expected_url), "unexpected URL %s, expected %s\n", buf, expected_url);
}

◆ _test_secflags_option()

static void _test_secflags_option	(	unsigned	line,
		HINTERNET	req,
		DWORD	ex_flags,
		DWORD	opt_flags
	)

static

Definition at line 6590 of file http.c.

{
    DWORD flags, size;
    BOOL res;
 
    flags = 0xdeadbeef;
    size = sizeof(flags);
    res = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_FLAGS, &flags, &size);
    ok_(__FILE__,line)(res, "InternetQueryOptionW(INTERNET_OPTION_SECURITY_FLAGS) failed: %u\n", GetLastError());
    ok_(__FILE__,line)((flags & ~opt_flags) == ex_flags, "INTERNET_OPTION_SECURITY_FLAGS flags = %x, expected %x\n",
                       flags, ex_flags);
 
    /* Option 98 is undocumented and seems to be the same as INTERNET_OPTION_SECURITY_FLAGS */
    flags = 0xdeadbeef;
    size = sizeof(flags);
    res = InternetQueryOptionW(req, 98, &flags, &size);
    ok_(__FILE__,line)(res, "InternetQueryOptionW(98) failed: %u\n", GetLastError());
    ok_(__FILE__,line)((flags & ~opt_flags) == ex_flags, "INTERNET_OPTION_SECURITY_FLAGS(98) flags = %x, expected %x\n",
                       flags, ex_flags);
}

◆ _test_security_info()

static void _test_security_info	(	unsigned	line,
		const char *	urlc,
		DWORD	error,
		DWORD	ex_flags
	)

static

Definition at line 6550 of file http.c.

{
    char url[INTERNET_MAX_URL_LENGTH];
    const CERT_CHAIN_CONTEXT *chain;
    DWORD flags;
    BOOL res;
 
    if(!pInternetGetSecurityInfoByURLA) {
        win_skip("pInternetGetSecurityInfoByURLA not available\n");
        return;
    }
 
    strcpy(url, urlc);
    chain = (void*)0xdeadbeef;
    flags = 0xdeadbeef;
    res = pInternetGetSecurityInfoByURLA(url, &chain, &flags);
    if(error == ERROR_SUCCESS) {
        ok_(__FILE__,line)(res, "InternetGetSecurityInfoByURLA failed: %u\n", GetLastError());
        ok_(__FILE__,line)(chain != NULL, "chain = NULL\n");
        ok_(__FILE__,line)(flags == ex_flags, "flags = %x\n", flags);
        CertFreeCertificateChain(chain);
 
        SetLastError(0xdeadbeef);
        res = pInternetGetSecurityInfoByURLA(url, NULL, NULL);
        ok_(__FILE__,line)(!res && GetLastError() == ERROR_INVALID_PARAMETER,
                           "InternetGetSecurityInfoByURLA returned: %x(%u)\n", res, GetLastError());
 
        res = pInternetGetSecurityInfoByURLA(url, &chain, NULL);
        ok_(__FILE__,line)(res, "InternetGetSecurityInfoByURLA failed: %u\n", GetLastError());
        CertFreeCertificateChain(chain);
 
        res = pInternetGetSecurityInfoByURLA(url, NULL, &flags);
        ok_(__FILE__,line)(res, "InternetGetSecurityInfoByURLA failed: %u\n", GetLastError());
    }else {
        ok_(__FILE__,line)(!res && GetLastError() == error,
                           "InternetGetSecurityInfoByURLA returned: %x(%u), expected %u\n", res, GetLastError(), error);
    }
}

◆ _test_status_code()

static void _test_status_code	(	unsigned	line,
		HINTERNET	req,
		DWORD	excode,
		BOOL	is_todo
	)

static

Definition at line 249 of file http.c.

{
    DWORD code, size, index;
    char exbuf[12], bufa[10];
    WCHAR bufw[10];
    BOOL res;
 
    code = 0xdeadbeef;
    size = sizeof(code);
    res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &code, &size, NULL);
    ok_(__FILE__,line)(res, "[1] HttpQueryInfoA(HTTP_QUERY_STATUS_CODE|number) failed: %u\n", GetLastError());
    todo_wine_if (is_todo)
        ok_(__FILE__,line)(code == excode, "code = %d, expected %d\n", code, excode);
    ok_(__FILE__,line)(size == sizeof(code), "size = %u\n", size);
 
    code = 0xdeadbeef;
    index = 0;
    size = sizeof(code);
    res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &code, &size, &index);
    ok_(__FILE__,line)(res, "[2] HttpQueryInfoA(HTTP_QUERY_STATUS_CODE|number index) failed: %u\n", GetLastError());
    ok_(__FILE__,line)(!index, "index = %d, expected 0\n", index);
    ok_(__FILE__,line)(size == sizeof(code), "size = %u\n", size);
 
    sprintf(exbuf, "%u", excode);
 
    size = sizeof(bufa);
    res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE, bufa, &size, NULL);
    ok_(__FILE__,line)(res, "[3] HttpQueryInfoA(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError());
    todo_wine_if (is_todo)
        ok_(__FILE__,line)(!strcmp(bufa, exbuf), "unexpected status code %s, expected %s\n", bufa, exbuf);
    ok_(__FILE__,line)(size == strlen(exbuf), "unexpected size %d for \"%s\"\n", size, exbuf);
 
    size = 0;
    res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE, NULL, &size, NULL);
    ok_(__FILE__,line)(!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
                       "[4] HttpQueryInfoA(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError());
    ok_(__FILE__,line)(size == strlen(exbuf)+1, "unexpected size %d for \"%s\"\n", size, exbuf);
 
    size = sizeof(bufw);
    res = HttpQueryInfoW(req, HTTP_QUERY_STATUS_CODE, bufw, &size, NULL);
    ok_(__FILE__,line)(res, "[5] HttpQueryInfoW(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError());
    todo_wine_if (is_todo)
        ok_(__FILE__,line)(!strcmp_wa(bufw, exbuf), "unexpected status code %s, expected %s\n", bufa, exbuf);
    ok_(__FILE__,line)(size == strlen(exbuf)*sizeof(WCHAR), "unexpected size %d for \"%s\"\n", size, exbuf);
 
    size = 0;
    res = HttpQueryInfoW(req, HTTP_QUERY_STATUS_CODE, bufw, &size, NULL);
    ok_(__FILE__,line)(!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
                       "[6] HttpQueryInfoW(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError());
    ok_(__FILE__,line)(size == (strlen(exbuf)+1)*sizeof(WCHAR), "unexpected size %d for \"%s\"\n", size, exbuf);
 
    if(0) {
    size = sizeof(bufw);
    res = HttpQueryInfoW(req, HTTP_QUERY_STATUS_CODE, NULL, &size, NULL);
    ok(!res && GetLastError() == ERROR_INVALID_PARAMETER, "HttpQueryInfo(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError());
    ok(size == sizeof(bufw), "unexpected size %d\n", size);
    }
 
    code = 0xdeadbeef;
    index = 1;
    size = sizeof(code);
    res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &code, &size, &index);
    ok_(__FILE__,line)(!res && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND,
                       "[7] HttpQueryInfoA failed: %x(%d)\n", res, GetLastError());
 
    code = 0xdeadbeef;
    size = sizeof(code);
    res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_REQUEST_HEADERS, &code, &size, NULL);
    ok_(__FILE__,line)(!res && GetLastError() == ERROR_HTTP_INVALID_QUERY_REQUEST,
                       "[8] HttpQueryInfoA failed: %x(%d)\n", res, GetLastError());
}

◆ BOOL()

static BOOL ( WINAPI * pInternetGetSecurityInfoByURLA )

static

◆ callback()

static VOID WINAPI callback	(	HINTERNET	hInternet,
		DWORD_PTR	dwContext,
		DWORD	dwInternetStatus,
		LPVOID	lpvStatusInformation,
		DWORD	dwStatusInformationLength
	)

static

Definition at line 368 of file http.c.

{
    ros_skip_flaky
    CHECK_EXPECT(dwInternetStatus);
    switch (dwInternetStatus)
    {
        case INTERNET_STATUS_RESOLVING_NAME:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RESOLVING_NAME \"%s\" %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      (LPCSTR)lpvStatusInformation,dwStatusInformationLength);
            *(LPSTR)lpvStatusInformation = '\0';
            break;
        case INTERNET_STATUS_NAME_RESOLVED:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_NAME_RESOLVED \"%s\" %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      (LPCSTR)lpvStatusInformation,dwStatusInformationLength);
            *(LPSTR)lpvStatusInformation = '\0';
            break;
        case INTERNET_STATUS_CONNECTING_TO_SERVER:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTING_TO_SERVER \"%s\" %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      (LPCSTR)lpvStatusInformation,dwStatusInformationLength);
            ok(dwStatusInformationLength == strlen(lpvStatusInformation)+1, "unexpected size %u\n",
               dwStatusInformationLength);
            *(LPSTR)lpvStatusInformation = '\0';
            break;
        case INTERNET_STATUS_CONNECTED_TO_SERVER:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTED_TO_SERVER \"%s\" %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      (LPCSTR)lpvStatusInformation,dwStatusInformationLength);
            ok(dwStatusInformationLength == strlen(lpvStatusInformation)+1, "unexpected size %u\n",
               dwStatusInformationLength);
            *(LPSTR)lpvStatusInformation = '\0';
            break;
        case INTERNET_STATUS_SENDING_REQUEST:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_SENDING_REQUEST %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      lpvStatusInformation,dwStatusInformationLength);
            break;
        case INTERNET_STATUS_REQUEST_SENT:
            ok(dwStatusInformationLength == sizeof(DWORD),
                "info length should be sizeof(DWORD) instead of %d\n",
                dwStatusInformationLength);
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REQUEST_SENT 0x%x %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      *(DWORD *)lpvStatusInformation,dwStatusInformationLength);
            break;
        case INTERNET_STATUS_RECEIVING_RESPONSE:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RECEIVING_RESPONSE %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      lpvStatusInformation,dwStatusInformationLength);
            break;
        case INTERNET_STATUS_RESPONSE_RECEIVED:
            ok(dwStatusInformationLength == sizeof(DWORD),
                "info length should be sizeof(DWORD) instead of %d\n",
                dwStatusInformationLength);
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RESPONSE_RECEIVED 0x%x %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      *(DWORD *)lpvStatusInformation,dwStatusInformationLength);
            break;
        case INTERNET_STATUS_CTL_RESPONSE_RECEIVED:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CTL_RESPONSE_RECEIVED %p %d\n",
                      GetCurrentThreadId(), hInternet,dwContext,
                      lpvStatusInformation,dwStatusInformationLength);
            break;
        case INTERNET_STATUS_PREFETCH:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_PREFETCH %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      lpvStatusInformation,dwStatusInformationLength);
            break;
        case INTERNET_STATUS_CLOSING_CONNECTION:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CLOSING_CONNECTION %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      lpvStatusInformation,dwStatusInformationLength);
            break;
        case INTERNET_STATUS_CONNECTION_CLOSED:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTION_CLOSED %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      lpvStatusInformation,dwStatusInformationLength);
            break;
        case INTERNET_STATUS_HANDLE_CREATED:
            ok(dwStatusInformationLength == sizeof(HINTERNET),
                "info length should be sizeof(HINTERNET) instead of %d\n",
                dwStatusInformationLength);
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_HANDLE_CREATED %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      *(HINTERNET *)lpvStatusInformation,dwStatusInformationLength);
            CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY);
            SET_EXPECT(INTERNET_STATUS_DETECTING_PROXY);
            break;
        case INTERNET_STATUS_HANDLE_CLOSING:
            ok(dwStatusInformationLength == sizeof(HINTERNET),
                "info length should be sizeof(HINTERNET) instead of %d\n",
                dwStatusInformationLength);
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_HANDLE_CLOSING %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      *(HINTERNET *)lpvStatusInformation, dwStatusInformationLength);
            if(!InterlockedDecrement(&close_handle_cnt))
                SetEvent(complete_event);
            break;
        case INTERNET_STATUS_REQUEST_COMPLETE:
        {
            INTERNET_ASYNC_RESULT *iar = (INTERNET_ASYNC_RESULT *)lpvStatusInformation;
            ok(dwStatusInformationLength == sizeof(INTERNET_ASYNC_RESULT),
                "info length should be sizeof(INTERNET_ASYNC_RESULT) instead of %d\n",
                dwStatusInformationLength);
            ok(iar->dwResult == 1 || iar->dwResult == 0, "iar->dwResult = %ld\n", iar->dwResult);
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REQUEST_COMPLETE {%ld,%d} %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      iar->dwResult,iar->dwError,dwStatusInformationLength);
            req_error = iar->dwError;
            if(!close_handle_cnt)
                SetEvent(complete_event);
            break;
        }
        case INTERNET_STATUS_REDIRECT:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REDIRECT \"%s\" %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      (LPCSTR)lpvStatusInformation, dwStatusInformationLength);
            *(LPSTR)lpvStatusInformation = '\0';
            CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY);
            SET_EXPECT(INTERNET_STATUS_DETECTING_PROXY);
            break;
        case INTERNET_STATUS_INTERMEDIATE_RESPONSE:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx INTERNET_STATUS_INTERMEDIATE_RESPONSE %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext,
                      lpvStatusInformation, dwStatusInformationLength);
            break;
        default:
            if(winetest_debug > 1)
                trace("%04x:Callback %p 0x%lx %d %p %d\n",
                      GetCurrentThreadId(), hInternet, dwContext, dwInternetStatus,
                      lpvStatusInformation, dwStatusInformationLength);
    }
}

◆ cb()

static void WINAPI cb	(	HINTERNET	handle,
		DWORD_PTR	context,
		DWORD	status,
		LPVOID	info,
		DWORD	size
	)

static

Definition at line 7257 of file http.c.

{
    INTERNET_ASYNC_RESULT *result = info;
    struct context *ctx = (struct context *)context;
 
    if(winetest_debug > 1)
        trace("%p 0x%08lx %u %p 0x%08x\n", handle, context, status, info, size);
 
    switch(status) {
    case INTERNET_STATUS_REQUEST_COMPLETE:
        trace("request handle: 0x%08lx\n", result->dwResult);
        ctx->req = (HINTERNET)result->dwResult;
        SetEvent(ctx->event);
        break;
    case INTERNET_STATUS_HANDLE_CLOSING: {
        DWORD type = INTERNET_HANDLE_TYPE_CONNECT_HTTP, size = sizeof(type);
 
        if (InternetQueryOptionA(handle, INTERNET_OPTION_HANDLE_TYPE, &type, &size))
            ok(type != INTERNET_HANDLE_TYPE_CONNECT_HTTP, "unexpected callback\n");
        SetEvent(ctx->event);
        break;
    }
    case INTERNET_STATUS_NAME_RESOLVED:
    case INTERNET_STATUS_CONNECTING_TO_SERVER:
    case INTERNET_STATUS_CONNECTED_TO_SERVER: {
        char *str = info;
        ok(str[0] && str[1], "Got string: %s\n", str);
        ok(size == strlen(str)+1, "unexpected size %u\n", size);
    }
    }
}

◆ check_notification()

static void CALLBACK check_notification	(	HINTERNET	handle,
		DWORD_PTR	context,
		DWORD	status,
		LPVOID	buffer,
		DWORD	buflen
	)

static

Definition at line 7388 of file http.c.

{
    BOOL status_ok, function_ok;
    struct info *info = (struct info *)context;
    unsigned int i;
 
    EnterCriticalSection( &notification_cs );
 
    if(info->is_aborted) {
        LeaveCriticalSection(&notification_cs);
        return;
    }
 
    if (status == INTERNET_STATUS_HANDLE_CREATED)
    {
        DWORD size = sizeof(struct info *);
        HttpQueryInfoA( handle, INTERNET_OPTION_CONTEXT_VALUE, &info, &size, 0 );
    }else if(status == INTERNET_STATUS_REQUEST_COMPLETE) {
        INTERNET_ASYNC_RESULT *ar = (INTERNET_ASYNC_RESULT*)buffer;
 
        ok(buflen == sizeof(*ar), "unexpected buflen = %d\n", buflen);
        if(info->expect_result == ERROR_SUCCESS) {
            ok(ar->dwResult == 1, "ar->dwResult = %ld, expected 1\n", ar->dwResult);
        }else {
            ok(!ar->dwResult, "ar->dwResult = %ld, expected 1\n", ar->dwResult);
            ok(ar->dwError == info->expect_result, "ar->dwError = %d, expected %d\n", ar->dwError, info->expect_result);
        }
    }
 
    i = info->index;
    if (i >= info->count)
    {
        LeaveCriticalSection( &notification_cs );
        return;
    }
 
    while (info->test[i].status != status &&
        (info->test[i].optional || info->test[i].todo) &&
        i < info->count - 1 &&
        info->test[i].function == info->test[i + 1].function)
    {
        i++;
    }
 
    status_ok   = (info->test[i].status == status);
    function_ok = (info->test[i].function == info->function);
 
    if (!info->test[i].todo)
    {
        ok( status_ok, "%u: expected status %u got %u\n", info->line, info->test[i].status, status );
        ok( function_ok, "%u: expected function %u got %u\n", info->line, info->test[i].function, info->function );
 
        if (info->test[i].async)
            ok(info->thread != GetCurrentThreadId(), "%u: expected thread %u got %u\n",
               info->line, info->thread, GetCurrentThreadId());
    }
    else
    {
        todo_wine ok( status_ok, "%u: expected status %u got %u\n", info->line, info->test[i].status, status );
        if (status_ok)
            todo_wine ok( function_ok, "%u: expected function %u got %u\n", info->line, info->test[i].function, info->function );
    }
    if (i == info->count - 1 || info->test[i].function != info->test[i + 1].function) SetEvent( info->wait );
    info->index = i+1;
 
    LeaveCriticalSection( &notification_cs );
}

Referenced by test_async_HttpSendRequestEx().

◆ close_async_handle()

static void close_async_handle	(	HINTERNET	handle,
		int	handle_cnt
	)

static

Definition at line 572 of file http.c.

{
    BOOL res;
 
    close_handle_cnt = handle_cnt;
 
    SET_EXPECT2(INTERNET_STATUS_HANDLE_CLOSING, handle_cnt);
    res = InternetCloseHandle(handle);
    ok(res, "InternetCloseHandle failed: %u\n", GetLastError());
    WaitForSingleObject(complete_event, INFINITE);
    CHECK_NOTIFIED2(INTERNET_STATUS_HANDLE_CLOSING, handle_cnt);
}

Referenced by InternetReadFile_test(), InternetReadFileExA_test(), test_async_read(), test_cache_read(), test_conn_close(), test_connection_break(), test_connection_closing(), test_http_read(), test_large_content(), test_no_content(), test_persistent_connection(), test_redirect(), test_security_flags(), and test_successive_HttpSendRequest().

◆ close_connection()

static void close_connection ( void )

static

Definition at line 5576 of file http.c.

{
    char c;
    SetEvent(conn_wait_event);
    recv(server_socket, &c, 1, 0);
}

Referenced by _send_response_and_wait(), _send_response_ex_and_wait(), finished_reading(), release_object(), send_response_len_and_wait(), test_connection_break(), test_large_content(), test_persistent_connection(), and test_redirect().

◆ closetest_callback()

static void WINAPI closetest_callback	(	HINTERNET	hInternet,
		DWORD_PTR	dwContext,
		DWORD	dwInternetStatus,
		LPVOID	lpvStatusInformation,
		DWORD	dwStatusInformationLength
	)

static

Definition at line 7705 of file http.c.

{
    DWORD len, type;
    BOOL res;
 
    if(winetest_debug > 1)
        trace("closetest_callback %p: %d\n", hInternet, dwInternetStatus);
 
    ok(hInternet == closetest_session || hInternet == closetest_conn || hInternet == closetest_req,
       "Unexpected hInternet %p\n", hInternet);
    if(!closetest_closed)
        return;
 
    len = sizeof(type);
    res = InternetQueryOptionA(closetest_req, INTERNET_OPTION_HANDLE_TYPE, &type, &len);
    ok(!res && GetLastError() == ERROR_INVALID_HANDLE,
       "InternetQueryOptionA(%p INTERNET_OPTION_HANDLE_TYPE) failed: %x %u, expected TRUE ERROR_INVALID_HANDLE\n",
       closetest_req, res, GetLastError());
}

Referenced by test_InternetCloseHandle().

◆ free_events()

static void free_events ( void )

static

Definition at line 229 of file http.c.

{
    CloseHandle(complete_event);
    CloseHandle(conn_close_event);
    CloseHandle(conn_wait_event);
    CloseHandle(server_req_rec_event);
    CloseHandle(request_sent_event);
}

Referenced by START_TEST().

◆ header_cb()

static void WINAPI header_cb	(	HINTERNET	handle,
		DWORD_PTR	ctx,
		DWORD	status,
		LPVOID	info,
		DWORD	len
	)

static

Definition at line 7906 of file http.c.

{
    BOOL ret;
    DWORD index, size;
    char buf[256];
 
    if (status == INTERNET_STATUS_SENDING_REQUEST)
    {
        ret = HttpAddRequestHeadersA( handle, "winetest: winetest", ~0u, HTTP_ADDREQ_FLAG_ADD );
        ok( ret, "HttpAddRequestHeadersA failed %u\n", GetLastError() );
        SetEvent( (HANDLE)ctx );
    }
    else if (status == INTERNET_STATUS_REQUEST_SENT)
    {
        index = 0;
        size = sizeof(buf);
        ret = HttpQueryInfoA( handle, HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                              buf, &size, &index );
        ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() );
        ok( strstr( buf, "winetest: winetest" ) != NULL, "header missing\n" );
        SetEvent( (HANDLE)ctx );
    }
}

Referenced by test_concurrent_header_access().

◆ HttpHeaders_test()

static void HttpHeaders_test ( void )

static

Definition at line 1766 of file http.c.

{
    HINTERNET hSession;
    HINTERNET hConnect;
    HINTERNET hRequest;
    CHAR      buffer[256];
    WCHAR     wbuffer[256];
    DWORD     len = 256;
    DWORD     oldlen;
    DWORD     index = 0;
    BOOL      ret;
 
    hSession = InternetOpenA("Wine Regression Test",
            INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0);
    ok( hSession != NULL ,"Unable to open Internet session\n");
    hConnect = InternetConnectA(hSession, "test.winehq.org",
            INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0,
            0);
    ok( hConnect != NULL, "Unable to connect to http://test.winehq.org\n");
    hRequest = HttpOpenRequestA(hConnect, "POST", "/tests/post.php",
            NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0);
    if (!hRequest && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
    {
        skip( "Network unreachable, skipping test\n" );
        goto done;
    }
    ok( hRequest != NULL, "Failed to open request handle\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
               buffer,&len,&index)==0,"Warning hearder reported as Existing\n");
 
    ok(HttpAddRequestHeadersA(hRequest,"Warning:test1",-1,HTTP_ADDREQ_FLAG_ADD),
            "Failed to add new header\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"test1")==0, "incorrect string was returned(%s)\n",buffer);
    ok(len == 5, "Invalid length (exp. 5, got %d)\n", len);
    ok((len < sizeof(buffer)) && (buffer[len] == 0), "Buffer not NULL-terminated\n"); /* len show only 5 characters but the buffer is NULL-terminated*/
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index)==0,"Second Index Should Not Exist\n");
 
    index = 0;
    len = 5; /* could store the string but not the NULL terminator */
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index) == FALSE,"Query succeeded on a too small buffer\n");
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
    ok(index == 0, "Index was incremented\n");
    ok(strcmp(buffer,"Warning")==0, "incorrect string was returned(%s)\n",buffer); /* string not touched */
    ok(len == 6, "Invalid length (exp. 6, got %d)\n", len); /* unlike success, the length includes the NULL-terminator */
 
    /* a call with NULL will fail but will return the length */
    index = 0;
    len = sizeof(buffer);
    SetLastError(0xdeadbeef);
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                NULL,&len,&index) == FALSE,"Query worked\n");
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
    ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len);
    ok(index == 0, "Index was incremented\n");
 
    /* even for a len that is too small */
    index = 0;
    len = 15;
    SetLastError(0xdeadbeef);
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                NULL,&len,&index) == FALSE,"Query worked\n");
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
    ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len);
    ok(index == 0, "Index was incremented\n");
 
    index = 0;
    len = 0;
    SetLastError(0xdeadbeef);
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                NULL,&len,&index) == FALSE,"Query worked\n");
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
    ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len);
    ok(index == 0, "Index was incremented\n");
    oldlen = len;   /* bytes; at least long enough to hold buffer & nul */
 
 
    /* a working query */
    index = 0;
    len = sizeof(buffer);
    memset(buffer, 'x', sizeof(buffer));
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Unable to query header\n");
    ok(len + sizeof(CHAR) <= oldlen, "Result longer than advertised\n");
    ok((len < sizeof(buffer)-sizeof(CHAR)) && (buffer[len/sizeof(CHAR)] == 0),"No NUL at end\n");
    ok(len == strlen(buffer) * sizeof(CHAR), "Length wrong\n");
    /* what's in the middle differs between Wine and Windows so currently we check only the beginning and the end */
    ok(strncmp(buffer, "POST /tests/post.php HTTP/1", 25)==0, "Invalid beginning of headers string\n");
    ok(strcmp(buffer + strlen(buffer) - 4, "\r\n\r\n")==0, "Invalid end of headers string\n");
    ok(index == 0, "Index was incremented\n");
 
    /* Like above two tests, but for W version */
 
    index = 0;
    len = 0;
    SetLastError(0xdeadbeef);
    ok(HttpQueryInfoW(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                NULL,&len,&index) == FALSE,"Query worked\n");
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
    ok(len > 80, "Invalid length (exp. more than 80, got %d)\n", len);
    ok(index == 0, "Index was incremented\n");
    oldlen = len;   /* bytes; at least long enough to hold buffer & nul */
 
    /* a working query */
    index = 0;
    len = sizeof(wbuffer);
    memset(wbuffer, 'x', sizeof(wbuffer));
    ok(HttpQueryInfoW(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                wbuffer,&len,&index),"Unable to query header\n");
    ok(len + sizeof(WCHAR) <= oldlen, "Result longer than advertised\n");
    ok(len == lstrlenW(wbuffer) * sizeof(WCHAR), "Length wrong\n");
    ok((len < sizeof(wbuffer)-sizeof(WCHAR)) && (wbuffer[len/sizeof(WCHAR)] == 0),"No NUL at end\n");
    ok(index == 0, "Index was incremented\n");
 
    /* end of W version tests */
 
    /* Without HTTP_QUERY_FLAG_REQUEST_HEADERS */
    index = 0;
    len = sizeof(buffer);
    memset(buffer, 'x', sizeof(buffer));
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF,
                buffer,&len,&index) == TRUE,"Query failed\n");
    ok(len == 2 || len == 4 /* win10 */, "Expected 2 or 4, got %d\n", len);
    ok(memcmp(buffer, "\r\n\r\n", len) == 0, "Expected CRLF, got '%s'\n", buffer);
    ok(index == 0, "Index was incremented\n");
 
    ok(HttpAddRequestHeadersA(hRequest,"Warning:test2",-1,HTTP_ADDREQ_FLAG_ADD),
            "Failed to add duplicate header using HTTP_ADDREQ_FLAG_ADD\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"test1")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Failed to get second header\n");
    ok(index == 2, "Index was not incremented\n");
    ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index)==0,"Third Header Should Not Exist\n");
 
    ok(HttpAddRequestHeadersA(hRequest,"Warning:test3",-1,HTTP_ADDREQ_FLAG_REPLACE), "Failed to replace header using HTTP_ADDREQ_FLAG_REPLACE\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Failed to get second header\n");
    ok(index == 2, "Index was not incremented\n");
    ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index)==0,"Third Header Should Not Exist\n");
 
    ok(HttpAddRequestHeadersA(hRequest,"Warning:test4",-1,HTTP_ADDREQ_FLAG_ADD_IF_NEW)==0, "HTTP_ADDREQ_FLAG_ADD_IF_NEW replaced existing header\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Failed to get second header\n");
    ok(index == 2, "Index was not incremented\n");
    ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index)==0,"Third Header Should Not Exist\n");
 
    ok(HttpAddRequestHeadersA(hRequest,"Warning:test4",-1, HTTP_ADDREQ_FLAG_COALESCE), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
                buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"test2, test4")==0, "incorrect string was returned(%s)\n", buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n");
    ok(index == 2, "Index was not incremented\n");
    ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n");
 
    ok(HttpAddRequestHeadersA(hRequest,"Warning:test5",-1, HTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"test2, test4, test5")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n");
    ok(index == 2, "Index was not incremented\n");
    ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n");
 
    ok(HttpAddRequestHeadersA(hRequest,"Warning:test6",-1, HTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"test2, test4, test5; test6")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n");
    ok(index == 2, "Index was not incremented\n");
    ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n");
 
    ok(HttpAddRequestHeadersA(hRequest,"Warning:test7",-1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE), "HTTP_ADDREQ_FLAG_ADD with HTTP_ADDREQ_FLAG_REPALCE Did not work\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n");
    ok(index == 2, "Index was not incremented\n");
    ok(strcmp(buffer,"test7")==0, "incorrect string was returned(%s)\n",buffer);
    len = sizeof(buffer);
    strcpy(buffer,"Warning");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n");
 
    /* Ensure that blank headers are ignored and don't cause a failure */
    ok(HttpAddRequestHeadersA(hRequest,"\r\nBlankTest:value\r\n\r\n",-1, HTTP_ADDREQ_FLAG_ADD_IF_NEW), "Failed to add header with blank entries in list\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"BlankTest");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"value")==0, "incorrect string was returned(%s)\n",buffer);
 
    /* Ensure that malformed header separators are ignored and don't cause a failure */
    ok(HttpAddRequestHeadersA(hRequest,"\r\rMalformedTest:value\n\nMalformedTestTwo: value2\rMalformedTestThree: value3\n\n\r\r\n",-1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE),
        "Failed to add header with malformed entries in list\n");
 
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"MalformedTest");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"value")==0, "incorrect string was returned(%s)\n",buffer);
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"MalformedTestTwo");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"value2")==0, "incorrect string was returned(%s)\n",buffer);
    index = 0;
    len = sizeof(buffer);
    strcpy(buffer,"MalformedTestThree");
    ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
    ok(index == 1, "Index was not incremented\n");
    ok(strcmp(buffer,"value3")==0, "incorrect string was returned(%s)\n",buffer);
 
    ret = HttpAddRequestHeadersA(hRequest, "Authorization: Basic\r\n", -1, HTTP_ADDREQ_FLAG_ADD);
    ok(ret, "unable to add header %u\n", GetLastError());
 
    index = 0;
    buffer[0] = 0;
    len = sizeof(buffer);
    ret = HttpQueryInfoA(hRequest, HTTP_QUERY_AUTHORIZATION|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &len, &index);
    ok(ret, "unable to query header %u\n", GetLastError());
    ok(index == 1, "index was not incremented\n");
    ok(!strcmp(buffer, "Basic"), "incorrect string was returned (%s)\n", buffer);
 
    ret = HttpAddRequestHeadersA(hRequest, "Authorization:\r\n", -1, HTTP_ADDREQ_FLAG_REPLACE);
    ok(ret, "unable to remove header %u\n", GetLastError());
 
    index = 0;
    len = sizeof(buffer);
    SetLastError(0xdeadbeef);
    ok(!HttpQueryInfoA(hRequest, HTTP_QUERY_AUTHORIZATION|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &len, &index),
       "header still present\n");
    ok(GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "got %u\n", GetLastError());
 
    ok(InternetCloseHandle(hRequest), "Close request handle failed\n");
done:
    ok(InternetCloseHandle(hConnect), "Close connect handle failed\n");
    ok(InternetCloseHandle(hSession), "Close session handle failed\n");
}

Referenced by START_TEST().

◆ HttpSendRequestEx_test()

static void HttpSendRequestEx_test ( void )

static

Definition at line 1353 of file http.c.

{
    HINTERNET hSession;
    HINTERNET hConnect;
    HINTERNET hRequest;
 
    INTERNET_BUFFERSA BufferIn;
    DWORD dwBytesWritten, dwBytesRead, error;
    CHAR szBuffer[256];
    int i;
    BOOL ret;
 
    static char szPostData[] = "mode=Test";
    static const char szContentType[] = "Content-Type: application/x-www-form-urlencoded";
 
    hSession = InternetOpenA("Wine Regression Test",
            INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0);
    ok( hSession != NULL ,"Unable to open Internet session\n");
    hConnect = InternetConnectA(hSession, "test.winehq.org",
            INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0,
            0);
    ok( hConnect != NULL, "Unable to connect to http://test.winehq.org\n");
    hRequest = HttpOpenRequestA(hConnect, "POST", "/tests/post.php",
            NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0);
    if (!hRequest && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
    {
        skip( "Network unreachable, skipping test\n" );
        goto done;
    }
    ok( hRequest != NULL, "Failed to open request handle err %u\n", GetLastError());
 
    test_request_flags(hRequest, INTERNET_REQFLAG_NO_HEADERS);
 
    BufferIn.dwStructSize = sizeof(BufferIn);
    BufferIn.Next = (INTERNET_BUFFERSA*)0xdeadcab;
    BufferIn.lpcszHeader = szContentType;
    BufferIn.dwHeadersLength = sizeof(szContentType)-1;
    BufferIn.dwHeadersTotal = sizeof(szContentType)-1;
    BufferIn.lpvBuffer = szPostData;
    BufferIn.dwBufferLength = 3;
    BufferIn.dwBufferTotal = sizeof(szPostData)-1;
    BufferIn.dwOffsetLow = 0;
    BufferIn.dwOffsetHigh = 0;
 
    SetLastError(0xdeadbeef);
    ret = HttpSendRequestExA(hRequest, &BufferIn, NULL, 0 ,0);
    error = GetLastError();
    ok(ret, "HttpSendRequestEx Failed with error %u\n", error);
    ok(error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", error);
 
    test_request_flags(hRequest, INTERNET_REQFLAG_NO_HEADERS);
 
    for (i = 3; szPostData[i]; i++)
        ok(InternetWriteFile(hRequest, &szPostData[i], 1, &dwBytesWritten),
                "InternetWriteFile failed\n");
 
    test_request_flags(hRequest, INTERNET_REQFLAG_NO_HEADERS);
 
    ok(HttpEndRequestA(hRequest, NULL, 0, 0), "HttpEndRequest Failed\n");
 
    test_request_flags(hRequest, 0);
 
    ok(InternetReadFile(hRequest, szBuffer, 255, &dwBytesRead),
            "Unable to read response\n");
    szBuffer[dwBytesRead] = 0;
 
    ok(dwBytesRead == 13,"Read %u bytes instead of 13\n",dwBytesRead);
    ok(strncmp(szBuffer,"mode => Test\n",dwBytesRead)==0 || broken(proxy_active()),"Got string %s\n",szBuffer);
 
    ok(InternetCloseHandle(hRequest), "Close request handle failed\n");
done:
    ok(InternetCloseHandle(hConnect), "Close connect handle failed\n");
    ok(InternetCloseHandle(hSession), "Close session handle failed\n");
}

Referenced by START_TEST().

◆ init_events()

static void init_events ( void )

static

Definition at line 220 of file http.c.

{
    complete_event = CreateEventW(NULL, FALSE, FALSE, NULL);
    conn_close_event = CreateEventW(NULL, FALSE, FALSE, NULL);
    conn_wait_event = CreateEventW(NULL, FALSE, FALSE, NULL);
    server_req_rec_event = CreateEventW(NULL, FALSE, FALSE, NULL);
    request_sent_event = CreateEventW(NULL, FALSE, FALSE, NULL);
}

Referenced by START_TEST().

◆ init_status_tests()

static void init_status_tests ( void )

static

Definition at line 7868 of file http.c.

{
    memset(expect, 0, sizeof(expect));
    memset(optional, 0, sizeof(optional));
    memset(wine_allow, 0, sizeof(wine_allow));
    memset(notified, 0, sizeof(notified));
    memset(status_string, 0, sizeof(status_string));
 
#define STATUS_STRING(status) status_string[status] = #status
    STATUS_STRING(INTERNET_STATUS_RESOLVING_NAME);
    STATUS_STRING(INTERNET_STATUS_NAME_RESOLVED);
    STATUS_STRING(INTERNET_STATUS_CONNECTING_TO_SERVER);
    STATUS_STRING(INTERNET_STATUS_CONNECTED_TO_SERVER);
    STATUS_STRING(INTERNET_STATUS_SENDING_REQUEST);
    STATUS_STRING(INTERNET_STATUS_REQUEST_SENT);
    STATUS_STRING(INTERNET_STATUS_RECEIVING_RESPONSE);
    STATUS_STRING(INTERNET_STATUS_RESPONSE_RECEIVED);
    STATUS_STRING(INTERNET_STATUS_CTL_RESPONSE_RECEIVED);
    STATUS_STRING(INTERNET_STATUS_PREFETCH);
    STATUS_STRING(INTERNET_STATUS_CLOSING_CONNECTION);
    STATUS_STRING(INTERNET_STATUS_CONNECTION_CLOSED);
    STATUS_STRING(INTERNET_STATUS_HANDLE_CREATED);
    STATUS_STRING(INTERNET_STATUS_HANDLE_CLOSING);
    STATUS_STRING(INTERNET_STATUS_DETECTING_PROXY);
    STATUS_STRING(INTERNET_STATUS_REQUEST_COMPLETE);
    STATUS_STRING(INTERNET_STATUS_REDIRECT);
    STATUS_STRING(INTERNET_STATUS_INTERMEDIATE_RESPONSE);
    STATUS_STRING(INTERNET_STATUS_USER_INPUT_REQUIRED);
    STATUS_STRING(INTERNET_STATUS_STATE_CHANGE);
    STATUS_STRING(INTERNET_STATUS_COOKIE_SENT);
    STATUS_STRING(INTERNET_STATUS_COOKIE_RECEIVED);
    STATUS_STRING(INTERNET_STATUS_PRIVACY_IMPACTED);
    STATUS_STRING(INTERNET_STATUS_P3P_HEADER);
    STATUS_STRING(INTERNET_STATUS_P3P_POLICYREF);
    STATUS_STRING(INTERNET_STATUS_COOKIE_HISTORY);
#undef STATUS_STRING
}

Referenced by START_TEST().

◆ INTERNET_STATUS_CALLBACK()

static INTERNET_STATUS_CALLBACK ( WINAPI * pInternetSetStatusCallbackA )

static

◆ InternetLockRequestFile_test()

static void InternetLockRequestFile_test ( void )

static

Definition at line 1713 of file http.c.

{
    char file_name[MAX_PATH];
    test_request_t req;
    HANDLE lock, lock2;
    DWORD size;
    BOOL ret;
 
    open_simple_request(&req, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, "/tests/hello.html");
 
    size = sizeof(file_name);
    ret = InternetQueryOptionA(req.request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size);
    ok(!ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) succeeded\n");
    ok(GetLastError() == ERROR_INTERNET_ITEM_NOT_FOUND, "GetLastError()=%u\n", GetLastError());
    ok(!size, "size = %d\n", size);
 
    lock = NULL;
    ret = InternetLockRequestFile(req.request, &lock);
    ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "InternetLockRequestFile returned: %x(%u)\n", ret, GetLastError());
 
    ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0);
    ok(ret, "HttpSendRequest failed: %u\n", GetLastError());
 
    size = sizeof(file_name);
    ret = InternetQueryOptionA(req.request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size);
    ok(ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) failed: %u\n", GetLastError());
 
    ret = InternetLockRequestFile(req.request, &lock);
    ok(ret, "InternetLockRequestFile returned: %x(%u)\n", ret, GetLastError());
    ok(lock != NULL, "lock == NULL\n");
 
    ret = InternetLockRequestFile(req.request, &lock2);
    ok(ret, "InternetLockRequestFile returned: %x(%u)\n", ret, GetLastError());
    ok(lock == lock2, "lock != lock2\n");
 
    ret = InternetUnlockRequestFile(lock2);
    ok(ret, "InternetUnlockRequestFile failed: %u\n", GetLastError());
 
    ret = DeleteFileA(file_name);
    ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION, "Deleting file returned %x(%u)\n", ret, GetLastError());
 
    ok(InternetCloseHandle(req.request), "Close request handle failed\n");
 
    ret = DeleteFileA(file_name);
    ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION, "Deleting file returned %x(%u)\n", ret, GetLastError());
 
    ret = InternetUnlockRequestFile(lock);
    ok(ret, "InternetUnlockRequestFile failed: %u\n", GetLastError());
 
    ret = DeleteFileA(file_name);
    ok(ret, "Deleting file returned %x(%u)\n", ret, GetLastError());
}

Referenced by START_TEST().

◆ InternetOpenRequest_test()

static void InternetOpenRequest_test ( void )

static

Definition at line 1428 of file http.c.

{
    HINTERNET session, connect, request;
    static const char *types[] = { "*", "", NULL };
    static const WCHAR slash[] = {'/', 0}, any[] = {'*', 0}, empty[] = {0};
    static const WCHAR *typesW[] = { any, empty, NULL };
    BOOL ret;
 
    session = InternetOpenA("Wine Regression Test", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
    ok(session != NULL ,"Unable to open Internet session\n");
 
    connect = InternetConnectA(session, NULL, INTERNET_DEFAULT_HTTP_PORT, NULL, NULL,
                              INTERNET_SERVICE_HTTP, 0, 0);
    ok(connect == NULL, "InternetConnectA should have failed\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "InternetConnectA with NULL server named should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
 
    connect = InternetConnectA(session, "", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL,
                              INTERNET_SERVICE_HTTP, 0, 0);
    ok(connect == NULL, "InternetConnectA should have failed\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "InternetConnectA with blank server named should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
 
    connect = InternetConnectA(session, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL,
                              INTERNET_SERVICE_HTTP, 0, 0);
    ok(connect != NULL, "Unable to connect to http://test.winehq.org with error %d\n", GetLastError());
 
    request = HttpOpenRequestA(connect, NULL, "/", NULL, NULL, types, INTERNET_FLAG_NO_CACHE_WRITE, 0);
    if (!request && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
    {
        skip( "Network unreachable, skipping test\n" );
        goto done;
    }
    ok(request != NULL, "Failed to open request handle err %u\n", GetLastError());
 
    ret = HttpSendRequestW(request, NULL, 0, NULL, 0);
    ok(ret, "HttpSendRequest failed: %u\n", GetLastError());
    ok(InternetCloseHandle(request), "Close request handle failed\n");
 
    request = HttpOpenRequestW(connect, NULL, slash, NULL, NULL, typesW, INTERNET_FLAG_NO_CACHE_WRITE, 0);
    ok(request != NULL, "Failed to open request handle err %u\n", GetLastError());
 
    ret = HttpSendRequestA(request, NULL, 0, NULL, 0);
    ok(ret, "HttpSendRequest failed: %u\n", GetLastError());
    ok(InternetCloseHandle(request), "Close request handle failed\n");
 
done:
    ok(InternetCloseHandle(connect), "Close connect handle failed\n");
    ok(InternetCloseHandle(session), "Close session handle failed\n");
}

Referenced by START_TEST().

◆ InternetOpenUrlA_test()

static void InternetOpenUrlA_test ( void )

static

Definition at line 1316 of file http.c.

{
  HINTERNET myhinternet, myhttp;
  char buffer[0x400];
  DWORD size, readbytes, totalbytes=0;
  BOOL ret;
 
  ret = DeleteUrlCacheEntryA(TEST_URL);
  ok(ret || GetLastError() == ERROR_FILE_NOT_FOUND,
          "DeleteUrlCacheEntry returned %x, GetLastError() = %d\n", ret, GetLastError());
 
  myhinternet = InternetOpenA("Winetest",0,NULL,NULL,INTERNET_FLAG_NO_CACHE_WRITE);
  ok((myhinternet != 0), "InternetOpen failed, error %u\n",GetLastError());
  size = 0x400;
  ret = InternetCanonicalizeUrlA(TEST_URL, buffer, &size,ICU_BROWSER_MODE);
  ok( ret, "InternetCanonicalizeUrl failed, error %u\n",GetLastError());
 
  SetLastError(0);
  myhttp = InternetOpenUrlA(myhinternet, TEST_URL, 0, 0,
               INTERNET_FLAG_RELOAD|INTERNET_FLAG_NO_CACHE_WRITE|INTERNET_FLAG_TRANSFER_BINARY,0);
  if (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
    return; /* WinXP returns this when not connected to the net */
  ok((myhttp != 0),"InternetOpenUrl failed, error %u\n",GetLastError());
  ret = InternetReadFile(myhttp, buffer,0x400,&readbytes);
  ok( ret, "InternetReadFile failed, error %u\n",GetLastError());
  totalbytes += readbytes;
  while (readbytes && InternetReadFile(myhttp, buffer,0x400,&readbytes))
    totalbytes += readbytes;
  trace("read 0x%08x bytes\n",totalbytes);
 
  InternetCloseHandle(myhttp);
  InternetCloseHandle(myhinternet);
 
  ret = DeleteUrlCacheEntryA(TEST_URL);
  ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "INTERNET_FLAG_NO_CACHE_WRITE flag doesn't work\n");
}

Referenced by START_TEST().

◆ InternetReadFile_chunked_test()

static void InternetReadFile_chunked_test ( void )

static

Definition at line 962 of file http.c.

{
    BOOL res;
    CHAR buffer[4000];
    DWORD length, got;
    const char *types[2] = { "*", NULL };
    HINTERNET hi, hic = 0, hor = 0;
 
    trace("Starting InternetReadFile chunked test\n");
 
    trace("InternetOpenA <--\n");
    hi = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
    ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError());
    trace("InternetOpenA -->\n");
 
    if (hi == 0x0) goto abort;
 
    trace("InternetConnectA <--\n");
    hic=InternetConnectA(hi, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER,
                         NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
    ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError());
    trace("InternetConnectA -->\n");
 
    if (hic == 0x0) goto abort;
 
    trace("HttpOpenRequestA <--\n");
    hor = HttpOpenRequestA(hic, "GET", "/tests/chunked", NULL, NULL, types,
                           INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RELOAD,
                           0xdeadbead);
    if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) {
        /*
         * If the internet name can't be resolved we are probably behind
         * a firewall or in some other way not directly connected to the
         * Internet. Not enough reason to fail the test. Just ignore and
         * abort.
         */
    } else  {
        ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError());
    }
    trace("HttpOpenRequestA -->\n");
 
    if (hor == 0x0) goto abort;
 
    trace("HttpSendRequestA -->\n");
    SetLastError(0xdeadbeef);
    res = HttpSendRequestA(hor, "", -1, NULL, 0);
    ok(res || (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED),
       "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError());
    trace("HttpSendRequestA <--\n");
 
    test_request_flags(hor, 0);
 
    length = 100;
    res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_TYPE,buffer,&length,0x0);
    buffer[length]=0;
    trace("Option CONTENT_TYPE -> %i  %s\n",res,buffer);
 
    SetLastError( 0xdeadbeef );
    length = 100;
    res = HttpQueryInfoA(hor,HTTP_QUERY_TRANSFER_ENCODING,buffer,&length,0x0);
    buffer[length]=0;
    trace("Option TRANSFER_ENCODING -> %i  %s\n",res,buffer);
    ok( res || ( proxy_active() && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND ),
        "Failed to get TRANSFER_ENCODING option, error %u\n", GetLastError() );
    ok( !strcmp( buffer, "chunked" ) || ( ! res && proxy_active() && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND ),
        "Wrong transfer encoding '%s'\n", buffer );
 
    SetLastError( 0xdeadbeef );
    length = 16;
    res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_LENGTH,&buffer,&length,0x0);
    ok( !res, "Found CONTENT_LENGTH option '%s'\n", buffer );
    ok( GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "Wrong error %u\n", GetLastError() );
 
    length = 100;
    trace("Entering Query loop\n");
 
    while (TRUE)
    {
        res = InternetQueryDataAvailable(hor,&length,0x0,0x0);
        ok(!(!res && length != 0),"InternetQueryDataAvailable failed with non-zero length\n");
        ok(res, "InternetQueryDataAvailable failed, error %d\n", GetLastError());
        trace("got %u available\n",length);
        if (length)
        {
            char *buffer = HeapAlloc(GetProcessHeap(),0,length+1);
 
            SetLastError(0xdeadbeef);
            res = InternetReadFile(hor,buffer,length,&got);
            ok(GetLastError() == 0 ||
                broken(GetLastError() == 0xdeadbeef /* XP/W2K3 */), "Last Error not reset %u\n", GetLastError());
 
            buffer[got]=0;
            trace("ReadFile -> %i %i\n",res,got);
            ok( length == got, "only got %u of %u available\n", got, length );
            ok( buffer[got-1] == '\n', "received partial line '%s'\n", buffer );
 
            HeapFree(GetProcessHeap(),0,buffer);
            if (!got) break;
        }
        if (length == 0)
        {
            got = 0xdeadbeef;
            SetLastError(0xdeadbeef);
            res = InternetReadFile( hor, buffer, 1, &got );
            ok( res, "InternetReadFile failed: %u\n", GetLastError() );
            ok(GetLastError() == 0 ||
                broken(GetLastError() == 0xdeadbeef /* XP/W2K3 */), "Last Error not reset %u\n", GetLastError());
            ok( !got, "got %u\n", got );
            break;
        }
    }
abort:
    trace("aborting\n");
    if (hor != 0x0) {
        res = InternetCloseHandle(hor);
        ok (res, "InternetCloseHandle of handle opened by HttpOpenRequestA failed\n");
    }
    if (hi != 0x0) {
        res = InternetCloseHandle(hi);
        ok (res, "InternetCloseHandle of handle opened by InternetOpenA failed\n");
    }
}

Referenced by START_TEST().

◆ InternetReadFile_test()

static void InternetReadFile_test	(	int	flags,
		const test_data_t *	test
	)

static

Definition at line 585 of file http.c.

{
    char *post_data = NULL;
    BOOL res, on_async = TRUE;
    CHAR buffer[4000];
    WCHAR wbuffer[4000];
    DWORD length, length2, index, exlen = 0, post_len = 0;
    const char *types[2] = { "*", NULL };
    HINTERNET hi, hic = 0, hor = 0;
    DWORD contents_length, accepts_ranges;
    BOOL not_supported;
 
    trace("Starting InternetReadFile test with flags 0x%x on url %s\n",flags,test->url);
    reset_events();
 
    trace("InternetOpenA <--\n");
    hi = InternetOpenA((test->flags & TESTF_COMPRESSED) ? "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)" : "",
            INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, flags);
    ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError());
    trace("InternetOpenA -->\n");
 
    if (hi == 0x0) goto abort;
 
    pInternetSetStatusCallbackA(hi,&callback);
 
    SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
 
    trace("InternetConnectA <--\n");
    hic=InternetConnectA(hi, test->host, INTERNET_INVALID_PORT_NUMBER,
                         NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
    ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError());
    trace("InternetConnectA -->\n");
 
    if (hic == 0x0) goto abort;
 
    CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
    SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
 
    trace("HttpOpenRequestA <--\n");
    hor = HttpOpenRequestA(hic, test->post_data ? "POST" : "GET", test->path, NULL, NULL, types,
                           INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RELOAD,
                           0xdeadbead);
    if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) {
        /*
         * If the internet name can't be resolved we are probably behind
         * a firewall or in some other way not directly connected to the
         * Internet. Not enough reason to fail the test. Just ignore and
         * abort.
         */
    } else  {
        ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError());
    }
    trace("HttpOpenRequestA -->\n");
 
    if (hor == 0x0) goto abort;
 
    test_request_flags(hor, INTERNET_REQFLAG_NO_HEADERS);
    test_request_url(hor, test->url);
 
    length = sizeof(buffer);
    res = HttpQueryInfoA(hor, HTTP_QUERY_RAW_HEADERS, buffer, &length, 0x0);
    ok(res, "HttpQueryInfoA(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError());
    ok(length == 0 || (length == 1 && !*buffer) /* win10 */, "HTTP_QUERY_RAW_HEADERS: expected length 0, but got %d\n", length);
    ok(!strcmp(buffer, ""), "HTTP_QUERY_RAW_HEADERS: expected string \"\", but got \"%s\"\n", buffer);
 
    CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
    CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
    CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
    SET_OPTIONAL2(INTERNET_STATUS_COOKIE_SENT,2);
    SET_OPTIONAL2(INTERNET_STATUS_COOKIE_RECEIVED,2);
    if (first_connection_to_test_url)
    {
        SET_EXPECT(INTERNET_STATUS_RESOLVING_NAME);
        SET_EXPECT(INTERNET_STATUS_NAME_RESOLVED);
    }
    SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER);
    SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER);
    SET_EXPECT2(INTERNET_STATUS_SENDING_REQUEST, (test->flags & TESTF_REDIRECT) ? 2 : 1);
    SET_EXPECT2(INTERNET_STATUS_REQUEST_SENT, (test->flags & TESTF_REDIRECT) ? 2 : 1);
    SET_EXPECT2(INTERNET_STATUS_RECEIVING_RESPONSE, (test->flags & TESTF_REDIRECT) ? 2 : 1);
    SET_EXPECT2(INTERNET_STATUS_RESPONSE_RECEIVED, (test->flags & TESTF_REDIRECT) ? 2 : 1);
    if(test->flags & TESTF_REDIRECT) {
        SET_OPTIONAL2(INTERNET_STATUS_CLOSING_CONNECTION, 2);
        SET_OPTIONAL2(INTERNET_STATUS_CONNECTION_CLOSED, 2);
    }
    SET_EXPECT(INTERNET_STATUS_REDIRECT);
    SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER);
    SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER);
    if (flags & INTERNET_FLAG_ASYNC)
        SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
 
    if(test->flags & TESTF_COMPRESSED) {
        BOOL b = TRUE;
 
        res = InternetSetOptionA(hor, INTERNET_OPTION_HTTP_DECODING, &b, sizeof(b));
        ok(res || broken(!res && GetLastError() == ERROR_INTERNET_INVALID_OPTION),
           "InternetSetOption failed: %u\n", GetLastError());
        if(!res)
            goto abort;
    }
 
    test_status_code(hor, 0);
 
    trace("HttpSendRequestA -->\n");
    if(test->post_data) {
        post_len = strlen(test->post_data);
        post_data = HeapAlloc(GetProcessHeap(), 0, post_len);
        memcpy(post_data, test->post_data, post_len);
    }
    SetLastError(0xdeadbeef);
    res = HttpSendRequestA(hor, test->headers, -1, post_data, post_len);
    if (flags & INTERNET_FLAG_ASYNC)
        ok(!res && (GetLastError() == ERROR_IO_PENDING),
            "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n");
    else
        ok(res || (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED),
           "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError());
    trace("HttpSendRequestA <--\n");
 
    if (flags & INTERNET_FLAG_ASYNC) {
        WaitForSingleObject(complete_event, INFINITE);
        ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error);
    }
    HeapFree(GetProcessHeap(), 0, post_data);
 
    CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT);
    CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_RECEIVED);
    if (first_connection_to_test_url)
    {
        if (! proxy_active())
        {
            CHECK_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
            CHECK_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
        }
        else
        {
            CLEAR_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
            CLEAR_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
        }
    }
    else
    {
        CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
        CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
    }
    CHECK_NOTIFIED2(INTERNET_STATUS_SENDING_REQUEST, (test->flags & TESTF_REDIRECT) ? 2 : 1);
    CHECK_NOTIFIED2(INTERNET_STATUS_REQUEST_SENT, (test->flags & TESTF_REDIRECT) ? 2 : 1);
    CHECK_NOTIFIED2(INTERNET_STATUS_RECEIVING_RESPONSE, (test->flags & TESTF_REDIRECT) ? 2 : 1);
    CHECK_NOTIFIED2(INTERNET_STATUS_RESPONSE_RECEIVED, (test->flags & TESTF_REDIRECT) ? 2 : 1);
    if(test->flags & TESTF_REDIRECT)
        CHECK_NOTIFIED(INTERNET_STATUS_REDIRECT);
    if (flags & INTERNET_FLAG_ASYNC)
        CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
    /* Sent on WinXP only if first_connection_to_test_url is TRUE, on Win98 always sent */
    CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER);
    CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER);
 
    test_request_flags(hor, 0);
 
    length = 100;
    res = InternetQueryOptionA(hor,INTERNET_OPTION_URL,buffer,&length);
    ok(res, "InternetQueryOptionA(INTERNET_OPTION_URL) failed with error %d\n", GetLastError());
 
    length = sizeof(buffer)-2;
    memset(buffer, 0x77, sizeof(buffer));
    SetLastError(0xdeadbeef);
    res = HttpQueryInfoA(hor,HTTP_QUERY_RAW_HEADERS,buffer,&length,0x0);
    ok(res, "HttpQueryInfoA(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError());
    ok(GetLastError() == 0 ||
                broken(GetLastError() == 0xdeadbeef /* XP/W2K3 */), "Last Error not reset %u\n", GetLastError());
    /* show that the function writes data past the length returned */
    ok(buffer[length-2], "Expected any header character, got 0x00\n");
    ok(!buffer[length-1], "Expected 0x00, got %02X\n", buffer[length-1]);
    ok(!buffer[length], "Expected 0x00, got %02X\n", buffer[length]);
    ok(buffer[length+1] == 0x77, "Expected 0x77, got %02X\n", buffer[length+1]);
 
    length2 = length;
    res = HttpQueryInfoA(hor,HTTP_QUERY_RAW_HEADERS,buffer,&length2,0x0);
    ok(!res, "Expected 0x00, got %d\n", res);
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
    ok(length2 == length+1, "Expected %d, got %d\n", length+1, length2);
    /* the in length of the buffer must be +1 but the length returned does not count this */
    length2 = length+1;
    memset(buffer, 0x77, sizeof(buffer));
    res = HttpQueryInfoA(hor,HTTP_QUERY_RAW_HEADERS,buffer,&length2,0x0);
    ok(res, "HttpQueryInfoA(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError());
    ok(buffer[length2] == 0x00, "Expected 0x00, got %02X\n", buffer[length2]);
    ok(buffer[length2+1] == 0x77, "Expected 0x77, got %02X\n", buffer[length2+1]);
    ok(length2 == length, "Value should not have changed: %d != %d\n", length2, length);
 
    length = sizeof(wbuffer)-2*sizeof(WCHAR);
    memset(wbuffer, 0x77, sizeof(wbuffer));
    res = HttpQueryInfoW(hor, HTTP_QUERY_RAW_HEADERS, wbuffer, &length, 0x0);
    ok(res, "HttpQueryInfoW(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError());
    ok(length % sizeof(WCHAR) == 0, "Expected that length is a multiple of sizeof(WCHAR), got %d.\n", length);
    length /= sizeof(WCHAR);
    /* show that the function writes data past the length returned */
    ok(wbuffer[length-2], "Expected any header character, got 0x0000\n");
    ok(!wbuffer[length-1], "Expected 0x0000, got %04X\n", wbuffer[length-1]);
    ok(!wbuffer[length], "Expected 0x0000, got %04X\n", wbuffer[length]);
    ok(wbuffer[length+1] == 0x7777 || broken(wbuffer[length+1] != 0x7777),
       "Expected 0x7777, got %04X\n", wbuffer[length+1]);
 
    length2 = length*sizeof(WCHAR);
    res = HttpQueryInfoW(hor,HTTP_QUERY_RAW_HEADERS,wbuffer,&length2,0x0);
    ok(!res, "Expected 0x00, got %d\n", res);
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
    ok(length2 % sizeof(WCHAR) == 0, "Expected that length is a multiple of sizeof(WCHAR), got %d.\n", length2);
    length2 /= sizeof(WCHAR);
    ok(length2 == length+1, "Expected %d, got %d\n", length+1, length2);
    /* the in length of the buffer must be +1 but the length returned does not count this */
    length2 = (length+1)*sizeof(WCHAR);
    memset(wbuffer, 0x77, sizeof(wbuffer));
    res = HttpQueryInfoW(hor,HTTP_QUERY_RAW_HEADERS,wbuffer,&length2,0x0);
    ok(res, "HttpQueryInfoW(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError());
    ok(length2 % sizeof(WCHAR) == 0, "Expected that length is a multiple of sizeof(WCHAR), got %d.\n", length2);
    length2 /= sizeof(WCHAR);
    ok(!wbuffer[length2], "Expected 0x0000, got %04X\n", wbuffer[length2]);
    ok(wbuffer[length2+1] == 0x7777, "Expected 0x7777, got %04X\n", wbuffer[length2+1]);
    ok(length2 == length, "Value should not have changed: %d != %d\n", length2, length);
 
    test_request_url(hor, test->redirected_url);
 
    index = 0;
    length = 0;
    SetLastError(0xdeadbeef);
    ok(HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_LENGTH,NULL,&length,&index) == FALSE,"Query worked\n");
    if(test->flags & TESTF_COMPRESSED)
        ok(GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND,
           "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", GetLastError());
    ok(index == 0, "Index was incremented\n");
 
    index = 0;
    length = 16;
    res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_LENGTH,&buffer,&length,&index);
    trace("Option HTTP_QUERY_CONTENT_LENGTH -> %i  %s  (%u)\n",res,buffer,GetLastError());
    if(test->flags & TESTF_COMPRESSED)
    {
        ok(!res && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND,
           "expected ERROR_HTTP_HEADER_NOT_FOUND, got %x (%u)\n", res, GetLastError());
        contents_length = 0;
    }
    else
    {
        contents_length = atoi(buffer);
    }
    ok(!res || index == 1, "Index was not incremented although result is %x (index = %u)\n", res, index);
 
    length = 64;
    *buffer = 0;
    res = HttpQueryInfoA(hor,HTTP_QUERY_ACCEPT_RANGES,&buffer,&length,0x0);
    trace("Option HTTP_QUERY_ACCEPT_RANGES -> %i  %s  (%u)\n",res,buffer,GetLastError());
    accepts_ranges = res && !strcmp(buffer, "bytes");
 
    length = 100;
    res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_TYPE,buffer,&length,0x0);
    buffer[length]=0;
    trace("Option HTTP_QUERY_CONTENT_TYPE -> %i  %s\n",res,buffer);
 
    length = 100;
    res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_ENCODING,buffer,&length,0x0);
    buffer[length]=0;
    trace("Option HTTP_QUERY_CONTENT_ENCODING -> %i  %s\n",res,buffer);
 
    SetLastError(0xdeadbeef);
    length = InternetSetFilePointer(hor, 0, NULL, FILE_END, 0);
    not_supported = length == INVALID_SET_FILE_POINTER
            && GetLastError() == ERROR_INTERNET_INVALID_OPERATION;
    if (accepts_ranges)
        todo_wine ok((length == contents_length && (GetLastError() == ERROR_SUCCESS
                || broken(GetLastError() == 0xdeadbeef))) || broken(not_supported),
                "Got unexpected length %#x, GetLastError() %u, contents_length %u, accepts_ranges %#x.\n",
                length, GetLastError(), contents_length, accepts_ranges);
    else
        ok(not_supported, "Got unexpected length %#x, GetLastError() %u.\n", length, GetLastError());
 
    if (length != INVALID_SET_FILE_POINTER)
    {
        SetLastError(0xdeadbeef);
        length = InternetSetFilePointer(hor, 0, NULL, FILE_BEGIN, 0);
        ok(!length && (GetLastError() == ERROR_SUCCESS || broken(GetLastError() == 0xdeadbeef)),
                "Got unexpected length %#x, GetLastError() %u.\n", length, GetLastError());
    }
 
    SetLastError(0xdeadbeef);
    res = InternetReadFile(NULL, buffer, 100, &length);
    ok(!res, "InternetReadFile should have failed\n");
    ok(GetLastError() == ERROR_INVALID_HANDLE,
        "InternetReadFile should have set last error to ERROR_INVALID_HANDLE instead of %u\n",
        GetLastError());
 
    length = 100;
    if(winetest_debug > 1)
        trace("Entering Query loop\n");
 
    while (TRUE)
    {
        if (flags & INTERNET_FLAG_ASYNC)
            SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
 
        /* IE11 calls those in InternetQueryDataAvailable call. */
        SET_OPTIONAL(INTERNET_STATUS_RECEIVING_RESPONSE);
        SET_OPTIONAL(INTERNET_STATUS_RESPONSE_RECEIVED);
 
        length = 0;
        res = InternetQueryDataAvailable(hor,&length,0x0,0x0);
 
        CLEAR_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
 
        if (flags & INTERNET_FLAG_ASYNC)
        {
            if (res)
            {
                CHECK_NOT_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
                if(exlen) {
                    ok(length >= exlen, "length %u < exlen %u\n", length, exlen);
                    exlen = 0;
                }
            }
            else if (GetLastError() == ERROR_IO_PENDING)
            {
                if(winetest_debug > 1)
                    trace("pending\n");
                /* on some tests, InternetQueryDataAvailable returns non-zero length and ERROR_IO_PENDING */
                if(!(test->flags & TESTF_CHUNKED))
                    ok(!length, "InternetQueryDataAvailable returned ERROR_IO_PENDING and %u length\n", length);
                WaitForSingleObject(complete_event, INFINITE);
                exlen = length;
                ok(exlen, "length = 0\n");
                CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
                CLEAR_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
                ok(req_error, "req_error = 0\n");
                continue;
            }else {
                ok(0, "InternetQueryDataAvailable failed: %u\n", GetLastError());
            }
        }else {
            ok(res, "InternetQueryDataAvailable failed: %u\n", GetLastError());
        }
        CLEAR_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
 
        if(winetest_debug > 1)
            trace("length %u\n", length);
        if(test->flags & TESTF_CHUNKED)
            ok(length <= 8192, "length = %d, expected <= 8192\n", length);
        if (length)
        {
            char *buffer;
            buffer = HeapAlloc(GetProcessHeap(),0,length+1);
 
            res = InternetReadFile(hor,buffer,length,&length);
 
            buffer[length]=0;
 
            if(winetest_debug > 1)
                trace("ReadFile -> %s %i\n", res ? "TRUE" : "FALSE", length);
 
            if(test->content)
                ok(!strcmp(buffer, test->content), "buffer = '%s', expected '%s'\n", buffer, test->content);
            HeapFree(GetProcessHeap(),0,buffer);
        }else {
            ok(!on_async, "Returned zero size in response to request complete\n");
            break;
        }
        on_async = FALSE;
    }
    if(test->flags & TESTF_REDIRECT) {
        CHECK_NOTIFIED2(INTERNET_STATUS_CLOSING_CONNECTION, 2);
        CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTION_CLOSED, 2);
    }
abort:
    if(winetest_debug > 1)
        trace("aborting\n");
    close_async_handle(hi, 2);
    first_connection_to_test_url = FALSE;
}

Referenced by START_TEST().

◆ InternetReadFileExA_test()

static void InternetReadFileExA_test ( int flags )

static

Definition at line 1085 of file http.c.

{
    DWORD rc;
    DWORD length;
    const char *types[2] = { "*", NULL };
    HINTERNET hi, hic = 0, hor = 0;
    INTERNET_BUFFERSA inetbuffers;
 
    trace("Starting InternetReadFileExA test with flags 0x%x\n",flags);
    reset_events();
 
    trace("InternetOpenA <--\n");
    hi = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, flags);
    ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError());
    trace("InternetOpenA -->\n");
 
    if (hi == 0x0) goto abort;
 
    pInternetSetStatusCallbackA(hi,&callback);
 
    SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
 
    trace("InternetConnectA <--\n");
    hic=InternetConnectA(hi, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER,
                         NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
    ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError());
    trace("InternetConnectA -->\n");
 
    if (hic == 0x0) goto abort;
 
    CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
    SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
 
    trace("HttpOpenRequestA <--\n");
    hor = HttpOpenRequestA(hic, "GET", "/tests/redirect", NULL, NULL, types,
                           INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RELOAD,
                           0xdeadbead);
    if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) {
        /*
         * If the internet name can't be resolved we are probably behind
         * a firewall or in some other way not directly connected to the
         * Internet. Not enough reason to fail the test. Just ignore and
         * abort.
         */
    } else  {
        ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError());
    }
    trace("HttpOpenRequestA -->\n");
 
    if (hor == 0x0) goto abort;
 
    CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
    CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
    CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
    if (first_connection_to_test_url)
    {
        SET_EXPECT(INTERNET_STATUS_RESOLVING_NAME);
        SET_EXPECT(INTERNET_STATUS_NAME_RESOLVED);
    }
    SET_OPTIONAL2(INTERNET_STATUS_COOKIE_SENT, 2);
    SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER);
    SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER);
    SET_EXPECT2(INTERNET_STATUS_SENDING_REQUEST, 2);
    SET_EXPECT2(INTERNET_STATUS_REQUEST_SENT, 2);
    SET_EXPECT2(INTERNET_STATUS_RECEIVING_RESPONSE, 2);
    SET_EXPECT2(INTERNET_STATUS_RESPONSE_RECEIVED, 2);
    SET_OPTIONAL2(INTERNET_STATUS_CLOSING_CONNECTION, 2);
    SET_OPTIONAL2(INTERNET_STATUS_CONNECTION_CLOSED, 2);
    SET_EXPECT(INTERNET_STATUS_REDIRECT);
    SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER);
    SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER);
    if (flags & INTERNET_FLAG_ASYNC)
        SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
    else
        SET_WINE_ALLOW(INTERNET_STATUS_REQUEST_COMPLETE);
 
    trace("HttpSendRequestA -->\n");
    SetLastError(0xdeadbeef);
    rc = HttpSendRequestA(hor, "", -1, NULL, 0);
    if (flags & INTERNET_FLAG_ASYNC)
        ok(((rc == 0)&&(GetLastError() == ERROR_IO_PENDING)),
            "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n");
    else
        ok((rc != 0) || GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED,
           "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError());
    trace("HttpSendRequestA <--\n");
 
    if (!rc && (GetLastError() == ERROR_IO_PENDING)) {
        WaitForSingleObject(complete_event, INFINITE);
        ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error);
 

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ _SECURITY_FLAG_CERT_INVALID_CA

◆ _SECURITY_FLAG_CERT_INVALID_CN

◆ _SECURITY_FLAG_CERT_INVALID_DATE

◆ _SECURITY_FLAG_CERT_REV_FAILED

◆ async_query_data_available

◆ CHECK_EXPECT

◆ CHECK_NOT_NOTIFIED

◆ CHECK_NOTIFIED

◆ CHECK_NOTIFIED2

◆ CLEAR_NOTIFIED

◆ close_request

◆ expect_data_available

◆ MAX_INTERNET_STATUS

◆ open_simple_request

◆ read_expect_sync_data

◆ read_expect_sync_data_len

◆ readex_expect_async

◆ readex_expect_sync_data

◆ readex_expect_sync_data_len

◆ receive_simple_request

◆ send_response_and_wait

◆ send_response_ex_and_wait

◆ server_read_request

◆ SET_EXPECT

◆ SET_EXPECT2

◆ SET_OPTIONAL

◆ SET_OPTIONAL2

◆ set_secflags

◆ SET_WINE_ALLOW

◆ SET_WINE_ALLOW2

◆ STATUS_STRING

◆ test_http_version

◆ test_request_flags

◆ test_request_flags_todo

◆ test_request_url

◆ test_secflags_option

◆ test_security_info

◆ test_status_code

◆ test_status_code_todo

◆ TEST_URL

◆ TESTF_CHUNKED

◆ TESTF_COMPRESSED

◆ TESTF_REDIRECT

Enumeration Type Documentation

◆ api

Function Documentation

◆ _async_query_data_available()

◆ _close_request()

◆ _expect_data_available()

◆ _open_simple_request()

◆ _read_expect_sync_data()

◆ _read_expect_sync_data_len()

◆ _readex_expect_async()

◆ _readex_expect_sync_data()

◆ _readex_expect_sync_data_len()

◆ _receive_simple_request()

◆ _send_response_and_wait()

◆ _send_response_ex_and_wait()

◆ _server_read_request()

◆ _set_secflags()

◆ _test_http_version()

◆ _test_request_flags()

◆ _test_request_url()

◆ _test_secflags_option()

◆ _test_security_info()

◆ _test_status_code()

◆ BOOL()

◆ callback()

◆ cb()

◆ check_notification()

◆ close_async_handle()

◆ close_connection()

◆ closetest_callback()

◆ free_events()