Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-03 23:01:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

[WINHTTP_WINETEST] Sync with Wine Staging 2.16. CORE-13762

Browse source 
svn path=/trunk/; revision=75945
This commit is contained in:
Amine Khaldi 2017-09-24 11:17:51 +00:00
parent 9048599788
commit 11ab123dcd
1 changed files with 550 additions and 112 deletions
Download patch file Download diff file Expand all files Collapse all files

662
rostests/winetests/winhttp/notification.c
View file

@ -22,12 +22,17 @@
#include <stdlib.h> #include <stdlib.h>
#include <windef.h> #include <windef.h>
#include <winbase.h> #include <winbase.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <winhttp.h> #include <winhttp.h>
#include "wine/test.h" #include "wine/test.h"
static const WCHAR user_agent[] = {'w','i','n','e','t','e','s','t',0}; static const WCHAR user_agent[] = {'w','i','n','e','t','e','s','t',0};
static const WCHAR test_winehq[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0}; static const WCHAR test_winehq[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0};
static const WCHAR tests_hello_html[] = {'/','t','e','s','t','s','/','h','e','l','l','o','.','h','t','m','l',0};
static const WCHAR tests_redirect[] = {'/','t','e','s','t','s','/','r','e','d','i','r','e','c','t',0};
static const WCHAR localhostW[] = {'l','o','c','a','l','h','o','s','t',0};
enum api enum api
{ {
@ -45,11 +50,13 @@ struct notification
{ {
enum api function; /* api responsible for notification */ enum api function; /* api responsible for notification */
unsigned int status; /* status received */ unsigned int status; /* status received */
BOOL todo; DWORD flags; /* a combination of NF_* flags */
BOOL ignore;
BOOL skipped_for_proxy;
}; };
#define NF_ALLOW 0x0001 /* notification may or may not happen */
#define NF_WINE_ALLOW 0x0002 /* wine sends notification when it should not */
#define NF_SIGNAL 0x0004 /* signal wait handle when notified */
struct info struct info
{ {
enum api function; enum api function;
@ -60,62 +67,40 @@ struct info
unsigned int line; unsigned int line;
}; };
static BOOL proxy_active(void) struct test_request
{ {
WINHTTP_PROXY_INFO proxy_info; HINTERNET session;
BOOL active = FALSE; HINTERNET connection;
HINTERNET request;
if (WinHttpGetDefaultProxyConfiguration(&proxy_info)) };
{
active = (proxy_info.lpszProxy != NULL);
if (active)
GlobalFree(proxy_info.lpszProxy);
if (proxy_info.lpszProxyBypass != NULL)
GlobalFree(proxy_info.lpszProxyBypass);
}
else
active = FALSE;
return active;
}
static void CALLBACK check_notification( HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD buflen ) static void CALLBACK check_notification( HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD buflen )
{ {
BOOL status_ok, function_ok; BOOL status_ok, function_ok;
struct info *info = (struct info *)context; struct info *info = (struct info *)context;
unsigned int i = info->index;
if (status == WINHTTP_CALLBACK_STATUS_HANDLE_CREATED) if (status == WINHTTP_CALLBACK_STATUS_HANDLE_CREATED)
{ {
DWORD size = sizeof(struct info *); DWORD size = sizeof(struct info *);
WinHttpQueryOption( handle, WINHTTP_OPTION_CONTEXT_VALUE, &info, &size ); WinHttpQueryOption( handle, WINHTTP_OPTION_CONTEXT_VALUE, &info, &size );
} }
ok(i < info->count, "%u: unexpected notification 0x%08x\n", info->line, status); while (info->index < info->count && info->test[info->index].status != status && (info->test[info->index].flags & NF_ALLOW))
if (i >= info->count) return; info->index++;
while (info->index < info->count && (info->test[info->index].flags & NF_WINE_ALLOW))
{
todo_wine ok(info->test[info->index].status != status, "unexpected %x notification\n", status);
if (info->test[info->index].status == status) break;
info->index++;
}
ok(info->index < info->count, "%u: unexpected notification 0x%08x\n", info->line, status);
if (info->index >= info->count) return;
status_ok = (info->test[i].status == status); status_ok = (info->test[info->index].status == status);
function_ok = (info->test[i].function == info->function); function_ok = (info->test[info->index].function == info->function);
if (!info->test[i].ignore && !info->test[i].todo) ok(status_ok, "%u: expected status 0x%08x got 0x%08x\n", info->line, info->test[info->index].status, status);
{ ok(function_ok, "%u: expected function %u got %u\n", info->line, info->test[info->index].function, info->function);
ok(status_ok, "%u: expected status 0x%08x got 0x%08x\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);
}
else if (!info->test[i].ignore)
{
todo_wine ok(status_ok, "%u: expected status 0x%08x got 0x%08x\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 (status_ok && function_ok) info->index++;
if (proxy_active())
{
while (info->test[info->index].skipped_for_proxy)
info->index++;
}
if (status & (WINHTTP_CALLBACK_FLAG_ALL_COMPLETIONS | WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING)) if (status_ok && function_ok && info->test[info->index++].flags & NF_SIGNAL)
{ {
SetEvent( info->wait ); SetEvent( info->wait );
} }
@ -133,27 +118,65 @@ static const struct notification cache_test[] =
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED }, { winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, TRUE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, TRUE, TRUE } { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL },
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
}; };
static void setup_test( struct info *info, enum api function, unsigned int line ) static void setup_test( struct info *info, enum api function, unsigned int line )
{ {
if (info->wait) ResetEvent( info->wait );
info->function = function; info->function = function;
info->line = line; info->line = line;
while (info->index < info->count && info->test[info->index].function != function
&& (info->test[info->index].flags & (NF_ALLOW | NF_WINE_ALLOW)))
info->index++;
ok_(__FILE__,line)(info->test[info->index].function == function,
"unexpected function %u, expected %u. probably some notifications were missing\n",
info->test[info->index].function, function);
}
static void end_test( struct info *info, unsigned int line )
{
ok_(__FILE__,line)(info->index == info->count, "some notifications were missing: %x\n",
info->test[info->index].status);
} }
static void test_connection_cache( void ) static void test_connection_cache( void )
@ -166,7 +189,7 @@ static void test_connection_cache( void )
info.test = cache_test; info.test = cache_test;
info.count = sizeof(cache_test) / sizeof(cache_test[0]); info.count = sizeof(cache_test) / sizeof(cache_test[0]);
info.index = 0; info.index = 0;
info.wait = NULL; info.wait = CreateEventW( NULL, FALSE, FALSE, NULL );
ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 ); ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 );
ok(ses != NULL, "failed to open session %u\n", GetLastError()); ok(ses != NULL, "failed to open session %u\n", GetLastError());
@ -189,7 +212,7 @@ static void test_connection_cache( void )
ok(con != NULL, "failed to open a connection %u\n", GetLastError()); ok(con != NULL, "failed to open a connection %u\n", GetLastError());
setup_test( &info, winhttp_open_request, __LINE__ ); setup_test( &info, winhttp_open_request, __LINE__ );
req = WinHttpOpenRequest( con, NULL, NULL, NULL, NULL, NULL, 0 ); req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
ok(req != NULL, "failed to open a request %u\n", GetLastError()); ok(req != NULL, "failed to open a request %u\n", GetLastError());
setup_test( &info, winhttp_send_request, __LINE__ ); setup_test( &info, winhttp_send_request, __LINE__ );
@ -211,11 +234,13 @@ static void test_connection_cache( void )
ok(ret, "failed unexpectedly %u\n", GetLastError()); ok(ret, "failed unexpectedly %u\n", GetLastError());
ok(status == 200, "request failed unexpectedly %u\n", status); ok(status == 200, "request failed unexpectedly %u\n", status);
ResetEvent( info.wait );
setup_test( &info, winhttp_close_handle, __LINE__ ); setup_test( &info, winhttp_close_handle, __LINE__ );
WinHttpCloseHandle( req ); WinHttpCloseHandle( req );
WaitForSingleObject( info.wait, INFINITE );
setup_test( &info, winhttp_open_request, __LINE__ ); setup_test( &info, winhttp_open_request, __LINE__ );
req = WinHttpOpenRequest( con, NULL, NULL, NULL, NULL, NULL, 0 ); req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
ok(req != NULL, "failed to open a request %u\n", GetLastError()); ok(req != NULL, "failed to open a request %u\n", GetLastError());
ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) ); ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
@ -240,12 +265,12 @@ static void test_connection_cache( void )
ok(ret, "failed unexpectedly %u\n", GetLastError()); ok(ret, "failed unexpectedly %u\n", GetLastError());
ok(status == 200, "request failed unexpectedly %u\n", status); ok(status == 200, "request failed unexpectedly %u\n", status);
ResetEvent( info.wait );
setup_test( &info, winhttp_close_handle, __LINE__ ); setup_test( &info, winhttp_close_handle, __LINE__ );
WinHttpCloseHandle( req ); WinHttpCloseHandle( req );
setup_test( &info, winhttp_close_handle, __LINE__ );
WinHttpCloseHandle( req ); WinHttpCloseHandle( req );
WinHttpCloseHandle( con ); WinHttpCloseHandle( con );
WaitForSingleObject( info.wait, INFINITE );
if (unload) if (unload)
{ {
@ -253,16 +278,16 @@ static void test_connection_cache( void )
ok(status == WAIT_TIMEOUT, "got %08x\n", status); ok(status == WAIT_TIMEOUT, "got %08x\n", status);
} }
setup_test( &info, winhttp_close_handle, __LINE__ );
WinHttpCloseHandle( ses ); WinHttpCloseHandle( ses );
WaitForSingleObject( info.wait, INFINITE );
Sleep(2000); /* make sure connection is evicted from cache */
if (unload) if (unload)
{ {
status = WaitForSingleObject( event, 0 ); status = WaitForSingleObject( event, 100 );
ok(status == WAIT_OBJECT_0, "got %08x\n", status); ok(status == WAIT_OBJECT_0, "got %08x\n", status);
} }
info.index = 0;
ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 ); ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 );
ok(ses != NULL, "failed to open session %u\n", GetLastError()); ok(ses != NULL, "failed to open session %u\n", GetLastError());
@ -283,7 +308,7 @@ static void test_connection_cache( void )
ok(con != NULL, "failed to open a connection %u\n", GetLastError()); ok(con != NULL, "failed to open a connection %u\n", GetLastError());
setup_test( &info, winhttp_open_request, __LINE__ ); setup_test( &info, winhttp_open_request, __LINE__ );
req = WinHttpOpenRequest( con, NULL, NULL, NULL, NULL, NULL, 0 ); req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
ok(req != NULL, "failed to open a request %u\n", GetLastError()); ok(req != NULL, "failed to open a request %u\n", GetLastError());
ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) ); ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
@ -308,11 +333,13 @@ static void test_connection_cache( void )
ok(ret, "failed unexpectedly %u\n", GetLastError()); ok(ret, "failed unexpectedly %u\n", GetLastError());
ok(status == 200, "request failed unexpectedly %u\n", status); ok(status == 200, "request failed unexpectedly %u\n", status);
ResetEvent( info.wait );
setup_test( &info, winhttp_close_handle, __LINE__ ); setup_test( &info, winhttp_close_handle, __LINE__ );
WinHttpCloseHandle( req ); WinHttpCloseHandle( req );
WaitForSingleObject( info.wait, INFINITE );
setup_test( &info, winhttp_open_request, __LINE__ ); setup_test( &info, winhttp_open_request, __LINE__ );
req = WinHttpOpenRequest( con, NULL, NULL, NULL, NULL, NULL, 0 ); req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
ok(req != NULL, "failed to open a request %u\n", GetLastError()); ok(req != NULL, "failed to open a request %u\n", GetLastError());
ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) ); ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
@ -341,6 +368,7 @@ static void test_connection_cache( void )
done: done:
WinHttpCloseHandle( req ); WinHttpCloseHandle( req );
WinHttpCloseHandle( con ); WinHttpCloseHandle( con );
WaitForSingleObject( info.wait, INFINITE );
if (unload) if (unload)
{ {
@ -348,12 +376,15 @@ done:
ok(status == WAIT_TIMEOUT, "got %08x\n", status); ok(status == WAIT_TIMEOUT, "got %08x\n", status);
} }
setup_test( &info, winhttp_close_handle, __LINE__ );
WinHttpCloseHandle( ses ); WinHttpCloseHandle( ses );
WaitForSingleObject( info.wait, INFINITE );
CloseHandle( info.wait );
end_test( &info, __LINE__ );
Sleep(2000); /* make sure connection is evicted from cache */
if (unload) if (unload)
{ {
status = WaitForSingleObject( event, 0 ); status = WaitForSingleObject( event, 100 );
ok(status == WAIT_OBJECT_0, "got %08x\n", status); ok(status == WAIT_OBJECT_0, "got %08x\n", status);
} }
@ -364,28 +395,28 @@ static const struct notification redirect_test[] =
{ {
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED }, { winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED }, { winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, FALSE, TRUE }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, FALSE, TRUE }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_REDIRECT }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_REDIRECT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, FALSE, TRUE, TRUE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, FALSE, TRUE, TRUE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, FALSE, FALSE, TRUE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, FALSE, FALSE, TRUE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_REQUEST_SENT }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, FALSE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, TRUE, TRUE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, TRUE, TRUE } { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
}; };
static void test_redirect( void ) static void test_redirect( void )
@ -398,7 +429,7 @@ static void test_redirect( void )
info.test = redirect_test; info.test = redirect_test;
info.count = sizeof(redirect_test) / sizeof(redirect_test[0]); info.count = sizeof(redirect_test) / sizeof(redirect_test[0]);
info.index = 0; info.index = 0;
info.wait = NULL; info.wait = CreateEventW( NULL, FALSE, FALSE, NULL );
ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 ); ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 );
ok(ses != NULL, "failed to open session %u\n", GetLastError()); ok(ses != NULL, "failed to open session %u\n", GetLastError());
@ -413,7 +444,7 @@ static void test_redirect( void )
ok(con != NULL, "failed to open a connection %u\n", GetLastError()); ok(con != NULL, "failed to open a connection %u\n", GetLastError());
setup_test( &info, winhttp_open_request, __LINE__ ); setup_test( &info, winhttp_open_request, __LINE__ );
req = WinHttpOpenRequest( con, NULL, NULL, NULL, NULL, NULL, 0 ); req = WinHttpOpenRequest( con, NULL, tests_redirect, NULL, NULL, NULL, 0 );
ok(req != NULL, "failed to open a request %u\n", GetLastError()); ok(req != NULL, "failed to open a request %u\n", GetLastError());
setup_test( &info, winhttp_send_request, __LINE__ ); setup_test( &info, winhttp_send_request, __LINE__ );
@ -440,40 +471,32 @@ done:
WinHttpCloseHandle( req ); WinHttpCloseHandle( req );
WinHttpCloseHandle( con ); WinHttpCloseHandle( con );
WinHttpCloseHandle( ses ); WinHttpCloseHandle( ses );
WaitForSingleObject( info.wait, INFINITE );
CloseHandle( info.wait );
end_test( &info, __LINE__ );
} }
static const struct notification async_test[] = static const struct notification async_test[] =
{ {
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED }, { winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED }, { winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, FALSE, TRUE }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, FALSE, TRUE }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE }, { winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NF_SIGNAL },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_REDIRECT }, { winhttp_receive_response, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NF_SIGNAL },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, FALSE, TRUE, TRUE }, { winhttp_query_data, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE, NF_SIGNAL },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, FALSE, TRUE, TRUE }, { winhttp_read_data, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, FALSE, FALSE, TRUE }, { winhttp_read_data, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, FALSE, FALSE, TRUE }, { winhttp_read_data, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, NF_SIGNAL },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_REQUEST_SENT }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE }, { winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE },
{ winhttp_query_data, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, FALSE, TRUE },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, FALSE, TRUE },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, FALSE, TRUE },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, FALSE, TRUE },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, FALSE, TRUE },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, FALSE, TRUE },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, TRUE, TRUE },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, TRUE, TRUE }
}; };
static void test_async( void ) static void test_async( void )
@ -520,7 +543,7 @@ static void test_async( void )
setup_test( &info, winhttp_open_request, __LINE__ ); setup_test( &info, winhttp_open_request, __LINE__ );
SetLastError( 0xdeadbeef ); SetLastError( 0xdeadbeef );
req = WinHttpOpenRequest( con, NULL, NULL, NULL, NULL, NULL, 0 ); req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
err = GetLastError(); err = GetLastError();
ok(req != NULL, "failed to open a request %u\n", err); ok(req != NULL, "failed to open a request %u\n", err);
ok(err == ERROR_SUCCESS, "got %u\n", err); ok(err == ERROR_SUCCESS, "got %u\n", err);
@ -570,11 +593,8 @@ static void test_async( void )
WaitForSingleObject( info.wait, INFINITE ); WaitForSingleObject( info.wait, INFINITE );
setup_test( &info, winhttp_read_data, __LINE__ ); setup_test( &info, winhttp_read_data, __LINE__ );
SetLastError( 0xdeadbeef );
ret = WinHttpReadData( req, buffer, sizeof(buffer), NULL ); ret = WinHttpReadData( req, buffer, sizeof(buffer), NULL );
err = GetLastError();
ok(ret, "failed to read data %u\n", err); ok(ret, "failed to read data %u\n", err);
ok(err == ERROR_SUCCESS, "got %u\n", err);
WaitForSingleObject( info.wait, INFINITE ); WaitForSingleObject( info.wait, INFINITE );
@ -588,8 +608,8 @@ static void test_async( void )
ok(status == WAIT_TIMEOUT, "got %08x\n", status); ok(status == WAIT_TIMEOUT, "got %08x\n", status);
} }
WinHttpCloseHandle( ses ); WinHttpCloseHandle( ses );
WaitForSingleObject( info.wait, INFINITE ); WaitForSingleObject( info.wait, INFINITE );
end_test( &info, __LINE__ );
if (unload) if (unload)
{ {
@ -598,12 +618,430 @@ static void test_async( void )
} }
CloseHandle( event ); CloseHandle( event );
CloseHandle( info.wait ); CloseHandle( info.wait );
end_test( &info, __LINE__ );
}
static const char okmsg[] =
"HTTP/1.1 200 OK\r\n"
"Server: winetest\r\n"
"\r\n";
static const char page1[] =
"<HTML>\r\n"
"<HEAD><TITLE>winhttp test page</TITLE></HEAD>\r\n"
"<BODY>The quick brown fox jumped over the lazy dog<P></BODY>\r\n"
"</HTML>\r\n\r\n";
struct server_info
{
HANDLE event;
int port;
};
static int server_socket;
static HANDLE server_socket_available, server_socket_done;
static DWORD CALLBACK server_thread(LPVOID param)
{
struct server_info *si = param;
int r, c = -1, i, on;
SOCKET s;
struct sockaddr_in sa;
char buffer[0x100];
WSADATA wsaData;
int last_request = 0;
WSAStartup(MAKEWORD(1,1), &wsaData);
s = socket(AF_INET, SOCK_STREAM, 0);
if (s == INVALID_SOCKET)
return 1;
on = 1;
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on);
memset(&sa, 0, sizeof sa);
sa.sin_family = AF_INET;
sa.sin_port = htons(si->port);
sa.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
r = bind(s, (struct sockaddr *)&sa, sizeof(sa));
if (r < 0)
return 1;
listen(s, 0);
SetEvent(si->event);
do
{
if (c == -1) c = accept(s, NULL, NULL);
memset(buffer, 0, sizeof buffer);
for(i = 0; i < sizeof buffer - 1; i++)
{
r = recv(c, &buffer[i], 1, 0);
if (r != 1)
break;
if (i < 4) continue;
if (buffer[i - 2] == '\n' && buffer[i] == '\n' &&
buffer[i - 3] == '\r' && buffer[i - 1] == '\r')
break;
}
if (strstr(buffer, "GET /quit"))
{
send(c, okmsg, sizeof okmsg - 1, 0);
send(c, page1, sizeof page1 - 1, 0);
last_request = 1;
}
else if(strstr(buffer, "GET /socket"))
{
server_socket = c;
SetEvent(server_socket_available);
WaitForSingleObject(server_socket_done, INFINITE);
ResetEvent(server_socket_available);
}
shutdown(c, 2);
closesocket(c);
c = -1;
} while (!last_request);
closesocket(s);
return 0;
}
static void test_basic_request(int port, const WCHAR *verb, const WCHAR *path)
{
HINTERNET ses, con, req;
char buffer[0x100];
DWORD count, status, size;
BOOL ret;
ses = WinHttpOpen(NULL, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0);
ok(ses != NULL, "failed to open session %u\n", GetLastError());
con = WinHttpConnect(ses, localhostW, port, 0);
ok(con != NULL, "failed to open a connection %u\n", GetLastError());
req = WinHttpOpenRequest(con, verb, path, NULL, NULL, NULL, 0);
ok(req != NULL, "failed to open a request %u\n", GetLastError());
ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
ok(ret, "failed to send request %u\n", GetLastError());
ret = WinHttpReceiveResponse(req, NULL);
ok(ret, "failed to receive response %u\n", GetLastError());
status = 0xdeadbeef;
size = sizeof(status);
ret = WinHttpQueryHeaders(req, WINHTTP_QUERY_STATUS_CODE|WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL);
ok(ret, "failed to query status code %u\n", GetLastError());
ok(status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status);
count = 0;
memset(buffer, 0, sizeof(buffer));
ret = WinHttpReadData(req, buffer, sizeof buffer, &count);
ok(ret, "failed to read data %u\n", GetLastError());
ok(count == sizeof page1 - 1, "count was wrong\n");
ok(!memcmp(buffer, page1, sizeof page1), "http data wrong\n");
WinHttpCloseHandle(req);
WinHttpCloseHandle(con);
WinHttpCloseHandle(ses);
}
static const struct notification open_socket_request_test[] =
{
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_ALLOW }, /* some versions call it twice. why? */
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NF_SIGNAL }
};
static const struct notification reuse_socket_request_test[] =
{
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NF_SIGNAL },
};
static void open_async_request(int port, struct test_request *req, struct info *info, const WCHAR *path, BOOL reuse_connection)
{
BOOL ret;
info->index = 0;
if (reuse_connection)
{
info->test = reuse_socket_request_test;
info->count = sizeof(reuse_socket_request_test) / sizeof(reuse_socket_request_test[0]);
}
else
{
info->test = open_socket_request_test;
info->count = sizeof(open_socket_request_test) / sizeof(open_socket_request_test[0]);
}
req->session = WinHttpOpen( user_agent, 0, NULL, NULL, WINHTTP_FLAG_ASYNC );
ok(req->session != NULL, "failed to open session %u\n", GetLastError());
WinHttpSetOption( req->session, WINHTTP_OPTION_CONTEXT_VALUE, &info, sizeof(struct info *) );
WinHttpSetStatusCallback( req->session, check_notification, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS, 0 );
setup_test( info, winhttp_connect, __LINE__ );
req->connection = WinHttpConnect( req->session, localhostW, port, 0 );
ok(req->connection != NULL, "failed to open a connection %u\n", GetLastError());
setup_test( info, winhttp_open_request, __LINE__ );
req->request = WinHttpOpenRequest( req->connection, NULL, path, NULL, NULL, NULL, 0 );
ok(req->request != NULL, "failed to open a request %u\n", GetLastError());
setup_test( info, winhttp_send_request, __LINE__ );
ret = WinHttpSendRequest( req->request, NULL, 0, NULL, 0, 0, 0 );
ok(ret, "failed to send request %u\n", GetLastError());
}
static void open_socket_request(int port, struct test_request *req, struct info *info)
{
static const WCHAR socketW[] = {'/','s','o','c','k','e','t',0};
ResetEvent( server_socket_done );
open_async_request( port, req, info, socketW, FALSE );
WaitForSingleObject( server_socket_available, INFINITE );
}
static const struct notification server_reply_test[] =
{
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NF_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, NF_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NF_SIGNAL }
};
static void server_send_reply(struct test_request *req, struct info *info, const char *msg)
{
BOOL ret;
send( server_socket, msg, strlen( msg ), 0 );
WaitForSingleObject( info->wait, INFINITE );
info->test = server_reply_test;
info->count = sizeof(server_reply_test) / sizeof(server_reply_test[0]);
info->index = 0;
setup_test( info, winhttp_send_request, __LINE__ );
ret = WinHttpReceiveResponse( req->request, NULL );
ok(ret, "failed to receive response %u\n", GetLastError());
WaitForSingleObject( info->wait, INFINITE );
end_test( info, __LINE__ );
}
#define server_read_data(a) _server_read_data(a,__LINE__)
static void _server_read_data(const char *expect_prefix, unsigned int line)
{
char buf[1024];
DWORD size, len;
size = recv( server_socket, buf, sizeof(buf), 0 );
len = strlen( expect_prefix );
ok_(__FILE__,line)(size > len, "data too short\n");
if (size >= len)
{
buf[len] = 0;
ok_(__FILE__,line)(!strcmp( buf, expect_prefix ), "unexpected data \"%s\"\n", buf);
}
}
static const struct notification close_request_test[] =
{
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
};
static const struct notification close_allow_connection_close_request_test[] =
{
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
};
static void close_request(struct test_request *req, struct info *info, BOOL allow_closing_connection)
{
BOOL ret;
if (allow_closing_connection)
{
info->test = close_allow_connection_close_request_test;
info->count = sizeof(close_allow_connection_close_request_test)/sizeof(*close_allow_connection_close_request_test);
}
else
{
info->test = close_request_test;
info->count = sizeof(close_request_test)/sizeof(*close_request_test);
}
info->index = 0;
setup_test( info, winhttp_close_handle, __LINE__ );
ret = WinHttpCloseHandle( req->request );
ok(ret, "WinHttpCloseHandle failed: %u\n", GetLastError());
ret = WinHttpCloseHandle( req->connection );
ok(ret, "WinHttpCloseHandle failed: %u\n", GetLastError());
ret = WinHttpCloseHandle( req->session );
ok(ret, "WinHttpCloseHandle failed: %u\n", GetLastError());
WaitForSingleObject( info->wait, INFINITE );
end_test( info, __LINE__ );
}
static const struct notification read_test[] =
{
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, NF_SIGNAL }
};
static const struct notification read_allow_close_test[] =
{
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, NF_SIGNAL }
};
#define read_request_data(a,b,c,d) _read_request_data(a,b,c,d,__LINE__)
static void _read_request_data(struct test_request *req, struct info *info, const char *expected_data, BOOL closing_connection, unsigned line)
{
char buffer[1024];
DWORD read, len;
BOOL ret;
if (closing_connection)
{
info->test = read_allow_close_test;
info->count = sizeof(read_allow_close_test)/sizeof(*read_allow_close_test);
}
else
{
info->test = read_test;
info->count = sizeof(read_test)/sizeof(*read_test);
}
info->index = 0;
setup_test( info, winhttp_read_data, line );
memset(buffer, '?', sizeof(buffer));
read = 0xdeadbeef;
ret = WinHttpReadData( req->request, buffer, sizeof(buffer), &read );
ok(ret, "failed to read data %u\n", GetLastError());
WaitForSingleObject( info->wait, INFINITE );
len = strlen(expected_data);
ok(!memcmp(buffer, expected_data, len), "unexpeceted data\n");
}
static void test_persistent_connection(int port)
{
struct test_request req;
struct info info;
static const WCHAR testW[] = {'/','t','e','s','t',0};
trace("Testing persistent connection...\n");
info.wait = CreateEventW( NULL, FALSE, FALSE, NULL );
open_socket_request( port, &req, &info );
server_send_reply( &req, &info,
"HTTP/1.1 200 OK\r\n"
"Server: winetest\r\n"
"Connection: keep-alive\r\n"
"Content-Length: 1\r\n"
"\r\n"
"X" );
read_request_data( &req, &info, "X", FALSE );
close_request( &req, &info, FALSE );
/* chunked connection test */
open_async_request( port, &req, &info, testW, TRUE );
server_read_data( "GET /test HTTP/1.1\r\n" );
server_send_reply( &req, &info,
"HTTP/1.1 200 OK\r\n"
"Server: winetest\r\n"
"Transfer-Encoding: chunked\r\n"
"Connection: keep-alive\r\n"
"\r\n"
"9\r\n123456789\r\n"
"0\r\n\r\n" );
read_request_data( &req, &info, "123456789", FALSE );
close_request( &req, &info, FALSE );
/* HTTP/1.1 connections are persistent by default, no additional header is needed */
open_async_request( port, &req, &info, testW, TRUE );
server_read_data( "GET /test HTTP/1.1\r\n" );
server_send_reply( &req, &info,
"HTTP/1.1 200 OK\r\n"
"Server: winetest\r\n"
"Content-Length: 2\r\n"
"\r\n"
"xx" );
read_request_data( &req, &info, "xx", FALSE );
close_request( &req, &info, FALSE );
open_async_request( port, &req, &info, testW, TRUE );
server_read_data( "GET /test HTTP/1.1\r\n" );
server_send_reply( &req, &info,
"HTTP/1.1 200 OK\r\n"
"Server: winetest\r\n"
"Content-Length: 2\r\n"
"Connection: close\r\n"
"\r\n"
"yy" );
close_request( &req, &info, TRUE );
SetEvent( server_socket_done );
CloseHandle( info.wait );
} }
START_TEST (notification) START_TEST (notification)
{ {
static const WCHAR quitW[] = {'/','q','u','i','t',0};
struct server_info si;
HANDLE thread;
DWORD ret;
test_connection_cache(); test_connection_cache();
test_redirect(); test_redirect();
Sleep(2000); /* make sure previous connection is evicted from cache */
test_async(); test_async();
si.event = CreateEventW( NULL, 0, 0, NULL );
si.port = 7533;
thread = CreateThread( NULL, 0, server_thread, (LPVOID)&si, 0, NULL );
ok(thread != NULL, "failed to create thread %u\n", GetLastError());
server_socket_available = CreateEventW( NULL, 0, 0, NULL );
server_socket_done = CreateEventW( NULL, 0, 0, NULL );
ret = WaitForSingleObject( si.event, 10000 );
ok(ret == WAIT_OBJECT_0, "failed to start winhttp test server %u\n", GetLastError());
if (ret != WAIT_OBJECT_0)
return;
test_persistent_connection( si.port );
/* send the basic request again to shutdown the server thread */
test_basic_request( si.port, NULL, quitW );
WaitForSingleObject( thread, 3000 );
CloseHandle( thread );
CloseHandle( server_socket_available );
CloseHandle( server_socket_done );
} }