ReactOS 0.4.15-dev-7918-g2a2556c
winhttp.c File Reference
#include <stdarg.h>
#include <windef.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <winhttp.h>
#include <wincrypt.h>
#include <winreg.h>
#include <stdio.h>
#include <initguid.h>
#include <httprequest.h>
#include <httprequestid.h>
#include "wine/test.h"
#include "wine/heap.h"
Include dependency graph for winhttp.c:

Go to the source code of this file.

Classes

struct  server_info
 

Macros

#define COBJMACROS
 
#define X(x)   if (flags & x) trace("%s\n", #x);
 
#define BIG_BUFFER_LEN   0x2250
 

Functions

 DEFINE_GUID (GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 
static WCHARa2w (const char *str)
 
static int strcmp_wa (const WCHAR *str1, const char *stra)
 
static BOOL proxy_active (void)
 
static void test_WinHttpQueryOption (void)
 
static void test_WinHttpOpenRequest (void)
 
static void test_empty_headers_param (void)
 
static void test_WinHttpSendRequest (void)
 
static void test_WinHttpTimeFromSystemTime (void)
 
static void test_WinHttpTimeToSystemTime (void)
 
static void test_WinHttpAddHeaders (void)
 
static void CALLBACK cert_error (HINTERNET handle, DWORD_PTR ctx, DWORD status, LPVOID buf, DWORD len)
 
static void test_secure_connection (void)
 
static void test_request_parameter_defaults (void)
 
static DWORD get_default_proxy_reg_value (BYTE *buf, DWORD len, DWORD *type)
 
static void set_proxy (REGSAM access, BYTE *buf, DWORD len, DWORD type)
 
static void set_default_proxy_reg_value (BYTE *buf, DWORD len, DWORD type)
 
static void test_set_default_proxy_config (void)
 
static void test_timeouts (void)
 
static void test_resolve_timeout (void)
 
static DWORD CALLBACK server_thread (LPVOID param)
 
static void test_basic_request (int port, const WCHAR *verb, const WCHAR *path)
 
static void test_basic_authentication (int port)
 
static void test_multi_authentication (int port)
 
static void test_large_data_authentication (int port)
 
static void test_no_headers (int port)
 
static void test_no_content (int port)
 
static void test_head_request (int port)
 
static void test_not_modified (int port)
 
static void test_bad_header (int port)
 
static void test_multiple_reads (int port)
 
static void test_cookies (int port)
 
static void do_request (HINTERNET con, const WCHAR *obj, DWORD flags)
 
static void test_request_path_escapes (int port)
 
static void test_connection_info (int port)
 
static void test_passport_auth (int port)
 
static void test_credentials (void)
 
static void test_IWinHttpRequest (int port)
 
static void request_get_property (IWinHttpRequest *request, int property, VARIANT *ret)
 
static void test_IWinHttpRequest_Invoke (void)
 
static void test_WinHttpDetectAutoProxyConfigUrl (void)
 
static void test_WinHttpGetIEProxyConfigForCurrentUser (void)
 
static void test_WinHttpGetProxyForUrl (void)
 
static void test_chunked_read (void)
 
 START_TEST (winhttp)
 

Variables

static const WCHAR test_useragent []
 
static const WCHAR test_winehq [] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0}
 
static const WCHAR test_winehq_https [] = {'h','t','t','p','s',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',':','4','4','3',0}
 
static const WCHAR localhostW [] = {'l','o','c','a','l','h','o','s','t',0}
 
static const WCHAR Connections []
 
static const WCHAR WinHttpSettings []
 
static const char page1 []
 
static const char okmsg []
 
static const char notokmsg []
 
static const char cookiemsg []
 
static const char cookiemsg2 []
 
static const char nocontentmsg []
 
static const char notmodified []
 
static const char noauthmsg []
 
static const char okauthmsg []
 
static const char headmsg []
 
static const char multiauth []
 
static const char largeauth []
 
static const char passportauth []
 
static const char unauthorized [] = "Unauthorized"
 
static const char hello_world [] = "Hello World"
 
static const char auth_unseen [] = "Auth Unseen"
 

Macro Definition Documentation

◆ BIG_BUFFER_LEN

#define BIG_BUFFER_LEN   0x2250

Definition at line 2269 of file winhttp.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 22 of file winhttp.c.

◆ X

#define X (   x)    if (flags & x) trace("%s\n", #x);

Function Documentation

◆ a2w()

static WCHAR * a2w ( const char str)
static

Definition at line 46 of file winhttp.c.

47{
48 int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
49 WCHAR *ret = heap_alloc(len * sizeof(WCHAR));
51 return ret;
52}
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
#define NULL
Definition: types.h:112
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
GLenum GLsizei len
Definition: glext.h:6722
const WCHAR * str
int ret
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by strcmp_wa().

◆ cert_error()

static void CALLBACK cert_error ( HINTERNET  handle,
DWORD_PTR  ctx,
DWORD  status,
LPVOID  buf,
DWORD  len 
)
static

Definition at line 1028 of file winhttp.c.

1029{
1030 DWORD flags = *(DWORD *)buf;
1031
1032 if (!flags)
1033 {
1034 trace("WINHTTP_CALLBACK_STATUS_FLAG_SECURITY_CHANNEL_ERROR\n");
1035 return;
1036 }
1037#define X(x) if (flags & x) trace("%s\n", #x);
1045#undef X
1046}
#define trace
Definition: atltest.h:70
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLbitfield flags
Definition: glext.h:7161
#define X(x)
#define WINHTTP_CALLBACK_STATUS_FLAG_CERT_REV_FAILED
Definition: winhttp.h:434
#define WINHTTP_CALLBACK_STATUS_FLAG_CERT_WRONG_USAGE
Definition: winhttp.h:440
#define WINHTTP_CALLBACK_STATUS_FLAG_CERT_CN_INVALID
Definition: winhttp.h:438
#define WINHTTP_CALLBACK_STATUS_FLAG_CERT_REVOKED
Definition: winhttp.h:436
#define WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CA
Definition: winhttp.h:437
#define WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CERT
Definition: winhttp.h:435
#define WINHTTP_CALLBACK_STATUS_FLAG_CERT_DATE_INVALID
Definition: winhttp.h:439

Referenced by test_secure_connection().

◆ DEFINE_GUID()

DEFINE_GUID ( GUID_NULL  ,
,
,
,
,
,
,
,
,
,
,
 
)

◆ do_request()

static void do_request ( HINTERNET  con,
const WCHAR obj,
DWORD  flags 
)
static

Definition at line 3427 of file winhttp.c.

3428{
3429 HINTERNET req;
3430 DWORD status, size;
3431 BOOL ret;
3432
3433 req = WinHttpOpenRequest( con, NULL, obj, NULL, NULL, NULL, flags );
3434 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3435
3436 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
3437 ok( ret, "failed to send request %u\n", GetLastError() );
3438
3440 ok( ret, "failed to receive response %u\n", GetLastError() );
3441
3442 status = 0xdeadbeef;
3443 size = sizeof(status);
3445 ok( ret, "failed to query status code %u\n", GetLastError() );
3447 "request %s with flags %08x failed %u\n", wine_dbgstr_w(obj), flags, status );
3448 WinHttpCloseHandle( req );
3449}
#define broken(x)
Definition: _sntprintf.h:21
#define ok(value,...)
Definition: atltest.h:57
BOOL WINAPI WinHttpCloseHandle(HINTERNET handle)
Definition: session.c:1195
HINTERNET WINAPI WinHttpOpenRequest(HINTERNET hconnect, LPCWSTR verb, LPCWSTR object, LPCWSTR version, LPCWSTR referrer, LPCWSTR *types, DWORD flags)
Definition: session.c:1117
unsigned int BOOL
Definition: ntddk_ex.h:94
GLsizeiptr size
Definition: glext.h:5919
#define wine_dbgstr_w
Definition: kernel32.h:34
BOOL WINAPI WinHttpQueryHeaders(HINTERNET hrequest, DWORD level, LPCWSTR name, LPVOID buffer, LPDWORD buflen, LPDWORD index)
Definition: request.c:856
BOOL WINAPI WinHttpSendRequest(HINTERNET hrequest, LPCWSTR headers, DWORD headers_len, LPVOID optional, DWORD optional_len, DWORD total_len, DWORD_PTR context)
Definition: request.c:2350
BOOL WINAPI WinHttpReceiveResponse(HINTERNET hrequest, LPVOID reserved)
Definition: request.c:2924
Definition: ps.c:97
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define HTTP_STATUS_OK
Definition: winhttp.h:240
#define HTTP_STATUS_BAD_REQUEST
Definition: winhttp.h:255
#define WINHTTP_QUERY_STATUS_CODE
Definition: winhttp.h:317
#define WINHTTP_QUERY_FLAG_NUMBER
Definition: winhttp.h:377

Referenced by test_request_path_escapes().

◆ get_default_proxy_reg_value()

static DWORD get_default_proxy_reg_value ( BYTE buf,
DWORD  len,
DWORD type 
)
static

Definition at line 1309 of file winhttp.c.

1310{
1311 LONG l;
1312 HKEY key;
1313 DWORD ret = 0;
1314
1316 if (!l)
1317 {
1318 DWORD size = 0;
1319
1321 if (!l)
1322 {
1323 if (size <= len)
1325 &size );
1326 if (!l)
1327 ret = size;
1328 }
1329 RegCloseKey( key );
1330 }
1331 return ret;
1332}
#define RegCloseKey(hKey)
Definition: registry.h:49
r l[0]
Definition: byte_order.h:168
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define KEY_READ
Definition: nt_native.h:1023
long LONG
Definition: pedump.c:60
Definition: copy.c:22
static const WCHAR WinHttpSettings[]
Definition: winhttp.c:1306
static const WCHAR Connections[]
Definition: winhttp.c:1299
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by test_set_default_proxy_config().

◆ proxy_active()

static BOOL proxy_active ( void  )
static

Definition at line 62 of file winhttp.c.

63{
64 WINHTTP_PROXY_INFO proxy_info;
65 BOOL active = FALSE;
66
67 SetLastError(0xdeadbeef);
69 {
70 ok(GetLastError() == ERROR_SUCCESS || broken(GetLastError() == 0xdeadbeef) /* < win7 */,
71 "got %u\n", GetLastError());
72 active = (proxy_info.lpszProxy != NULL);
73 if (active)
74 GlobalFree(proxy_info.lpszProxy);
75 if (proxy_info.lpszProxyBypass != NULL)
76 GlobalFree(proxy_info.lpszProxyBypass);
77 }
78 else
79 active = FALSE;
80
81 return active;
82}
#define ERROR_SUCCESS
Definition: deptool.c:10
#define FALSE
Definition: types.h:117
#define SetLastError(x)
Definition: compat.h:752
BOOL WINAPI WinHttpGetDefaultProxyConfiguration(WINHTTP_PROXY_INFO *info)
Definition: session.c:1537
HGLOBAL NTAPI GlobalFree(HGLOBAL hMem)
Definition: heapmem.c:611
LPWSTR lpszProxyBypass
Definition: winhttp.h:506
LPWSTR lpszProxy
Definition: winhttp.h:505

Referenced by test_resolve_timeout().

◆ request_get_property()

static void request_get_property ( IWinHttpRequest *  request,
int  property,
VARIANT ret 
)
static

Definition at line 4327 of file winhttp.c.

4328{
4330 VARIANT arg;
4331 HRESULT hr;
4332
4333 memset(&params, 0, sizeof(params));
4334 params.cNamedArgs = 0;
4335 params.rgdispidNamedArgs = NULL;
4336 params.cArgs = 1;
4337 params.rgvarg = &arg;
4338 VariantInit(&arg);
4339 V_VT(&arg) = VT_I4;
4340 V_I4(&arg) = property;
4342 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0,
4344 ok(hr == S_OK, "error %#x\n", hr);
4345}
@ VT_I4
Definition: compat.h:2298
GLenum const GLfloat * params
Definition: glext.h:5645
#define DISPID_HTTPREQUEST_OPTION
Definition: httprequestid.h:28
#define S_OK
Definition: intsafe.h:52
struct stdole::DISPPARAMS DISPPARAMS
#define V_VT(A)
Definition: oleauto.h:211
#define V_I4(A)
Definition: oleauto.h:247
#define DISPATCH_PROPERTYGET
Definition: oleauto.h:1007
#define IID_NULL
Definition: guiddef.h:98
#define memset(x, y, z)
Definition: compat.h:39
HRESULT hr
Definition: shlfolder.c:183
Definition: tftpd.h:86
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
void * arg
Definition: msvc.h:10

Referenced by test_IWinHttpRequest_Invoke().

◆ server_thread()

static DWORD CALLBACK server_thread ( LPVOID  param)
static

Definition at line 2271 of file winhttp.c.

2272{
2273 struct server_info *si = param;
2274 int r, c = -1, i, on;
2275 SOCKET s;
2276 struct sockaddr_in sa;
2277 char buffer[0x100];
2278 WSADATA wsaData;
2279 int last_request = 0;
2280
2281 WSAStartup(MAKEWORD(1,1), &wsaData);
2282
2283 s = socket(AF_INET, SOCK_STREAM, 0);
2284 if (s == INVALID_SOCKET)
2285 return 1;
2286
2287 on = 1;
2288 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on);
2289
2290 memset(&sa, 0, sizeof sa);
2291 sa.sin_family = AF_INET;
2292 sa.sin_port = htons(si->port);
2293 sa.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
2294
2295 r = bind(s, (struct sockaddr *)&sa, sizeof(sa));
2296 if (r < 0)
2297 return 1;
2298
2299 listen(s, 0);
2300 SetEvent(si->event);
2301 do
2302 {
2303 if (c == -1) c = accept(s, NULL, NULL);
2304
2305 memset(buffer, 0, sizeof buffer);
2306 for(i = 0; i < sizeof buffer - 1; i++)
2307 {
2308 r = recv(c, &buffer[i], 1, 0);
2309 if (r != 1)
2310 break;
2311 if (i < 4) continue;
2312 if (buffer[i - 2] == '\n' && buffer[i] == '\n' &&
2313 buffer[i - 3] == '\r' && buffer[i - 1] == '\r')
2314 break;
2315 }
2316 if (strstr(buffer, "GET /basic"))
2317 {
2318 send(c, okmsg, sizeof okmsg - 1, 0);
2319 send(c, page1, sizeof page1 - 1, 0);
2320 }
2321 if (strstr(buffer, "/auth_with_creds"))
2322 {
2323 send(c, okauthmsg, sizeof okauthmsg - 1, 0);
2324 if (strstr(buffer, "Authorization: Basic dXNlcjpwd2Q="))
2325 send(c, hello_world, sizeof hello_world - 1, 0);
2326 else
2327 send(c, auth_unseen, sizeof auth_unseen - 1, 0);
2328 continue;
2329 }
2330 if (strstr(buffer, "/auth"))
2331 {
2332 if (strstr(buffer, "Authorization: Basic dXNlcjpwd2Q="))
2333 {
2334 send(c, okauthmsg, sizeof okauthmsg - 1, 0);
2335 send(c, hello_world, sizeof hello_world - 1, 0);
2336 }
2337 else
2338 {
2339 send(c, noauthmsg, sizeof noauthmsg - 1, 0);
2340 send(c, unauthorized, sizeof unauthorized - 1, 0);
2341 }
2342 continue;
2343 }
2344 if (strstr(buffer, "/big"))
2345 {
2346 char msg[BIG_BUFFER_LEN];
2347 memset(msg, 'm', sizeof(msg));
2348 send(c, okmsg, sizeof(okmsg) - 1, 0);
2349 send(c, msg, sizeof(msg), 0);
2350 }
2351 if (strstr(buffer, "/no_headers"))
2352 {
2353 send(c, page1, sizeof page1 - 1, 0);
2354 }
2355 if (strstr(buffer, "GET /no_content"))
2356 {
2357 send(c, nocontentmsg, sizeof nocontentmsg - 1, 0);
2358 continue;
2359 }
2360 if (strstr(buffer, "GET /not_modified"))
2361 {
2362 if (strstr(buffer, "If-Modified-Since:")) send(c, notmodified, sizeof notmodified - 1, 0);
2363 else send(c, notokmsg, sizeof(notokmsg) - 1, 0);
2364 continue;
2365 }
2366 if (strstr(buffer, "HEAD /head"))
2367 {
2368 send(c, headmsg, sizeof headmsg - 1, 0);
2369 continue;
2370 }
2371 if (strstr(buffer, "GET /multiauth"))
2372 {
2373 send(c, multiauth, sizeof multiauth - 1, 0);
2374 }
2375 if (strstr(buffer, "GET /largeauth"))
2376 {
2377 if (strstr(buffer, "Authorization: NTLM"))
2378 send(c, okmsg, sizeof(okmsg) - 1, 0);
2379 else
2380 {
2381 send(c, largeauth, sizeof largeauth - 1, 0);
2382#ifdef __REACTOS__
2383 memset(buffer, 'A', sizeof(buffer));
2384 for (i = 0; i < (10240 / sizeof(buffer)); i++) send(c, buffer, sizeof(buffer), 0);
2385#else
2386 for (i = 0; i < 10240; i++) send(c, "A", 1, 0);
2387#endif
2388 continue;
2389 }
2390 }
2391 if (strstr(buffer, "GET /cookie5"))
2392 {
2393 if (strstr(buffer, "Cookie: name2=value\r\n"))
2394 send(c, okmsg, sizeof(okmsg) - 1, 0);
2395 else
2396 send(c, notokmsg, sizeof(notokmsg) - 1, 0);
2397 }
2398 if (strstr(buffer, "GET /cookie4"))
2399 {
2400 send(c, cookiemsg2, sizeof(cookiemsg2) - 1, 0);
2401 }
2402 if (strstr(buffer, "GET /cookie3"))
2403 {
2404 if (strstr(buffer, "Cookie: name=value2; NAME=value; name=value\r\n") ||
2405 broken(strstr(buffer, "Cookie: name=value2; name=value; NAME=value\r\n") != NULL))
2406 send(c, okmsg, sizeof(okmsg) - 1, 0);
2407 else
2408 send(c, notokmsg, sizeof(notokmsg) - 1, 0);
2409 }
2410 if (strstr(buffer, "GET /cookie2"))
2411 {
2412 if (strstr(buffer, "Cookie: NAME=value; name=value\r\n") ||
2413 broken(strstr(buffer, "Cookie: name=value; NAME=value\r\n") != NULL))
2414 send(c, okmsg, sizeof(okmsg) - 1, 0);
2415 else
2416 send(c, notokmsg, sizeof(notokmsg) - 1, 0);
2417 }
2418 else if (strstr(buffer, "GET /cookie"))
2419 {
2420 if (!strstr(buffer, "Cookie: name=value\r\n")) send(c, cookiemsg, sizeof(cookiemsg) - 1, 0);
2421 else send(c, notokmsg, sizeof(notokmsg) - 1, 0);
2422 }
2423 else if (strstr(buffer, "GET /escape"))
2424 {
2425 static const char res[] = "%0D%0A%1F%7F%3C%20%one?%1F%7F%20!%22%23$%&'()*+,-./:;%3C=%3E?@%5B%5C%5D"
2426 "%5E_%60%7B%7C%7D~%0D%0A ";
2427 static const char res2[] = "%0D%0A%1F%7F%3C%20%25two?%1F%7F%20!%22%23$%25&'()*+,-./:;%3C=%3E?@%5B%5C%5D"
2428 "%5E_%60%7B%7C%7D~%0D%0A ";
2429 static const char res3[] = "\x1f\x7f<%20%three?\x1f\x7f%20!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
2430 static const char res4[] = "%0D%0A%1F%7F%3C%20%four?\x1f\x7f%20!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
2431 static const char res5[] = "&text=one%C2%80%7F~";
2432 static const char res6[] = "&text=two%C2%80\x7f~";
2433 static const char res7[] = "&text=%E5%90%9B%E3%81%AE%E5%90%8D%E3%81%AF";
2434
2435 if (strstr(buffer + 11, res) || strstr(buffer + 11, res2) || strstr(buffer + 11, res3) ||
2436 strstr(buffer + 11, res4) || strstr(buffer + 11, res5) || strstr(buffer + 11, res6) ||
2437 strstr(buffer + 11, res7))
2438 {
2439 send(c, okmsg, sizeof(okmsg) - 1, 0);
2440 }
2441 else send(c, notokmsg, sizeof(notokmsg) - 1, 0);
2442 }
2443 else if (strstr(buffer, "GET /passport"))
2444 {
2445 send(c, passportauth, sizeof(passportauth) - 1, 0);
2446 }
2447 if (strstr(buffer, "GET /quit"))
2448 {
2449 send(c, okmsg, sizeof okmsg - 1, 0);
2450 send(c, page1, sizeof page1 - 1, 0);
2451 last_request = 1;
2452 }
2453 shutdown(c, 2);
2454 closesocket(c);
2455 c = -1;
2456
2457 } while (!last_request);
2458
2459 closesocket(s);
2460 return 0;
2461}
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
#define msg(x)
Definition: auth_time.c:54
INT WSAAPI recv(IN SOCKET s, OUT CHAR FAR *buf, IN INT len, IN INT flags)
Definition: recv.c:23
INT WSAAPI send(IN SOCKET s, IN CONST CHAR FAR *buf, IN INT len, IN INT flags)
Definition: send.c:23
INT WINAPI WSAStartup(IN WORD wVersionRequested, OUT LPWSADATA lpWSAData)
Definition: startup.c:113
#define SOCK_STREAM
Definition: tcpip.h:118
#define AF_INET
Definition: tcpip.h:117
GLdouble s
Definition: gl.h:2039
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLuint res
Definition: glext.h:9613
GLuint buffer
Definition: glext.h:5915
const GLubyte * c
Definition: glext.h:8905
GLfloat param
Definition: glext.h:5796
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define inet_addr(cp)
Definition: inet.h:98
#define htons(x)
Definition: module.h:215
#define closesocket
Definition: ncftp.h:477
INT WSAAPI setsockopt(IN SOCKET s, IN INT level, IN INT optname, IN CONST CHAR FAR *optval, IN INT optlen)
Definition: sockctrl.c:421
INT WSAAPI listen(IN SOCKET s, IN INT backlog)
Definition: sockctrl.c:123
INT WSAAPI shutdown(IN SOCKET s, IN INT how)
Definition: sockctrl.c:506
INT WSAAPI bind(IN SOCKET s, IN CONST struct sockaddr *name, IN INT namelen)
Definition: socklife.c:36
SOCKET WSAAPI accept(IN SOCKET s, OUT LPSOCKADDR addr, OUT INT FAR *addrlen)
Definition: socklife.c:23
SOCKET WSAAPI socket(IN INT af, IN INT type, IN INT protocol)
Definition: socklife.c:143
HANDLE event
Definition: notification.c:637
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
#define MAKEWORD(a, b)
Definition: typedefs.h:248
static const char auth_unseen[]
Definition: winhttp.c:2261
static const char okmsg[]
Definition: winhttp.c:2182
static const char noauthmsg[]
Definition: winhttp.c:2211
static const char hello_world[]
Definition: winhttp.c:2260
static const char notokmsg[]
Definition: winhttp.c:2187
static const char page1[]
Definition: winhttp.c:2176
static const char cookiemsg2[]
Definition: winhttp.c:2197
static const char headmsg[]
Definition: winhttp.c:2228
static const char unauthorized[]
Definition: winhttp.c:2259
static const char nocontentmsg[]
Definition: winhttp.c:2202
static const char passportauth[]
Definition: winhttp.c:2252
static const char largeauth[]
Definition: winhttp.c:2243
static const char cookiemsg[]
Definition: winhttp.c:2191
#define BIG_BUFFER_LEN
Definition: winhttp.c:2269
static const char okauthmsg[]
Definition: winhttp.c:2220
static const char notmodified[]
Definition: winhttp.c:2207
static const char multiauth[]
Definition: winhttp.c:2233
#define INVALID_SOCKET
Definition: winsock.h:332
UINT_PTR SOCKET
Definition: winsock.h:47
#define SO_REUSEADDR
Definition: winsock.h:180
#define SOL_SOCKET
Definition: winsock.h:398

Referenced by START_TEST().

◆ set_default_proxy_reg_value()

static void set_default_proxy_reg_value ( BYTE buf,
DWORD  len,
DWORD  type 
)
static

Definition at line 1345 of file winhttp.c.

1346{
1347 BOOL wow64;
1349 if (sizeof(void *) > sizeof(int) || wow64)
1350 {
1353 }
1354 else
1356}
#define GetCurrentProcess()
Definition: compat.h:759
#define IsWow64Process
Definition: compat.h:760
#define KEY_WRITE
Definition: nt_native.h:1031
static BOOL wow64
Definition: psapi_main.c:44
static void set_proxy(REGSAM access, BYTE *buf, DWORD len, DWORD type)
Definition: winhttp.c:1334
#define KEY_WOW64_32KEY
Definition: cmtypes.h:45
#define KEY_WOW64_64KEY
Definition: cmtypes.h:46

Referenced by test_set_default_proxy_config().

◆ set_proxy()

static void set_proxy ( REGSAM  access,
BYTE buf,
DWORD  len,
DWORD  type 
)
static

Definition at line 1334 of file winhttp.c.

1335{
1336 HKEY hkey;
1338 {
1339 if (len) RegSetValueExW( hkey, WinHttpSettings, 0, type, buf, len );
1340 else RegDeleteValueW( hkey, WinHttpSettings );
1341 RegCloseKey( hkey );
1342 }
1343}
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1096
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
Definition: reg.c:2330
GLuint GLint GLboolean GLint GLenum access
Definition: glext.h:7866

Referenced by set_default_proxy_reg_value().

◆ START_TEST()

START_TEST ( winhttp  )

Definition at line 4840 of file winhttp.c.

4841{
4842 static const WCHAR basicW[] = {'/','b','a','s','i','c',0};
4843 static const WCHAR quitW[] = {'/','q','u','i','t',0};
4844 struct server_info si;
4845 HANDLE thread;
4846 DWORD ret;
4847
4858 test_timeouts();
4866
4867 si.event = CreateEventW(NULL, 0, 0, NULL);
4868 si.port = 7532;
4869
4870 thread = CreateThread(NULL, 0, server_thread, &si, 0, NULL);
4871 ok(thread != NULL, "failed to create thread %u\n", GetLastError());
4872
4873 ret = WaitForSingleObject(si.event, 10000);
4874 ok(ret == WAIT_OBJECT_0, "failed to start winhttp test server %u\n", GetLastError());
4875 if (ret != WAIT_OBJECT_0)
4876 {
4878 return;
4879 }
4880
4881 test_IWinHttpRequest(si.port);
4882 test_connection_info(si.port);
4883 test_basic_request(si.port, NULL, basicW);
4884 test_no_headers(si.port);
4885 test_no_content(si.port);
4886 test_head_request(si.port);
4887 test_not_modified(si.port);
4891 test_bad_header(si.port);
4892#ifdef __REACTOS__
4894 {
4895 skip("Skipping tests due to hang. See ROSTESTS-350\n");
4896 }
4897 else
4898 {
4899 test_multiple_reads(si.port);
4900 test_cookies(si.port);
4902 test_passport_auth(si.port);
4903
4904 /* send the basic request again to shutdown the server thread */
4905 test_basic_request(si.port, NULL, quitW);
4906 }
4907#else
4908 test_multiple_reads(si.port);
4909 test_cookies(si.port);
4911 test_passport_auth(si.port);
4912
4913 /* send the basic request again to shutdown the server thread */
4914 test_basic_request(si.port, NULL, quitW);
4915#endif
4916
4919}
#define skip(...)
Definition: atltest.h:64
static HANDLE thread
Definition: service.c:33
#define CloseHandle
Definition: compat.h:739
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
static const WCHAR basicW[]
int winetest_interactive
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
#define WAIT_OBJECT_0
Definition: winbase.h:406
static void test_WinHttpSendRequest(void)
Definition: winhttp.c:365
static void test_WinHttpDetectAutoProxyConfigUrl(void)
Definition: winhttp.c:4562
static void test_bad_header(int port)
Definition: winhttp.c:3174
static void test_IWinHttpRequest(int port)
Definition: winhttp.c:3746
static DWORD CALLBACK server_thread(LPVOID param)
Definition: winhttp.c:2271
static void test_multiple_reads(int port)
Definition: winhttp.c:3212
static void test_no_content(int port)
Definition: winhttp.c:2974
static void test_no_headers(int port)
Definition: winhttp.c:2938
static void test_credentials(void)
Definition: winhttp.c:3625
static void test_cookies(int port)
Definition: winhttp.c:3266
static void test_set_default_proxy_config(void)
Definition: winhttp.c:1358
static void test_WinHttpOpenRequest(void)
Definition: winhttp.c:270
static void test_resolve_timeout(void)
Definition: winhttp.c:2104
static void test_secure_connection(void)
Definition: winhttp.c:1048
static void test_WinHttpGetIEProxyConfigForCurrentUser(void)
Definition: winhttp.c:4619
static void test_WinHttpAddHeaders(void)
Definition: winhttp.c:556
static void test_basic_authentication(int port)
Definition: winhttp.c:2555
static void test_basic_request(int port, const WCHAR *verb, const WCHAR *path)
Definition: winhttp.c:2463
static void test_request_parameter_defaults(void)
Definition: winhttp.c:1222
static void test_multi_authentication(int port)
Definition: winhttp.c:2832
static void test_IWinHttpRequest_Invoke(void)
Definition: winhttp.c:4347
static void test_empty_headers_param(void)
Definition: winhttp.c:334
static void test_WinHttpTimeToSystemTime(void)
Definition: winhttp.c:514
static void test_head_request(int port)
Definition: winhttp.c:3058
static void test_not_modified(int port)
Definition: winhttp.c:3117
static void test_WinHttpQueryOption(void)
Definition: winhttp.c:84
static void test_connection_info(int port)
Definition: winhttp.c:3495
static void test_request_path_escapes(int port)
Definition: winhttp.c:3451
static void test_WinHttpGetProxyForUrl(void)
Definition: winhttp.c:4648
static void test_passport_auth(int port)
Definition: winhttp.c:3554
static void test_chunked_read(void)
Definition: winhttp.c:4755
static void test_WinHttpTimeFromSystemTime(void)
Definition: winhttp.c:483
static void test_large_data_authentication(int port)
Definition: winhttp.c:2887
static void test_timeouts(void)
Definition: winhttp.c:1446

◆ strcmp_wa()

static int strcmp_wa ( const WCHAR str1,
const char stra 
)
static

Definition at line 54 of file winhttp.c.

55{
56 WCHAR *str2 = a2w(stra);
57 int r = lstrcmpW(str1, str2);
58 heap_free(str2);
59 return r;
60}
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
static WCHAR * a2w(const char *str)
Definition: winhttp.c:46

Referenced by test_multi_authentication().

◆ test_bad_header()

static void test_bad_header ( int  port)
static

Definition at line 3174 of file winhttp.c.

3175{
3176 static const WCHAR bad_headerW[] =
3177 {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',
3178 't','e','x','t','/','h','t','m','l','\n','\r',0};
3179 static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
3180 static const WCHAR content_typeW[] = {'C','o','n','t','e','n','t','-','T','y','p','e',0};
3181 WCHAR buffer[32];
3182 HINTERNET ses, con, req;
3183 DWORD index, len;
3184 BOOL ret;
3185
3187 ok( ses != NULL, "failed to open session %u\n", GetLastError() );
3188
3189 con = WinHttpConnect( ses, localhostW, port, 0 );
3190 ok( con != NULL, "failed to open a connection %u\n", GetLastError() );
3191
3192 req = WinHttpOpenRequest( con, NULL, NULL, NULL, NULL, NULL, 0 );
3193 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3194
3195 ret = WinHttpAddRequestHeaders( req, bad_headerW, ~0u, WINHTTP_ADDREQ_FLAG_ADD );
3196 ok( ret, "failed to add header %u\n", GetLastError() );
3197
3198 index = 0;
3199 buffer[0] = 0;
3200 len = sizeof(buffer);
3202 content_typeW, buffer, &len, &index );
3203 ok( ret, "failed to query headers %u\n", GetLastError() );
3204 ok( !lstrcmpW( buffer, text_htmlW ), "got %s\n", wine_dbgstr_w(buffer) );
3205 ok( index == 1, "index = %u\n", index );
3206
3207 WinHttpCloseHandle( req );
3208 WinHttpCloseHandle( con );
3209 WinHttpCloseHandle( ses );
3210}
#define index(s, c)
Definition: various.h:29
USHORT port
Definition: uri.c:228
HINTERNET WINAPI WinHttpOpen(LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags)
Definition: session.c:250
HINTERNET WINAPI WinHttpConnect(HINTERNET hsession, LPCWSTR server, INTERNET_PORT port, DWORD reserved)
Definition: session.c:541
GLuint index
Definition: glext.h:6031
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
static const WCHAR text_htmlW[]
Definition: navigate.c:29
BOOL WINAPI WinHttpAddRequestHeaders(HINTERNET hrequest, LPCWSTR headers, DWORD len, DWORD flags)
Definition: request.c:542
static const WCHAR test_useragent[]
Definition: winhttp.c:40
static const WCHAR localhostW[]
Definition: winhttp.c:44
#define WINHTTP_QUERY_FLAG_REQUEST_HEADERS
Definition: winhttp.h:375
#define WINHTTP_ADDREQ_FLAG_ADD
Definition: winhttp.h:84
#define WINHTTP_QUERY_CUSTOM
Definition: winhttp.h:374
#define WINHTTP_ACCESS_TYPE_NO_PROXY
Definition: winhttp.h:63

Referenced by START_TEST().

◆ test_basic_authentication()

static void test_basic_authentication ( int  port)
static

Definition at line 2555 of file winhttp.c.

2556{
2557 static const WCHAR authW[] = {'/','a','u','t','h',0};
2558 static const WCHAR auth_with_credsW[] = {'/','a','u','t','h','_','w','i','t','h','_','c','r','e','d','s',0};
2559 static WCHAR userW[] = {'u','s','e','r',0};
2560 static WCHAR passW[] = {'p','w','d',0};
2561 static WCHAR pass2W[] = {'p','w','d','2',0};
2562 HINTERNET ses, con, req;
2563 DWORD status, size, error, supported, first, target;
2564 char buffer[32];
2565 BOOL ret;
2566
2568 ok(ses != NULL, "failed to open session %u\n", GetLastError());
2569
2570 con = WinHttpConnect(ses, localhostW, port, 0);
2571 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
2572
2573 req = WinHttpOpenRequest(con, NULL, authW, NULL, NULL, NULL, 0);
2574 ok(req != NULL, "failed to open a request %u\n", GetLastError());
2575
2576 SetLastError(0xdeadbeef);
2578 error = GetLastError();
2579 ok(!ret, "expected failure\n");
2580 ok(error == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %u\n", error);
2581
2582 SetLastError(0xdeadbeef);
2584 error = GetLastError();
2585 ok(!ret, "expected failure\n");
2587
2588 supported = 0xdeadbeef;
2589 SetLastError(0xdeadbeef);
2590 ret = WinHttpQueryAuthSchemes(req, &supported, NULL, NULL);
2591 error = GetLastError();
2592 ok(!ret, "expected failure\n");
2594 ok(supported == 0xdeadbeef, "got %x\n", supported);
2595
2596 supported = first = 0xdeadbeef;
2597 SetLastError(0xdeadbeef);
2598 ret = WinHttpQueryAuthSchemes(req, &supported, &first, NULL);
2599 error = GetLastError();
2600 ok(!ret, "expected failure\n");
2602 ok(supported == 0xdeadbeef, "got %x\n", supported);
2603 ok(first == 0xdeadbeef, "got %x\n", first);
2604
2605 supported = first = target = 0xdeadbeef;
2606 SetLastError(0xdeadbeef);
2607 ret = WinHttpQueryAuthSchemes(req, &supported, &first, &target);
2608 error = GetLastError();
2609 ok(!ret, "expected failure\n");
2610 ok(error == ERROR_INVALID_OPERATION, "expected ERROR_INVALID_OPERATION, got %u\n", error);
2611 ok(supported == 0xdeadbeef, "got %x\n", supported);
2612 ok(first == 0xdeadbeef, "got %x\n", first);
2613 ok(target == 0xdeadbeef, "got %x\n", target);
2614
2615 supported = first = target = 0xdeadbeef;
2616 SetLastError(0xdeadbeef);
2617 ret = WinHttpQueryAuthSchemes(NULL, &supported, &first, &target);
2618 error = GetLastError();
2619 ok(!ret, "expected failure\n");
2620 ok(error == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %u\n", error);
2621 ok(supported == 0xdeadbeef, "got %x\n", supported);
2622 ok(first == 0xdeadbeef, "got %x\n", first);
2623 ok(target == 0xdeadbeef, "got %x\n", target);
2624
2625 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
2626 ok(ret, "failed to send request %u\n", GetLastError());
2627
2629 ok(ret, "failed to receive response %u\n", GetLastError());
2630
2631 status = 0xdeadbeef;
2632 size = sizeof(status);
2634 ok(ret, "failed to query status code %u\n", GetLastError());
2635 ok(status == HTTP_STATUS_DENIED, "request failed unexpectedly %u\n", status);
2636
2637 size = 0;
2638 ret = WinHttpReadData(req, buffer, sizeof(buffer), &size);
2639 error = GetLastError();
2640 ok(ret || broken(error == ERROR_WINHTTP_SHUTDOWN || error == ERROR_WINHTTP_TIMEOUT) /* XP */, "failed to read data %u\n", GetLastError());
2641 if (ret)
2642 {
2643 ok(size == 12, "expected 12, got %u\n", size);
2644 ok(!memcmp(buffer, unauthorized, 12), "got %s\n", buffer);
2645 }
2646
2647 supported = first = target = 0xdeadbeef;
2648 SetLastError(0xdeadbeef);
2649 ret = WinHttpQueryAuthSchemes(req, &supported, &first, &target);
2650 error = GetLastError();
2651 ok(ret, "failed to query authentication schemes %u\n", error);
2652 ok(error == ERROR_SUCCESS || broken(error == 0xdeadbeef) /* < win7 */, "expected ERROR_SUCCESS, got %u\n", error);
2653 ok(supported == WINHTTP_AUTH_SCHEME_BASIC, "got %x\n", supported);
2654 ok(first == WINHTTP_AUTH_SCHEME_BASIC, "got %x\n", first);
2655 ok(target == WINHTTP_AUTH_TARGET_SERVER, "got %x\n", target);
2656
2657 SetLastError(0xdeadbeef);
2659 error = GetLastError();
2660 ok(ret, "failed to set credentials %u\n", error);
2661 ok(error == ERROR_SUCCESS || broken(error == 0xdeadbeef) /* < win7 */, "expected ERROR_SUCCESS, got %u\n", error);
2662
2664 ok(ret, "failed to set credentials %u\n", GetLastError());
2665
2667 ok(ret, "failed to set credentials %u\n", GetLastError());
2668
2669 SetLastError(0xdeadbeef);
2671 error = GetLastError();
2672 ok(!ret, "expected failure\n");
2673 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2674
2675 SetLastError(0xdeadbeef);
2677 error = GetLastError();
2678 ok(!ret, "expected failure\n");
2679 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2680
2681 SetLastError(0xdeadbeef);
2683 error = GetLastError();
2684 ok(!ret, "expected failure\n");
2685 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2686
2687 SetLastError(0xdeadbeef);
2689 error = GetLastError();
2690 ok(!ret, "expected failure\n");
2691 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2692
2694 ok(ret, "failed to set credentials %u\n", GetLastError());
2695
2696 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
2697 ok(ret, "failed to send request %u\n", GetLastError());
2698
2700 ok(ret, "failed to receive response %u\n", GetLastError());
2701
2702 status = 0xdeadbeef;
2703 size = sizeof(status);
2705 ok(ret, "failed to query status code %u\n", GetLastError());
2706 ok(status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status);
2707
2708 size = 0;
2709 ret = WinHttpReadData(req, buffer, sizeof(buffer), &size);
2710 error = GetLastError();
2711 ok(ret || broken(error == ERROR_WINHTTP_SHUTDOWN || error == ERROR_WINHTTP_TIMEOUT) /* XP */, "failed to read data %u\n", GetLastError());
2712 if (ret)
2713 {
2714 ok(size == 11, "expected 11, got %u\n", size);
2715 ok(!memcmp(buffer, hello_world, 11), "got %s\n", buffer);
2716 }
2717
2718 WinHttpCloseHandle(req);
2719 WinHttpCloseHandle(con);
2720 WinHttpCloseHandle(ses);
2721
2722 /* now set the credentials first to show that they get sent with the first request */
2724 ok(ses != NULL, "failed to open session %u\n", GetLastError());
2725
2726 con = WinHttpConnect(ses, localhostW, port, 0);
2727 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
2728
2729 req = WinHttpOpenRequest(con, NULL, auth_with_credsW, NULL, NULL, NULL, 0);
2730 ok(req != NULL, "failed to open a request %u\n", GetLastError());
2731
2733 ok(ret, "failed to set credentials %u\n", GetLastError());
2734
2735 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
2736 ok(ret, "failed to send request %u\n", GetLastError());
2737
2739 ok(ret, "failed to receive response %u\n", GetLastError());
2740
2741 status = 0xdeadbeef;
2742 size = sizeof(status);
2744 ok(ret, "failed to query status code %u\n", GetLastError());
2745 ok(status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status);
2746
2747 size = 0;
2748 ret = WinHttpReadData(req, buffer, sizeof(buffer), &size);
2749 error = GetLastError();
2750 ok(ret || broken(error == ERROR_WINHTTP_SHUTDOWN || error == ERROR_WINHTTP_TIMEOUT) /* XP */, "failed to read data %u\n", GetLastError());
2751 if (ret)
2752 {
2753 ok(size == 11, "expected 11, got %u\n", size);
2754 ok(!memcmp(buffer, hello_world, 11), "got %s\n", buffer);
2755 }
2756
2757 WinHttpCloseHandle(req);
2758 WinHttpCloseHandle(con);
2759 WinHttpCloseHandle(ses);
2760
2761 /* credentials set with WinHttpSetCredentials take precedence over those set through options */
2762
2764 ok(ses != NULL, "failed to open session %u\n", GetLastError());
2765
2766 con = WinHttpConnect(ses, localhostW, port, 0);
2767 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
2768
2769 req = WinHttpOpenRequest(con, NULL, authW, NULL, NULL, NULL, 0);
2770 ok(req != NULL, "failed to open a request %u\n", GetLastError());
2771
2773 ok(ret, "failed to set credentials %u\n", GetLastError());
2774
2776 ok(ret, "failed to set username %u\n", GetLastError());
2777
2778 ret = WinHttpSetOption(req, WINHTTP_OPTION_PASSWORD, pass2W, lstrlenW(pass2W));
2779 ok(ret, "failed to set password %u\n", GetLastError());
2780
2781 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
2782 ok(ret, "failed to send request %u\n", GetLastError());
2783
2785 ok(ret, "failed to receive response %u\n", GetLastError());
2786
2787 status = 0xdeadbeef;
2788 size = sizeof(status);
2790 ok(ret, "failed to query status code %u\n", GetLastError());
2791 ok(status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status);
2792
2793 WinHttpCloseHandle(req);
2794 WinHttpCloseHandle(con);
2795 WinHttpCloseHandle(ses);
2796
2798 ok(ses != NULL, "failed to open session %u\n", GetLastError());
2799
2800 con = WinHttpConnect(ses, localhostW, port, 0);
2801 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
2802
2803 req = WinHttpOpenRequest(con, NULL, authW, NULL, NULL, NULL, 0);
2804 ok(req != NULL, "failed to open a request %u\n", GetLastError());
2805
2807 ok(ret, "failed to set username %u\n", GetLastError());
2808
2810 ok(ret, "failed to set password %u\n", GetLastError());
2811
2813 ok(ret, "failed to set credentials %u\n", GetLastError());
2814
2815 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
2816 ok(ret, "failed to send request %u\n", GetLastError());
2817
2819 ok(ret, "failed to receive response %u\n", GetLastError());
2820
2821 status = 0xdeadbeef;
2822 size = sizeof(status);
2824 ok(ret, "failed to query status code %u\n", GetLastError());
2825 ok(status == HTTP_STATUS_DENIED, "request failed unexpectedly %u\n", status);
2826
2827 WinHttpCloseHandle(req);
2828 WinHttpCloseHandle(con);
2829 WinHttpCloseHandle(ses);
2830}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define lstrlenW
Definition: compat.h:750
BOOL WINAPI WinHttpSetOption(HINTERNET handle, DWORD option, LPVOID buffer, DWORD buflen)
Definition: session.c:1312
const GLint * first
Definition: glext.h:5794
GLenum target
Definition: glext.h:7315
#define error(str)
Definition: mkdosfs.c:1605
BOOL WINAPI WinHttpReadData(HINTERNET hrequest, LPVOID buffer, DWORD to_read, LPDWORD read)
Definition: request.c:3053
BOOL WINAPI WinHttpSetCredentials(HINTERNET hrequest, DWORD target, DWORD scheme, LPCWSTR username, LPCWSTR password, LPVOID params)
Definition: request.c:2442
BOOL WINAPI WinHttpQueryAuthSchemes(HINTERNET hrequest, LPDWORD supported, LPDWORD first, LPDWORD target)
Definition: request.c:964
#define ERROR_INVALID_OPERATION
Definition: winerror.h:1261
#define WINHTTP_OPTION_USERNAME
Definition: winhttp.h:145
#define WINHTTP_AUTH_SCHEME_BASIC
Definition: winhttp.h:452
#define WINHTTP_AUTH_SCHEME_PASSPORT
Definition: winhttp.h:454
#define WINHTTP_OPTION_PASSWORD
Definition: winhttp.h:146
#define WINHTTP_AUTH_SCHEME_NEGOTIATE
Definition: winhttp.h:456
#define WINHTTP_AUTH_TARGET_SERVER
Definition: winhttp.h:458
#define WINHTTP_AUTH_SCHEME_DIGEST
Definition: winhttp.h:455
#define HTTP_STATUS_DENIED
Definition: winhttp.h:256
#define ERROR_WINHTTP_TIMEOUT
Definition: winhttp.h:189
#define ERROR_WINHTTP_SHUTDOWN
Definition: winhttp.h:196
#define WINHTTP_AUTH_SCHEME_NTLM
Definition: winhttp.h:453

Referenced by START_TEST().

◆ test_basic_request()

static void test_basic_request ( int  port,
const WCHAR verb,
const WCHAR path 
)
static

Definition at line 2463 of file winhttp.c.

2464{
2465 static const WCHAR test_header_end_clrf[] = {'\r','\n','\r','\n',0};
2466 static const WCHAR test_header_end_raw[] = {0,0};
2467 HINTERNET ses, con, req;
2468 char buffer[0x100];
2469 WCHAR buffer2[0x100];
2470 DWORD count, status, size, error, supported, first, target;
2471 BOOL ret;
2472
2474 ok(ses != NULL, "failed to open session %u\n", GetLastError());
2475
2476 SetLastError(0xdeadbeef);
2477 ret = WinHttpSetOption(ses, 0, buffer, sizeof(buffer));
2479
2480 SetLastError(0xdeadbeef);
2481 ret = WinHttpQueryOption(ses, 0, buffer, &size);
2482 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %u\n", GetLastError());
2483
2484 con = WinHttpConnect(ses, localhostW, port, 0);
2485 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
2486
2487 SetLastError(0xdeadbeef);
2488 ret = WinHttpSetOption(con, 0, buffer, sizeof(buffer));
2490
2491 SetLastError(0xdeadbeef);
2492 ret = WinHttpQueryOption(con, 0, buffer, &size);
2493 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %u\n", GetLastError());
2494
2495 req = WinHttpOpenRequest(con, verb, path, NULL, NULL, NULL, 0);
2496 ok(req != NULL, "failed to open a request %u\n", GetLastError());
2497
2498 SetLastError(0xdeadbeef);
2499 ret = WinHttpSetOption(req, 0, buffer, sizeof(buffer));
2501
2502 SetLastError(0xdeadbeef);
2503 ret = WinHttpQueryOption(req, 0, buffer, &size);
2504 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %u\n", GetLastError());
2505
2506 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
2507 ok(ret, "failed to send request %u\n", GetLastError());
2508
2510 ok(ret, "failed to receive response %u\n", GetLastError());
2511
2512 status = 0xdeadbeef;
2513 size = sizeof(status);
2515 ok(ret, "failed to query status code %u\n", GetLastError());
2516 ok(status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status);
2517
2518 supported = first = target = 0xdeadbeef;
2519 SetLastError(0xdeadbeef);
2520 ret = WinHttpQueryAuthSchemes(req, &supported, &first, &target);
2521 error = GetLastError();
2522 ok(!ret, "unexpected success\n");
2523 ok(error == ERROR_INVALID_OPERATION, "expected ERROR_INVALID_OPERATION, got %u\n", error);
2524 ok(supported == 0xdeadbeef, "got %x\n", supported);
2525 ok(first == 0xdeadbeef, "got %x\n", first);
2526 ok(target == 0xdeadbeef, "got %x\n", target);
2527
2528 size = sizeof(buffer2);
2529 memset(buffer2, 0, sizeof(buffer2));
2531 ok(ret, "failed to query for raw headers: %u\n", GetLastError());
2532 ok(!memcmp(buffer2 + lstrlenW(buffer2) - 4, test_header_end_clrf, sizeof(test_header_end_clrf)),
2533 "WinHttpQueryHeaders returned invalid end of header string\n");
2534
2535 size = sizeof(buffer2);
2536 memset(buffer2, 0, sizeof(buffer2));
2538 ok(ret, "failed to query for raw headers: %u\n", GetLastError());
2539 ok(!memcmp(buffer2 + (size / sizeof(WCHAR)) - 1, test_header_end_raw, sizeof(test_header_end_raw)),
2540 "WinHttpQueryHeaders returned invalid end of header string\n");
2541 ok(buffer2[(size / sizeof(WCHAR)) - 2] != 0, "returned string has too many NULL characters\n");
2542
2543 count = 0;
2544 memset(buffer, 0, sizeof(buffer));
2545 ret = WinHttpReadData(req, buffer, sizeof buffer, &count);
2546 ok(ret, "failed to read data %u\n", GetLastError());
2547 ok(count == sizeof page1 - 1, "count was wrong\n");
2548 ok(!memcmp(buffer, page1, sizeof page1), "http data wrong\n");
2549
2550 WinHttpCloseHandle(req);
2551 WinHttpCloseHandle(con);
2552 WinHttpCloseHandle(ses);
2553}
BOOL WINAPI WinHttpQueryOption(HINTERNET handle, DWORD option, LPVOID buffer, LPDWORD buflen)
Definition: session.c:1253
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define todo_wine
Definition: custom.c:79
#define ERROR_WINHTTP_INVALID_OPTION
Definition: winhttp.h:194
#define WINHTTP_QUERY_RAW_HEADERS_CRLF
Definition: winhttp.h:320
#define WINHTTP_QUERY_RAW_HEADERS
Definition: winhttp.h:319

Referenced by START_TEST().

◆ test_chunked_read()

static void test_chunked_read ( void  )
static

Definition at line 4755 of file winhttp.c.

4756{
4757 static const WCHAR verb[] = {'/','t','e','s','t','s','/','c','h','u','n','k','e','d',0};
4758 static const WCHAR chunked[] = {'c','h','u','n','k','e','d',0};
4759 WCHAR header[32];
4760 DWORD len, err;
4761 HINTERNET ses, con = NULL, req = NULL;
4762 BOOL ret;
4763
4764 trace( "starting chunked read test\n" );
4765
4766 ses = WinHttpOpen( test_useragent, 0, NULL, NULL, 0 );
4767 ok( ses != NULL, "WinHttpOpen failed with error %u\n", GetLastError() );
4768 if (!ses) goto done;
4769
4770 con = WinHttpConnect( ses, test_winehq, 0, 0 );
4771 ok( con != NULL, "WinHttpConnect failed with error %u\n", GetLastError() );
4772 if (!con) goto done;
4773
4774 req = WinHttpOpenRequest( con, NULL, verb, NULL, NULL, NULL, 0 );
4775 ok( req != NULL, "WinHttpOpenRequest failed with error %u\n", GetLastError() );
4776 if (!req) goto done;
4777
4778 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
4779 err = GetLastError();
4781 {
4782 skip("connection failed, skipping\n");
4783 goto done;
4784 }
4785 ok( ret, "WinHttpSendRequest failed with error %u\n", GetLastError() );
4786 if (!ret) goto done;
4787
4789 ok( ret, "WinHttpReceiveResponse failed with error %u\n", GetLastError() );
4790 if (!ret) goto done;
4791
4792 header[0] = 0;
4793 len = sizeof(header);
4795 ok( ret, "failed to get TRANSFER_ENCODING header (error %u)\n", GetLastError() );
4796 ok( !lstrcmpW( header, chunked ), "wrong transfer encoding %s\n", wine_dbgstr_w(header) );
4797 trace( "transfer encoding: %s\n", wine_dbgstr_w(header) );
4798
4799 header[0] = 0;
4800 len = sizeof(header);
4801 SetLastError( 0xdeadbeef );
4803 ok( !ret, "unexpected CONTENT_LENGTH header %s\n", wine_dbgstr_w(header) );
4804 ok( GetLastError() == ERROR_WINHTTP_HEADER_NOT_FOUND, "wrong error %u\n", GetLastError() );
4805
4806 trace( "entering query loop\n" );
4807 for (;;)
4808 {
4809 len = 0xdeadbeef;
4811 ok( ret, "WinHttpQueryDataAvailable failed with error %u\n", GetLastError() );
4812 if (ret) ok( len != 0xdeadbeef, "WinHttpQueryDataAvailable return wrong length\n" );
4813 trace( "got %u available\n", len );
4814 if (len)
4815 {
4816 DWORD bytes_read;
4817 char *buf = HeapAlloc( GetProcessHeap(), 0, len + 1 );
4818
4819 ret = WinHttpReadData( req, buf, len, &bytes_read );
4820 ok(ret, "WinHttpReadData failed: %u.\n", GetLastError());
4821
4822 buf[bytes_read] = 0;
4823 trace( "WinHttpReadData -> %d %u\n", ret, bytes_read );
4824 ok( len == bytes_read, "only got %u of %u available\n", bytes_read, len );
4825 ok( buf[bytes_read - 1] == '\n', "received partial line '%s'\n", buf );
4826
4827 HeapFree( GetProcessHeap(), 0, buf );
4828 if (!bytes_read) break;
4829 }
4830 if (!len) break;
4831 }
4832 trace( "done\n" );
4833
4834done:
4835 if (req) WinHttpCloseHandle( req );
4836 if (con) WinHttpCloseHandle( con );
4837 if (ses) WinHttpCloseHandle( ses );
4838}
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define err(...)
BOOL WINAPI WinHttpQueryDataAvailable(HINTERNET hrequest, LPDWORD available)
Definition: request.c:3005
static const WCHAR test_winehq[]
Definition: winhttp.c:42
#define WINHTTP_QUERY_CONTENT_LENGTH
Definition: winhttp.h:303
#define ERROR_WINHTTP_CANNOT_CONNECT
Definition: winhttp.h:201
#define ERROR_WINHTTP_HEADER_NOT_FOUND
Definition: winhttp.h:213
#define WINHTTP_QUERY_TRANSFER_ENCODING
Definition: winhttp.h:361

Referenced by START_TEST().

◆ test_connection_info()

static void test_connection_info ( int  port)
static

Definition at line 3495 of file winhttp.c.

3496{
3497 static const WCHAR basicW[] = {'/','b','a','s','i','c',0};
3498 HINTERNET ses, con, req;
3499 WINHTTP_CONNECTION_INFO info;
3500 DWORD size, error;
3501 BOOL ret;
3502
3504 ok( ses != NULL, "failed to open session %u\n", GetLastError() );
3505
3506 con = WinHttpConnect( ses, localhostW, port, 0 );
3507 ok( con != NULL, "failed to open a connection %u\n", GetLastError() );
3508
3509 req = WinHttpOpenRequest( con, NULL, basicW, NULL, NULL, NULL, 0 );
3510 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3511
3512 size = sizeof(info);
3513 SetLastError( 0xdeadbeef );
3515 error = GetLastError();
3517 {
3518 win_skip( "WINHTTP_OPTION_CONNECTION_INFO not supported\n" );
3519 return;
3520 }
3521 ok( !ret, "unexpected success\n" );
3523
3524 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
3525 ok( ret, "failed to send request %u\n", GetLastError() );
3526
3527 size = 0;
3528 SetLastError( 0xdeadbeef );
3530 error = GetLastError();
3531 ok( !ret, "unexpected success\n" );
3532 ok( error == ERROR_INSUFFICIENT_BUFFER, "got %u\n", error );
3533
3534 size = sizeof(info);
3535 memset( &info, 0, sizeof(info) );
3537 ok( ret, "failed to retrieve connection info %u\n", GetLastError() );
3538 ok( info.cbSize == sizeof(info) || info.cbSize == sizeof(info) - sizeof(info.cbSize) /* Win7 */, "wrong size %u\n", info.cbSize );
3539
3541 ok( ret, "failed to receive response %u\n", GetLastError() );
3542
3543 size = sizeof(info);
3544 memset( &info, 0, sizeof(info) );
3546 ok( ret, "failed to retrieve connection info %u\n", GetLastError() );
3547 ok( info.cbSize == sizeof(info) || info.cbSize == sizeof(info) - sizeof(info.cbSize) /* Win7 */, "wrong size %u\n", info.cbSize );
3548
3549 WinHttpCloseHandle( req );
3550 WinHttpCloseHandle( con );
3551 WinHttpCloseHandle( ses );
3552}
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define win_skip
Definition: test.h:160
#define WINHTTP_OPTION_CONNECTION_INFO
Definition: winhttp.h:136
#define ERROR_WINHTTP_INCORRECT_HANDLE_STATE
Definition: winhttp.h:200

Referenced by START_TEST().

◆ test_cookies()

static void test_cookies ( int  port)
static

Definition at line 3266 of file winhttp.c.

3267{
3268 static const WCHAR cookieW[] = {'/','c','o','o','k','i','e',0};
3269 static const WCHAR cookie2W[] = {'/','c','o','o','k','i','e','2',0};
3270 static const WCHAR cookie3W[] = {'/','c','o','o','k','i','e','3',0};
3271 static const WCHAR cookie4W[] = {'/','c','o','o','k','i','e','4',0};
3272 static const WCHAR cookie5W[] = {'/','c','o','o','k','i','e','5',0};
3273 static const WCHAR cookieheaderW[] =
3274 {'C','o','o','k','i','e',':',' ','n','a','m','e','=','v','a','l','u','e','2','\r','\n',0};
3275 HINTERNET ses, con, req;
3276 DWORD status, size;
3277 BOOL ret;
3278
3280 ok( ses != NULL, "failed to open session %u\n", GetLastError() );
3281
3282 con = WinHttpConnect( ses, localhostW, port, 0 );
3283 ok( con != NULL, "failed to open a connection %u\n", GetLastError() );
3284
3285 req = WinHttpOpenRequest( con, NULL, cookieW, NULL, NULL, NULL, 0 );
3286 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3287
3288 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
3289 ok( ret, "failed to send request %u\n", GetLastError() );
3290
3292 ok( ret, "failed to receive response %u\n", GetLastError() );
3293
3294 status = 0xdeadbeef;
3295 size = sizeof(status);
3297 ok( ret, "failed to query status code %u\n", GetLastError() );
3298 ok( status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status );
3299
3300 WinHttpCloseHandle( req );
3301
3302 req = WinHttpOpenRequest( con, NULL, cookie2W, NULL, NULL, NULL, 0 );
3303 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3304
3305 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
3306 ok( ret, "failed to send request %u\n", GetLastError() );
3307
3309 ok( ret, "failed to receive response %u\n", GetLastError() );
3310
3311 status = 0xdeadbeef;
3312 size = sizeof(status);
3314 ok( ret, "failed to query status code %u\n", GetLastError() );
3315 ok( status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status );
3316
3317 WinHttpCloseHandle( req );
3318 WinHttpCloseHandle( con );
3319
3320 con = WinHttpConnect( ses, localhostW, port, 0 );
3321 ok( con != NULL, "failed to open a connection %u\n", GetLastError() );
3322
3323 req = WinHttpOpenRequest( con, NULL, cookie2W, NULL, NULL, NULL, 0 );
3324 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3325
3326 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
3327 ok( ret, "failed to send request %u\n", GetLastError() );
3328
3330 ok( ret, "failed to receive response %u\n", GetLastError() );
3331
3332 status = 0xdeadbeef;
3333 size = sizeof(status);
3335 ok( ret, "failed to query status code %u\n", GetLastError() );
3336 ok( status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status );
3337
3338 WinHttpCloseHandle( req );
3339
3340 req = WinHttpOpenRequest( con, NULL, cookie3W, NULL, NULL, NULL, 0 );
3341 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3342
3343 ret = WinHttpSendRequest( req, cookieheaderW, ~0u, NULL, 0, 0, 0 );
3344 ok( ret, "failed to send request %u\n", GetLastError() );
3345
3347 ok( ret, "failed to receive response %u\n", GetLastError() );
3348
3349 status = 0xdeadbeef;
3350 size = sizeof(status);
3352 ok( ret, "failed to query status code %u\n", GetLastError() );
3353 ok( status == HTTP_STATUS_OK || broken(status == HTTP_STATUS_BAD_REQUEST), "request failed unexpectedly %u\n", status );
3354
3355 WinHttpCloseHandle( req );
3356 WinHttpCloseHandle( con );
3357 WinHttpCloseHandle( ses );
3358
3360 ok( ses != NULL, "failed to open session %u\n", GetLastError() );
3361
3362 con = WinHttpConnect( ses, localhostW, port, 0 );
3363 ok( con != NULL, "failed to open a connection %u\n", GetLastError() );
3364
3365 req = WinHttpOpenRequest( con, NULL, cookie2W, NULL, NULL, NULL, 0 );
3366 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3367
3368 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
3369 ok( ret, "failed to send request %u\n", GetLastError() );
3370
3372 ok( ret, "failed to receive response %u\n", GetLastError() );
3373
3374 status = 0xdeadbeef;
3375 size = sizeof(status);
3377 ok( ret, "failed to query status code %u\n", GetLastError() );
3378 ok( status == HTTP_STATUS_BAD_REQUEST, "request failed unexpectedly %u\n", status );
3379
3380 WinHttpCloseHandle( req );
3381 WinHttpCloseHandle( con );
3382 WinHttpCloseHandle( ses );
3383
3385 ok( ses != NULL, "failed to open session %u\n", GetLastError() );
3386
3387 con = WinHttpConnect( ses, localhostW, port, 0 );
3388 ok( con != NULL, "failed to open a connection %u\n", GetLastError() );
3389
3390 req = WinHttpOpenRequest( con, NULL, cookie4W, NULL, NULL, NULL, 0 );
3391 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3392
3393 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
3394 ok( ret, "failed to send request %u\n", GetLastError() );
3395
3397 ok( ret, "failed to receive response %u\n", GetLastError() );
3398
3399 status = 0xdeadbeef;
3400 size = sizeof(status);
3402 ok( ret, "failed to query status code %u\n", GetLastError() );
3403 ok( status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status );
3404 WinHttpCloseHandle( req );
3405
3406 req = WinHttpOpenRequest( con, NULL, cookie5W, NULL, NULL, NULL, 0 );
3407 ok( req != NULL, "failed to open a request %u\n", GetLastError() );
3408
3409 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
3410 ok( ret, "failed to send request %u\n", GetLastError() );
3411
3413 ok( ret, "failed to receive response %u\n", GetLastError() );
3414
3415 status = 0xdeadbeef;
3416 size = sizeof(status);
3418 ok( ret, "failed to query status code %u\n", GetLastError() );
3420 "request failed unexpectedly %u\n", status );
3421
3422 WinHttpCloseHandle( req );
3423 WinHttpCloseHandle( con );
3424 WinHttpCloseHandle( ses );
3425}

Referenced by START_TEST().

◆ test_credentials()

static void test_credentials ( void  )
static

Definition at line 3625 of file winhttp.c.

3626{
3627 static WCHAR userW[] = {'u','s','e','r',0};
3628 static WCHAR passW[] = {'p','a','s','s',0};
3629 static WCHAR proxy_userW[] = {'p','r','o','x','y','u','s','e','r',0};
3630 static WCHAR proxy_passW[] = {'p','r','o','x','y','p','a','s','s',0};
3631 HINTERNET ses, con, req;
3632 DWORD size, error;
3633 WCHAR buffer[32];
3634 BOOL ret;
3635
3636 ses = WinHttpOpen(test_useragent, 0, proxy_userW, proxy_passW, 0);
3637 ok(ses != NULL, "failed to open session %u\n", GetLastError());
3638
3639 con = WinHttpConnect(ses, localhostW, 0, 0);
3640 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
3641
3642 req = WinHttpOpenRequest(con, NULL, NULL, NULL, NULL, NULL, 0);
3643 ok(req != NULL, "failed to open a request %u\n", GetLastError());
3644
3647 ok(ret, "failed to query proxy username %u\n", GetLastError());
3648 ok(!buffer[0], "unexpected result %s\n", wine_dbgstr_w(buffer));
3649 ok(!size, "expected 0, got %u\n", size);
3650
3653 ok(ret, "failed to query proxy password %u\n", GetLastError());
3654 ok(!buffer[0], "unexpected result %s\n", wine_dbgstr_w(buffer));
3655 ok(!size, "expected 0, got %u\n", size);
3656
3657 ret = WinHttpSetOption(req, WINHTTP_OPTION_PROXY_USERNAME, proxy_userW, lstrlenW(proxy_userW));
3658 ok(ret, "failed to set username %u\n", GetLastError());
3659
3662 ok(ret, "failed to query proxy username %u\n", GetLastError());
3663 ok(!winetest_strcmpW(buffer, proxy_userW), "unexpected result %s\n", wine_dbgstr_w(buffer));
3664 ok(size == lstrlenW(proxy_userW) * sizeof(WCHAR), "unexpected result %u\n", size);
3665
3668 ok(ret, "failed to query username %u\n", GetLastError());
3669 ok(!buffer[0], "unexpected result %s\n", wine_dbgstr_w(buffer));
3670 ok(!size, "expected 0, got %u\n", size);
3671
3674 ok(ret, "failed to query password %u\n", GetLastError());
3675 ok(!buffer[0], "unexpected result %s\n", wine_dbgstr_w(buffer));
3676 ok(!size, "expected 0, got %u\n", size);
3677
3678 ret = WinHttpSetOption(req, WINHTTP_OPTION_PROXY_PASSWORD, proxy_passW, lstrlenW(proxy_passW));
3679 ok(ret, "failed to set proxy password %u\n", GetLastError());
3680
3683 ok(ret, "failed to query proxy password %u\n", GetLastError());
3684 ok(!winetest_strcmpW(buffer, proxy_passW), "unexpected result %s\n", wine_dbgstr_w(buffer));
3685 ok(size == lstrlenW(proxy_passW) * sizeof(WCHAR), "unexpected result %u\n", size);
3686
3688 ok(ret, "failed to set username %u\n", GetLastError());
3689
3692 ok(ret, "failed to query username %u\n", GetLastError());
3693 ok(!winetest_strcmpW(buffer, userW), "unexpected result %s\n", wine_dbgstr_w(buffer));
3694 ok(size == lstrlenW(userW) * sizeof(WCHAR), "unexpected result %u\n", size);
3695
3697 ok(ret, "failed to set password %u\n", GetLastError());
3698
3701 ok(ret, "failed to query password %u\n", GetLastError());
3702 ok(!winetest_strcmpW(buffer, passW), "unexpected result %s\n", wine_dbgstr_w(buffer));
3703 ok(size == lstrlenW(passW) * sizeof(WCHAR), "unexpected result %u\n", size);
3704
3705 WinHttpCloseHandle(req);
3706
3707 req = WinHttpOpenRequest(con, NULL, NULL, NULL, NULL, NULL, 0);
3708 ok(req != NULL, "failed to open a request %u\n", GetLastError());
3709
3710 SetLastError(0xdeadbeef);
3712 error = GetLastError();
3713 ok(!ret, "expected failure\n");
3714 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
3715
3716 SetLastError(0xdeadbeef);
3718 error = GetLastError();
3719 ok(!ret, "expected failure\n");
3720 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
3721
3723 ok(ret, "failed to set credentials %u\n", GetLastError());
3724
3727 ok(ret, "failed to query username %u\n", GetLastError());
3728 todo_wine {
3729 ok(!buffer[0], "unexpected result %s\n", wine_dbgstr_w(buffer));
3730 ok(!size, "expected 0, got %u\n", size);
3731 }
3732
3735 ok(ret, "failed to query password %u\n", GetLastError());
3736 todo_wine {
3737 ok(!buffer[0], "unexpected result %s\n", wine_dbgstr_w(buffer));
3738 ok(!size, "expected 0, got %u\n", size);
3739 }
3740
3741 WinHttpCloseHandle(req);
3742 WinHttpCloseHandle(con);
3743 WinHttpCloseHandle(ses);
3744}
#define ARRAY_SIZE(A)
Definition: main.h:33
static int winetest_strcmpW(const WCHAR *str1, const WCHAR *str2)
Definition: test.h:94
#define WINHTTP_OPTION_PROXY_PASSWORD
Definition: winhttp.h:148
#define WINHTTP_OPTION_PROXY_USERNAME
Definition: winhttp.h:147

Referenced by START_TEST().

◆ test_empty_headers_param()

static void test_empty_headers_param ( void  )
static

Definition at line 334 of file winhttp.c.

335{
336 static const WCHAR empty[] = {0};
337 HINTERNET ses, con, req;
338 DWORD err;
339 BOOL ret;
340
341 ses = WinHttpOpen(test_useragent, 0, NULL, NULL, 0);
342 ok(ses != NULL, "failed to open session %u\n", GetLastError());
343
344 con = WinHttpConnect(ses, test_winehq, 80, 0);
345 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
346
347 req = WinHttpOpenRequest(con, NULL, NULL, NULL, NULL, NULL, 0);
348 ok(req != NULL, "failed to open a request %u\n", GetLastError());
349
350 ret = WinHttpSendRequest(req, empty, 0, NULL, 0, 0, 0);
351 err = GetLastError();
353 {
354 skip("connection failed, skipping\n");
355 goto done;
356 }
357 ok(ret, "failed to send request %u\n", GetLastError());
358
359 done:
363}
static const WCHAR empty[]
Definition: main.c:47

Referenced by START_TEST().

◆ test_head_request()

static void test_head_request ( int  port)
static

Definition at line 3058 of file winhttp.c.

3059{
3060 static const WCHAR verbW[] = {'H','E','A','D',0};
3061 static const WCHAR headW[] = {'/','h','e','a','d',0};
3062 HINTERNET ses, con, req;
3063 char buf[128];
3065 BOOL ret;
3066
3068 ok(ses != NULL, "failed to open session %u\n", GetLastError());
3069
3070 con = WinHttpConnect(ses, localhostW, port, 0);
3071 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
3072
3073 req = WinHttpOpenRequest(con, verbW, headW, NULL, NULL, NULL, 0);
3074 ok(req != NULL, "failed to open a request %u\n", GetLastError());
3075
3076 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
3077 ok(ret, "failed to send request %u\n", GetLastError());
3078
3080 ok(ret, "failed to receive response %u\n", GetLastError());
3081
3082 status = 0xdeadbeef;
3083 size = sizeof(status);
3085 NULL, &status, &size, NULL);
3086 ok(ret, "failed to get status code %u\n", GetLastError());
3087 ok(status == HTTP_STATUS_OK, "got %u\n", status);
3088
3089 len = 0xdeadbeef;
3090 size = sizeof(len);
3092 NULL, &len, &size, 0);
3093 ok(ret, "failed to get content-length header %u\n", GetLastError());
3094 ok(len == HTTP_STATUS_CONTINUE, "got %u\n", len);
3095
3096 count = 0xdeadbeef;
3098 ok(ret, "failed to query data available %u\n", GetLastError());
3099 ok(!count, "got %u\n", count);
3100
3101 len = sizeof(buf);
3102 count = 0xdeadbeef;
3103 ret = WinHttpReadData(req, buf, len, &count);
3104 ok(ret, "failed to read data %u\n", GetLastError());
3105 ok(!count, "got %u\n", count);
3106
3107 count = 0xdeadbeef;
3109 ok(ret, "failed to query data available %u\n", GetLastError());
3110 ok(!count, "got %u\n", count);
3111
3112 WinHttpCloseHandle(req);
3113 WinHttpCloseHandle(con);
3114 WinHttpCloseHandle(ses);
3115}
static const WCHAR headW[]
Definition: htmlelem.c:28
static const WCHAR verbW[]
Definition: main.c:64
#define HTTP_STATUS_CONTINUE
Definition: winhttp.h:238

Referenced by START_TEST().

◆ test_IWinHttpRequest()

static void test_IWinHttpRequest ( int  port)
static

Definition at line 3746 of file winhttp.c.

3747{
3748 static const WCHAR data_start[] = {'<','!','D','O','C','T','Y','P','E',' ','h','t','m','l',' ','P','U','B','L','I','C'};
3749 static const WCHAR usernameW[] = {'u','s','e','r','n','a','m','e',0};
3750 static const WCHAR passwordW[] = {'p','a','s','s','w','o','r','d',0};
3751 static const WCHAR url1W[] = {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0};
3752 static const WCHAR url2W[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0};
3753 static const WCHAR url3W[] = {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.',
3754 'o','r','g','/','t','e','s','t','s','/','p','o','s','t','.','p','h','p',0};
3755 static const WCHAR method1W[] = {'G','E','T',0};
3756 static const WCHAR method2W[] = {'I','N','V','A','L','I','D',0};
3757 static const WCHAR method3W[] = {'P','O','S','T',0};
3758 static const WCHAR proxy_serverW[] = {'p','r','o','x','y','s','e','r','v','e','r',0};
3759 static const WCHAR bypas_listW[] = {'b','y','p','a','s','s','l','i','s','t',0};
3760 static const WCHAR connectionW[] = {'C','o','n','n','e','c','t','i','o','n',0};
3761 static const WCHAR dateW[] = {'D','a','t','e',0};
3762 static const WCHAR test_dataW[] = {'t','e','s','t','d','a','t','a',128,0};
3763 static const WCHAR utf8W[] = {'u','t','f','-','8',0};
3764 static const WCHAR unauthW[] = {'U','n','a','u','t','h','o','r','i','z','e','d',0};
3765 HRESULT hr;
3766 IWinHttpRequest *req;
3767 BSTR method, url, username, password, response = NULL, status_text = NULL, headers = NULL;
3768 BSTR date, today, connection, value = NULL;
3769 VARIANT async, empty, timeout, body, body2, proxy_server, bypass_list, data, cp;
3770 VARIANT_BOOL succeeded;
3771 LONG status;
3773 SYSTEMTIME st;
3774 IStream *stream, *stream2;
3776 char buf[128];
3777 WCHAR bufW[128];
3778 DWORD count;
3779
3780 GetSystemTime( &st );
3781 WinHttpTimeFromSystemTime( &st, todayW );
3782
3783 CoInitialize( NULL );
3784 hr = CoCreateInstance( &CLSID_WinHttpRequest, NULL, CLSCTX_INPROC_SERVER, &IID_IWinHttpRequest, (void **)&req );
3785 ok( hr == S_OK, "got %08x\n", hr );
3786
3787 V_VT( &empty ) = VT_ERROR;
3788 V_ERROR( &empty ) = 0xdeadbeef;
3789
3790 V_VT( &async ) = VT_BOOL;
3791 V_BOOL( &async ) = VARIANT_FALSE;
3792
3793 method = SysAllocString( method3W );
3794 url = SysAllocString( url3W );
3795 hr = IWinHttpRequest_Open( req, method, url, async );
3796 ok( hr == S_OK, "got %08x\n", hr );
3798 SysFreeString( url );
3799
3800 V_VT( &data ) = VT_BSTR;
3801 V_BSTR( &data ) = SysAllocString( test_dataW );
3802 hr = IWinHttpRequest_Send( req, data );
3804 SysFreeString( V_BSTR( &data ) );
3805 if (hr != S_OK) goto done;
3806
3807 hr = IWinHttpRequest_Open( req, NULL, NULL, empty );
3808 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3809
3810 method = SysAllocString( method1W );
3811 hr = IWinHttpRequest_Open( req, method, NULL, empty );
3812 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3813
3814 hr = IWinHttpRequest_Open( req, method, NULL, async );
3815 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3816
3818 hr = IWinHttpRequest_Open( req, NULL, url, empty );
3819 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3820
3821 hr = IWinHttpRequest_Abort( req );
3822 ok( hr == S_OK, "got %08x\n", hr );
3823
3824 hr = IWinHttpRequest_Open( req, method, url, empty );
3825 ok( hr == S_OK, "got %08x\n", hr );
3826
3827 hr = IWinHttpRequest_Abort( req );
3828 ok( hr == S_OK, "got %08x\n", hr );
3829
3830 IWinHttpRequest_Release( req );
3831
3832 hr = CoCreateInstance( &CLSID_WinHttpRequest, NULL, CLSCTX_INPROC_SERVER, &IID_IWinHttpRequest, (void **)&req );
3833 ok( hr == S_OK, "got %08x\n", hr );
3834
3835 SysFreeString( url );
3836 url = SysAllocString( url2W );
3837 hr = IWinHttpRequest_Open( req, method, url, async );
3839
3841 method = SysAllocString( method2W );
3842 hr = IWinHttpRequest_Open( req, method, url, async );
3844
3846 method = SysAllocString( method1W );
3847 SysFreeString( url );
3849 V_VT( &async ) = VT_ERROR;
3850 V_ERROR( &async ) = DISP_E_PARAMNOTFOUND;
3851 hr = IWinHttpRequest_Open( req, method, url, async );
3852 ok( hr == S_OK, "got %08x\n", hr );
3853
3854 V_VT( &cp ) = VT_ERROR;
3855 V_ERROR( &cp ) = 0xdeadbeef;
3856 hr = IWinHttpRequest_get_Option( req, WinHttpRequestOption_URLCodePage, &cp );
3857 ok( hr == S_OK, "got %08x\n", hr );
3858 ok( V_VT( &cp ) == VT_I4, "got %08x\n", V_VT( &cp ) );
3859 ok( V_I4( &cp ) == CP_UTF8, "got %u\n", V_I4( &cp ) );
3860
3861 V_VT( &cp ) = VT_UI4;
3862 V_UI4( &cp ) = CP_ACP;
3863 hr = IWinHttpRequest_put_Option( req, WinHttpRequestOption_URLCodePage, cp );
3864 ok( hr == S_OK, "got %08x\n", hr );
3865
3866 V_VT( &cp ) = VT_ERROR;
3867 V_ERROR( &cp ) = 0xdeadbeef;
3868 hr = IWinHttpRequest_get_Option( req, WinHttpRequestOption_URLCodePage, &cp );
3869 ok( hr == S_OK, "got %08x\n", hr );
3870 ok( V_VT( &cp ) == VT_I4, "got %08x\n", V_VT( &cp ) );
3871 ok( V_I4( &cp ) == CP_ACP, "got %u\n", V_I4( &cp ) );
3872
3874 V_VT( &cp ) = VT_BSTR;
3875 V_BSTR( &cp ) = value;
3876 hr = IWinHttpRequest_put_Option( req, WinHttpRequestOption_URLCodePage, cp );
3877 ok( hr == S_OK, "got %08x\n", hr );
3879
3880 V_VT( &cp ) = VT_ERROR;
3881 V_ERROR( &cp ) = 0xdeadbeef;
3882 hr = IWinHttpRequest_get_Option( req, WinHttpRequestOption_URLCodePage, &cp );
3883 ok( hr == S_OK, "got %08x\n", hr );
3884 ok( V_VT( &cp ) == VT_I4, "got %08x\n", V_VT( &cp ) );
3885 ok( V_I4( &cp ) == CP_UTF8, "got %u\n", V_I4( &cp ) );
3886
3887 hr = IWinHttpRequest_Abort( req );
3888 ok( hr == S_OK, "got %08x\n", hr );
3889
3890 hr = IWinHttpRequest_Send( req, empty );
3892
3893 hr = IWinHttpRequest_Abort( req );
3894 ok( hr == S_OK, "got %08x\n", hr );
3895
3896 IWinHttpRequest_Release( req );
3897
3898 hr = CoCreateInstance( &CLSID_WinHttpRequest, NULL, CLSCTX_INPROC_SERVER, &IID_IWinHttpRequest, (void **)&req );
3899 ok( hr == S_OK, "got %08x\n", hr );
3900
3901 hr = IWinHttpRequest_get_ResponseText( req, NULL );
3902 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3903
3904 hr = IWinHttpRequest_get_ResponseText( req, &response );
3906
3907 hr = IWinHttpRequest_get_Status( req, NULL );
3908 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3909
3910 hr = IWinHttpRequest_get_Status( req, &status );
3912
3913 hr = IWinHttpRequest_get_StatusText( req, NULL );
3914 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3915
3916 hr = IWinHttpRequest_get_StatusText( req, &status_text );
3918
3919 hr = IWinHttpRequest_get_ResponseBody( req, NULL );
3920 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3921
3922 hr = IWinHttpRequest_SetTimeouts( req, 10000, 10000, 10000, 10000 );
3923 ok( hr == S_OK, "got %08x\n", hr );
3924
3925 hr = IWinHttpRequest_SetCredentials( req, NULL, NULL, 0xdeadbeef );
3927
3930 VariantInit( &bypass_list );
3931 V_VT( &bypass_list ) = VT_ERROR;
3932 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_DIRECT, proxy_server, bypass_list );
3933 ok( hr == S_OK, "got %08x\n", hr );
3934
3935 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_PROXY, proxy_server, bypass_list );
3936 ok( hr == S_OK, "got %08x\n", hr );
3937
3938 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_DIRECT, proxy_server, bypass_list );
3939 ok( hr == S_OK, "got %08x\n", hr );
3940
3941 hr = IWinHttpRequest_GetAllResponseHeaders( req, NULL );
3942 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3943
3944 hr = IWinHttpRequest_GetAllResponseHeaders( req, &headers );
3946
3947 hr = IWinHttpRequest_GetResponseHeader( req, NULL, NULL );
3949
3950 connection = SysAllocString( connectionW );
3951 hr = IWinHttpRequest_GetResponseHeader( req, connection, NULL );
3953
3954 hr = IWinHttpRequest_GetResponseHeader( req, connection, &value );
3956
3957 hr = IWinHttpRequest_SetRequestHeader( req, NULL, NULL );
3958 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3959
3960 date = SysAllocString( dateW );
3961 hr = IWinHttpRequest_SetRequestHeader( req, date, NULL );
3963
3964 today = SysAllocString( todayW );
3965 hr = IWinHttpRequest_SetRequestHeader( req, date, today );
3967
3968 hr = IWinHttpRequest_SetAutoLogonPolicy( req, 0xdeadbeef );
3969 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3970
3971 hr = IWinHttpRequest_SetAutoLogonPolicy( req, AutoLogonPolicy_OnlyIfBypassProxy );
3972 ok( hr == S_OK, "got %08x\n", hr );
3973
3975 method = SysAllocString( method1W );
3976 SysFreeString( url );
3978 hr = IWinHttpRequest_Open( req, method, url, async );
3979 ok( hr == S_OK, "got %08x\n", hr );
3980
3981 hr = IWinHttpRequest_get_ResponseText( req, NULL );
3982 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3983
3984 hr = IWinHttpRequest_get_ResponseText( req, &response );
3986
3987 hr = IWinHttpRequest_get_Status( req, &status );
3989
3990 hr = IWinHttpRequest_get_StatusText( req, &status_text );
3992
3993 hr = IWinHttpRequest_get_ResponseBody( req, NULL );
3994 ok( hr == E_INVALIDARG, "got %08x\n", hr );
3995
3996 hr = IWinHttpRequest_SetTimeouts( req, 10000, 10000, 10000, 10000 );
3997 ok( hr == S_OK, "got %08x\n", hr );
3998
3999 hr = IWinHttpRequest_SetCredentials( req, NULL, NULL, 0xdeadbeef );
4000 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4001
4002 username = SysAllocString( usernameW );
4003 hr = IWinHttpRequest_SetCredentials( req, username, NULL, 0xdeadbeef );
4004 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4005
4006 password = SysAllocString( passwordW );
4007 hr = IWinHttpRequest_SetCredentials( req, NULL, password, 0xdeadbeef );
4008 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4009
4010 hr = IWinHttpRequest_SetCredentials( req, username, password, 0xdeadbeef );
4011 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4012
4013 hr = IWinHttpRequest_SetCredentials( req, NULL, password, HTTPREQUEST_SETCREDENTIALS_FOR_SERVER );
4014 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4015
4016 hr = IWinHttpRequest_SetCredentials( req, username, password, HTTPREQUEST_SETCREDENTIALS_FOR_SERVER );
4017 ok( hr == S_OK, "got %08x\n", hr );
4018
4020 V_BSTR( &proxy_server ) = SysAllocString( proxy_serverW );
4021 V_VT( &bypass_list ) = VT_BSTR;
4022 V_BSTR( &bypass_list ) = SysAllocString( bypas_listW );
4023 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_PROXY, proxy_server, bypass_list );
4024 ok( hr == S_OK, "got %08x\n", hr );
4025
4026 hr = IWinHttpRequest_SetProxy( req, 0xdeadbeef, proxy_server, bypass_list );
4027 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4028
4029 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_DIRECT, proxy_server, bypass_list );
4030 ok( hr == S_OK, "got %08x\n", hr );
4031
4032 hr = IWinHttpRequest_GetAllResponseHeaders( req, &headers );
4034
4035 hr = IWinHttpRequest_GetResponseHeader( req, connection, &value );
4037
4038 hr = IWinHttpRequest_SetRequestHeader( req, date, today );
4039 ok( hr == S_OK, "got %08x\n", hr );
4040
4041 hr = IWinHttpRequest_SetRequestHeader( req, date, NULL );
4042 ok( hr == S_OK, "got %08x\n", hr );
4043
4044 hr = IWinHttpRequest_SetAutoLogonPolicy( req, AutoLogonPolicy_OnlyIfBypassProxy );
4045 ok( hr == S_OK, "got %08x\n", hr );
4046
4047 hr = IWinHttpRequest_Send( req, empty );
4048 ok( hr == S_OK, "got %08x\n", hr );
4049
4050 hr = IWinHttpRequest_Send( req, empty );
4051 ok( hr == S_OK, "got %08x\n", hr );
4052
4053 hr = IWinHttpRequest_get_ResponseText( req, NULL );
4054 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4055
4056 hr = IWinHttpRequest_get_ResponseText( req, &response );
4057 ok( hr == S_OK, "got %08x\n", hr );
4058 ok( !memcmp(response, data_start, sizeof(data_start)), "got %s\n", wine_dbgstr_wn(response, 32) );
4059 SysFreeString( response );
4060
4061 hr = IWinHttpRequest_get_Status( req, NULL );
4062 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4063
4064 status = 0;
4065 hr = IWinHttpRequest_get_Status( req, &status );
4066 ok( hr == S_OK, "got %08x\n", hr );
4067 trace("Status=%d\n", status);
4068
4069 hr = IWinHttpRequest_get_StatusText( req, NULL );
4070 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4071
4072 hr = IWinHttpRequest_get_StatusText( req, &status_text );
4073 ok( hr == S_OK, "got %08x\n", hr );
4074 trace("StatusText=%s\n", wine_dbgstr_w(status_text));
4075 SysFreeString( status_text );
4076
4077 hr = IWinHttpRequest_get_ResponseBody( req, NULL );
4078 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4079
4080 hr = IWinHttpRequest_SetCredentials( req, username, password, HTTPREQUEST_SETCREDENTIALS_FOR_SERVER );
4081 ok( hr == S_OK, "got %08x\n", hr );
4082
4083 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_PROXY, proxy_server, bypass_list );
4084 ok( hr == S_OK, "got %08x\n", hr );
4085
4086 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_DIRECT, proxy_server, bypass_list );
4087 ok( hr == S_OK, "got %08x\n", hr );
4088
4089 hr = IWinHttpRequest_GetAllResponseHeaders( req, NULL );
4090 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4091
4092 hr = IWinHttpRequest_GetAllResponseHeaders( req, &headers );
4093 ok( hr == S_OK, "got %08x\n", hr );
4095
4096 hr = IWinHttpRequest_GetResponseHeader( req, NULL, NULL );
4097 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4098
4099 hr = IWinHttpRequest_GetResponseHeader( req, connection, NULL );
4100 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4101
4102 hr = IWinHttpRequest_GetResponseHeader( req, connection, &value );
4103 ok( hr == S_OK, "got %08x\n", hr );
4105
4106 hr = IWinHttpRequest_SetRequestHeader( req, date, today );
4108
4109 hr = IWinHttpRequest_SetAutoLogonPolicy( req, AutoLogonPolicy_OnlyIfBypassProxy );
4110 ok( hr == S_OK, "got %08x\n", hr );
4111
4112 VariantInit( &timeout );
4113 V_VT( &timeout ) = VT_I4;
4114 V_I4( &timeout ) = 10;
4115 hr = IWinHttpRequest_WaitForResponse( req, timeout, &succeeded );
4116 ok( hr == S_OK, "got %08x\n", hr );
4117
4118 hr = IWinHttpRequest_get_Status( req, &status );
4119 ok( hr == S_OK, "got %08x\n", hr );
4120
4121 hr = IWinHttpRequest_get_StatusText( req, &status_text );
4122 ok( hr == S_OK, "got %08x\n", hr );
4123 SysFreeString( status_text );
4124
4125 hr = IWinHttpRequest_SetCredentials( req, username, password, HTTPREQUEST_SETCREDENTIALS_FOR_SERVER );
4126 ok( hr == S_OK, "got %08x\n", hr );
4127
4128 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_PROXY, proxy_server, bypass_list );
4129 ok( hr == S_OK, "got %08x\n", hr );
4130
4131 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_DIRECT, proxy_server, bypass_list );
4132 ok( hr == S_OK, "got %08x\n", hr );
4133
4134 hr = IWinHttpRequest_Send( req, empty );
4135 ok( hr == S_OK, "got %08x\n", hr );
4136
4137 hr = IWinHttpRequest_get_ResponseText( req, NULL );
4138 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4139
4140 hr = IWinHttpRequest_get_ResponseText( req, &response );
4141 ok( hr == S_OK, "got %08x\n", hr );
4142 SysFreeString( response );
4143
4144 hr = IWinHttpRequest_get_ResponseBody( req, NULL );
4145 ok( hr == E_INVALIDARG, "got %08x\n", hr );
4146
4147 VariantInit( &body );
4148 V_VT( &body ) = VT_ERROR;
4149 hr = IWinHttpRequest_get_ResponseBody( req, &body );
4150 ok( hr == S_OK, "got %08x\n", hr );
4151 ok( V_VT( &body ) == (VT_ARRAY|VT_UI1), "got %08x\n", V_VT( &body ) );
4152
4153 hr = VariantClear( &body );
4154 ok( hr == S_OK, "got %08x\n", hr );
4155
4156 VariantInit( &body );
4157 V_VT( &body ) = VT_ERROR;
4158 hr = IWinHttpRequest_get_ResponseStream( req, &body );
4159 ok( hr == S_OK, "got %08x\n", hr );
4160 ok( V_VT( &body ) == VT_UNKNOWN, "got %08x\n", V_VT( &body ) );
4161
4162 hr = IUnknown_QueryInterface( V_UNKNOWN( &body ), &IID_IStream, (void **)&stream );
4163 ok( hr == S_OK, "got %08x\n", hr );
4164 ok( V_UNKNOWN( &body ) == (IUnknown *)stream, "got different interface pointer\n" );
4165
4166 buf[0] = 0;
4167 count = 0xdeadbeef;
4168 hr = IStream_Read( stream, buf, 128, &count );
4169 ok( hr == S_OK, "got %08x\n", hr );
4170 ok( count != 0xdeadbeef, "count not set\n" );
4171 ok( buf[0], "no data\n" );
4172
4173 VariantInit( &body2 );
4174 V_VT( &body2 ) = VT_ERROR;
4175 hr = IWinHttpRequest_get_ResponseStream( req, &body2 );
4176 ok( hr == S_OK, "got %08x\n", hr );
4177 ok( V_VT( &body2 ) == VT_UNKNOWN, "got %08x\n", V_VT( &body2 ) );
4178 ok( V_UNKNOWN( &body ) != V_UNKNOWN( &body2 ), "got same interface pointer\n" );
4179
4180 hr = IUnknown_QueryInterface( V_UNKNOWN( &body2 ), &IID_IStream, (void **)&stream2 );
4181 ok( hr == S_OK, "got %08x\n", hr );
4182 ok( V_UNKNOWN( &body2 ) == (IUnknown *)stream2, "got different interface pointer\n" );
4183 IStream_Release( stream2 );
4184
4185 hr = VariantClear( &body );
4186 ok( hr == S_OK, "got %08x\n", hr );
4187
4188 hr = VariantClear( &body2 );
4189 ok( hr == S_OK, "got %08x\n", hr );
4190
4191 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_PROXY, proxy_server, bypass_list );
4192 ok( hr == S_OK, "got %08x\n", hr );
4193
4194 hr = IWinHttpRequest_SetProxy( req, HTTPREQUEST_PROXYSETTING_DIRECT, proxy_server, bypass_list );
4195 ok( hr == S_OK, "got %08x\n", hr );
4196
4197 hr = IWinHttpRequest_GetAllResponseHeaders( req, &headers );
4198 ok( hr == S_OK, "got %08x\n", hr );
4200
4201 hr = IWinHttpRequest_GetResponseHeader( req, connection, &value );
4202 ok( hr == S_OK, "got %08x\n", hr );
4204
4205 hr = IWinHttpRequest_SetRequestHeader( req, date, today );
4207
4208 hr = IWinHttpRequest_SetAutoLogonPolicy( req, AutoLogonPolicy_OnlyIfBypassProxy );
4209 ok( hr == S_OK, "got %08x\n", hr );
4210
4211 hr = IWinHttpRequest_Send( req, empty );
4212 ok( hr == S_OK, "got %08x\n", hr );
4213
4214 hr = IWinHttpRequest_Abort( req );
4215 ok( hr == S_OK, "got %08x\n", hr );
4216
4217 hr = IWinHttpRequest_Abort( req );
4218 ok( hr == S_OK, "got %08x\n", hr );
4219
4220 IWinHttpRequest_Release( req );
4221
4222 pos.QuadPart = 0;
4223 hr = IStream_Seek( stream, pos, STREAM_SEEK_SET, NULL );
4224 ok( hr == S_OK, "got %08x\n", hr );
4225
4226 buf[0] = 0;
4227 count = 0xdeadbeef;
4228 hr = IStream_Read( stream, buf, 128, &count );
4229 ok( hr == S_OK, "got %08x\n", hr );
4230 ok( count != 0xdeadbeef, "count not set\n" );
4231 ok( buf[0], "no data\n" );
4232 IStream_Release( stream );
4233
4234 hr = CoCreateInstance( &CLSID_WinHttpRequest, NULL, CLSCTX_INPROC_SERVER, &IID_IWinHttpRequest, (void **)&req );
4235 ok( hr == S_OK, "got %08x\n", hr );
4236
4237 V_VT( &async ) = VT_I4;
4238 V_I4( &async ) = 1;
4239 hr = IWinHttpRequest_Open( req, method, url, async );
4240 ok( hr == S_OK, "got %08x\n", hr );
4241
4242 hr = IWinHttpRequest_Send( req, empty );
4243 ok( hr == S_OK, "got %08x\n", hr );
4244
4245 hr = IWinHttpRequest_WaitForResponse( req, timeout, &succeeded );
4246 ok( hr == S_OK, "got %08x\n", hr );
4247
4248 IWinHttpRequest_Release( req );
4249
4251 SysFreeString( url );
4254 SysFreeString( connection );
4256 SysFreeString( today );
4258 VariantClear( &bypass_list );
4259
4260 hr = CoCreateInstance( &CLSID_WinHttpRequest, NULL, CLSCTX_INPROC_SERVER, &IID_IWinHttpRequest, (void **)&req );
4261 ok( hr == S_OK, "got %08x\n", hr );
4262
4264 method = SysAllocString( method3W );
4265 V_VT( &async ) = VT_BOOL;
4266 V_BOOL( &async ) = VARIANT_FALSE;
4267 hr = IWinHttpRequest_Open( req, method, url, async );
4268 ok( hr == S_OK, "got %08x\n", hr );
4270 SysFreeString( url );
4271
4272 hr = IWinHttpRequest_Send( req, empty );
4274 hr == SEC_E_ILLEGAL_MESSAGE /* winxp */, "got %08x\n", hr );
4275 if (hr != S_OK) goto done;
4276
4277 hr = IWinHttpRequest_get_ResponseText( req, &response );
4278 ok( hr == S_OK, "got %08x\n", hr );
4279#ifdef __REACTOS__
4280 ok( !memcmp(response, data_start, sizeof(data_start)), "got %s\n",
4281 wine_dbgstr_wn(response, min(SysStringLen(response), 32)) );
4282#else
4283 ok( !memcmp(response, data_start, sizeof(data_start)), "got %s\n", wine_dbgstr_wn(response, 32) );
4284#endif
4285 SysFreeString( response );
4286
4287 IWinHttpRequest_Release( req );
4288
4289 hr = CoCreateInstance( &CLSID_WinHttpRequest, NULL, CLSCTX_INPROC_SERVER, &IID_IWinHttpRequest, (void **)&req );
4290 ok( hr == S_OK, "got %08x\n", hr );
4291
4292 sprintf( buf, "http://localhost:%d/auth", port );
4293 MultiByteToWideChar( CP_ACP, 0, buf, -1, bufW, ARRAY_SIZE( bufW ));
4294 url = SysAllocString( bufW );
4295 method = SysAllocString( method3W );
4296 V_VT( &async ) = VT_BOOL;
4297 V_BOOL( &async ) = VARIANT_FALSE;
4298 hr = IWinHttpRequest_Open( req, method, url, async );
4299 ok( hr == S_OK, "got %08x\n", hr );
4301 SysFreeString( url );
4302
4303 hr = IWinHttpRequest_get_Status( req, &status );
4305
4306 V_VT( &data ) = VT_BSTR;
4307 V_BSTR( &data ) = SysAllocString( test_dataW );
4308 hr = IWinHttpRequest_Send( req, data );
4309 ok( hr == S_OK, "got %08x\n", hr );
4310 SysFreeString( V_BSTR( &data ) );
4311
4312 hr = IWinHttpRequest_get_ResponseText( req, &response );
4313 ok( hr == S_OK, "got %08x\n", hr );
4314 ok( !memcmp( response, unauthW, sizeof(unauthW) ), "got %s\n", wine_dbgstr_w(response) );
4315 SysFreeString( response );
4316
4317 status = 0xdeadbeef;
4318 hr = IWinHttpRequest_get_Status( req, &status );
4319 ok( hr == S_OK, "got %08x\n", hr );
4320 ok( status == HTTP_STATUS_DENIED, "got %d\n", status );
4321
4322done:
4323 IWinHttpRequest_Release( req );
4325}
static const WCHAR proxy_server[]
Definition: connections.c:40
#define E_INVALIDARG
Definition: ddrawi.h:101
const char * wine_dbgstr_wn(const WCHAR *str, int n)
Definition: compat.c:367
OLECHAR * BSTR
Definition: compat.h:2293
short VARIANT_BOOL
Definition: compat.h:2290
@ VT_BSTR
Definition: compat.h:2303
@ VT_UNKNOWN
Definition: compat.h:2308
@ VT_ERROR
Definition: compat.h:2305
@ VT_ARRAY
Definition: compat.h:2341
@ VT_BOOL
Definition: compat.h:2306
@ VT_UI4
Definition: compat.h:2313
@ VT_UI1
Definition: compat.h:2311
VOID WINAPI GetSystemTime(OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:327
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
BOOL WINAPI WinHttpTimeFromSystemTime(const SYSTEMTIME *time, LPWSTR string)
Definition: session.c:2158
method
Definition: dragdrop.c:54
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
POINT cp
Definition: magnifier.c:59
__u16 date
Definition: mkdosfs.c:8
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static const WCHAR url1W[]
Definition: atl.c:53
static const WCHAR url[]
Definition: encode.c:1432
static WCHAR password[]
Definition: url.c:33
static WCHAR username[]
Definition: url.c:32
#define min(a, b)
Definition: monoChain.cc:55
static const WCHAR utf8W[]
Definition: mxwriter.c:86
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
#define V_ERROR(A)
Definition: oleauto.h:241
#define V_BOOL(A)
Definition: oleauto.h:224
#define V_UNKNOWN(A)
Definition: oleauto.h:281
#define V_BSTR(A)
Definition: oleauto.h:226
#define V_UI4(A)
Definition: oleauto.h:270
#define CP_UTF8
Definition: nls.h:20
static const void * body(MD5_CTX *ctx, const void *data, unsigned long size)
Definition: md5.c:100
vector< Header * > headers
Definition: sdkparse.cpp:39
Definition: parse.h:23
Definition: dhcpd.h:245
Definition: pdh_main.c:94
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
#define DISP_E_PARAMNOTFOUND
Definition: winerror.h:2513
#define SEC_E_ILLEGAL_MESSAGE
Definition: winerror.h:2943
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
static const WCHAR test_winehq_https[]
Definition: winhttp.c:43
#define ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN
Definition: winhttp.h:209
#define ERROR_WINHTTP_INVALID_SERVER_RESPONSE
Definition: winhttp.h:214
#define ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND
Definition: winhttp.h:210
#define ERROR_WINHTTP_UNRECOGNIZED_SCHEME
Definition: winhttp.h:192
#define ERROR_WINHTTP_CANNOT_CALL_AFTER_SEND
Definition: winhttp.h:211
#define WINHTTP_TIME_FORMAT_BUFSIZE
Definition: winhttp.h:461

Referenced by START_TEST().

◆ test_IWinHttpRequest_Invoke()

static void test_IWinHttpRequest_Invoke ( void  )
static

Definition at line 4347 of file winhttp.c.

4348{
4349 static const WCHAR utf8W[] = {'U','T','F','-','8',0};
4350 static const WCHAR regid[] = {'W','i','n','H','t','t','p','.','W','i','n','H','t','t','p','R','e','q','u','e','s','t','.','5','.','1',0};
4351 WCHAR openW[] = {'O','p','e','n',0};
4352 WCHAR optionW[] = {'O','p','t','i','o','n',0};
4353 OLECHAR *open = openW, *option = optionW;
4354 BSTR utf8;
4355 CLSID clsid;
4356 IWinHttpRequest *request;
4358 DISPID id;
4360 VARIANT arg[3], ret;
4361 UINT err;
4362 BOOL bret;
4363 HRESULT hr;
4364
4366
4368 ok(hr == S_OK, "CLSIDFromProgID error %#x\n", hr);
4369 bret = IsEqualIID(&clsid, &CLSID_WinHttpRequest);
4370 ok(bret || broken(!bret) /* win2003 */, "not expected %s\n", wine_dbgstr_guid(&clsid));
4371
4372 hr = CoCreateInstance(&CLSID_WinHttpRequest, 0, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&request);
4373 ok(hr == S_OK, "error %#x\n", hr);
4374
4375 hr = IWinHttpRequest_QueryInterface(request, &IID_IDispatch, (void **)&dispatch);
4376 ok(hr == S_OK, "error %#x\n", hr);
4377 IDispatch_Release(dispatch);
4378
4379 hr = IWinHttpRequest_GetIDsOfNames(request, &IID_NULL, &open, 1, 0x0409, &id);
4380 ok(hr == S_OK, "error %#x\n", hr);
4381 ok(id == DISPID_HTTPREQUEST_OPEN, "expected DISPID_HTTPREQUEST_OPEN, got %u\n", id);
4382
4383 hr = IWinHttpRequest_GetIDsOfNames(request, &IID_NULL, &option, 1, 0x0409, &id);
4384 ok(hr == S_OK, "error %#x\n", hr);
4385 ok(id == DISPID_HTTPREQUEST_OPTION, "expected DISPID_HTTPREQUEST_OPTION, got %u\n", id);
4386
4387 request_get_property(request, WinHttpRequestOption_URLCodePage, &ret);
4388 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4389 ok(V_I4(&ret) == CP_UTF8, "expected CP_UTF8, got %d\n", V_I4(&ret));
4390
4391 memset(&params, 0, sizeof(params));
4392 params.cArgs = 2;
4393 params.cNamedArgs = 0;
4394 params.rgvarg = arg;
4395 V_VT(&arg[0]) = VT_I4;
4396 V_I4(&arg[0]) = 1252;
4397 V_VT(&arg[1]) = VT_R8;
4398 V_R8(&arg[1]) = 2.0; /* WinHttpRequestOption_URLCodePage */
4399 VariantInit(&ret);
4400 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0,
4402 ok(hr == S_OK, "error %#x\n", hr);
4403
4404 request_get_property(request, WinHttpRequestOption_URLCodePage, &ret);
4405 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4406 ok(V_I4(&ret) == CP_UTF8, "expected CP_UTF8, got %d\n", V_I4(&ret));
4407
4408 memset(&params, 0, sizeof(params));
4409 params.cArgs = 2;
4410 params.cNamedArgs = 0;
4411 params.rgvarg = arg;
4412 V_VT(&arg[0]) = VT_I4;
4413 V_I4(&arg[0]) = 1252;
4414 V_VT(&arg[1]) = VT_R8;
4415 V_R8(&arg[1]) = 2.0; /* WinHttpRequestOption_URLCodePage */
4416 VariantInit(&ret);
4417 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0,
4419 ok(hr == S_OK, "error %#x\n", hr);
4420
4421 request_get_property(request, WinHttpRequestOption_URLCodePage, &ret);
4422 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4423 ok(V_I4(&ret) == CP_UTF8, "expected CP_UTF8, got %d\n", V_I4(&ret));
4424
4425 memset(&params, 0, sizeof(params));
4426 params.cArgs = 2;
4427 params.cNamedArgs = 0;
4428 params.rgvarg = arg;
4429 V_VT(&arg[0]) = VT_I4;
4430 V_I4(&arg[0]) = 1252;
4431 V_VT(&arg[1]) = VT_R8;
4432 V_R8(&arg[1]) = 2.0; /* WinHttpRequestOption_URLCodePage */
4433 VariantInit(&ret);
4434 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0,
4436 ok(hr == S_OK, "error %#x\n", hr);
4437
4438 request_get_property(request, WinHttpRequestOption_URLCodePage, &ret);
4439 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4440 ok(V_I4(&ret) == 1252, "expected 1252, got %d\n", V_I4(&ret));
4441
4442 memset(&params, 0, sizeof(params));
4443 params.cArgs = 2;
4444 params.cNamedArgs = 0;
4445 params.rgvarg = arg;
4446 V_VT(&arg[0]) = VT_BSTR;
4447 utf8 = SysAllocString(utf8W);
4448 V_BSTR(&arg[0]) = utf8;
4449 V_VT(&arg[1]) = VT_R8;
4450 V_R8(&arg[1]) = 2.0; /* WinHttpRequestOption_URLCodePage */
4451 hr = IWinHttpRequest_Invoke(request, id, &IID_NULL, 0, DISPATCH_METHOD, &params, NULL, NULL, &err);
4452 ok(hr == S_OK, "error %#x\n", hr);
4453
4454 request_get_property(request, WinHttpRequestOption_URLCodePage, &ret);
4455 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4456 ok(V_I4(&ret) == 1252, "expected 1252, got %d\n", V_I4(&ret));
4457
4458 VariantInit(&ret);
4459 hr = IWinHttpRequest_Invoke(request, id, &IID_NULL, 0, DISPATCH_METHOD, &params, &ret, NULL, &err);
4460 ok(hr == S_OK, "error %#x\n", hr);
4461
4462 request_get_property(request, WinHttpRequestOption_URLCodePage, &ret);
4463 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4464 ok(V_I4(&ret) == 1252, "expected 1252, got %d\n", V_I4(&ret));
4465
4466 VariantInit(&ret);
4467 hr = IWinHttpRequest_Invoke(request, id, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &params, &ret, NULL, &err);
4468 ok(hr == S_OK, "error %#x\n", hr);
4469
4470 request_get_property(request, WinHttpRequestOption_URLCodePage, &ret);
4471 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4472 ok(V_I4(&ret) == CP_UTF8, "expected CP_UTF8, got %d\n", V_I4(&ret));
4473
4475 ok(hr == S_OK, "error %#x\n", hr);
4476
4477 hr = IWinHttpRequest_Invoke(request, 255, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &params, NULL, NULL, NULL);
4478 ok(hr == DISP_E_MEMBERNOTFOUND, "error %#x\n", hr);
4479
4480 VariantInit(&ret);
4481 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_IUnknown, 0, DISPATCH_PROPERTYPUT, &params, &ret, NULL, &err);
4482 ok(hr == DISP_E_UNKNOWNINTERFACE, "error %#x\n", hr);
4483
4484 VariantInit(&ret);
4485 if (0) /* crashes */
4486 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0, DISPATCH_PROPERTYPUT, NULL, &ret, NULL, &err);
4487
4488 params.cArgs = 1;
4489 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &params, &ret, NULL, &err);
4490 ok(hr == DISP_E_TYPEMISMATCH, "error %#x\n", hr);
4491
4492 VariantInit(&arg[2]);
4493 params.cArgs = 3;
4494 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &params, &ret, NULL, &err);
4496 ok(hr == S_OK, "error %#x\n", hr);
4497
4498 VariantInit(&arg[0]);
4499 VariantInit(&arg[1]);
4500 VariantInit(&arg[2]);
4501
4502 params.cArgs = 1;
4503 V_VT(&arg[0]) = VT_I4;
4506 ok(hr == S_OK, "error %#x\n", hr);
4507
4508 V_VT(&ret) = 0xdead;
4509 V_I4(&ret) = 0xbeef;
4511 ok(hr == S_OK, "error %#x\n", hr);
4512 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4513 ok(V_I4(&ret) == CP_UTF8, "expected CP_UTF8, got %d\n", V_I4(&ret));
4514
4515 V_VT(&ret) = 0xdead;
4516 V_I4(&ret) = 0xbeef;
4517 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0, DISPATCH_METHOD, &params, &ret, NULL, NULL);
4518 ok(hr == S_OK, "error %#x\n", hr);
4519 ok(V_VT(&ret) == VT_I4, "expected VT_I4, got %d\n", V_VT(&ret));
4520 ok(V_I4(&ret) == CP_UTF8, "expected CP_UTF8, got %d\n", V_I4(&ret));
4521
4523 ok(hr == S_OK, "error %#x\n", hr);
4524
4525 V_VT(&ret) = 0xdead;
4526 V_I4(&ret) = 0xbeef;
4527 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0, 0, &params, &ret, NULL, NULL);
4528 ok(hr == S_OK, "error %#x\n", hr);
4529 ok(V_VT(&ret) == VT_EMPTY, "expected VT_EMPTY, got %d\n", V_VT(&ret));
4530 ok(V_I4(&ret) == 0xbeef || V_I4(&ret) == 0 /* Win8 */, "expected 0xdead, got %d\n", V_I4(&ret));
4531
4532 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_OPTION, &IID_NULL, 0, 0, &params, NULL, NULL, NULL);
4533 ok(hr == S_OK, "error %#x\n", hr);
4534
4536 ok(hr == DISP_E_UNKNOWNINTERFACE, "error %#x\n", hr);
4537
4538 params.cArgs = 2;
4541 ok(hr == S_OK, "error %#x\n", hr);
4542
4543 params.cArgs = 0;
4545 ok(hr == DISP_E_PARAMNOTFOUND, "error %#x\n", hr);
4546
4547 SysFreeString(utf8);
4548
4549 params.cArgs = 1;
4550 V_VT(&arg[0]) = VT_I4;
4552 VariantInit(&ret);
4553 hr = IWinHttpRequest_Invoke(request, DISPID_HTTPREQUEST_SETAUTOLOGONPOLICY, &IID_NULL, 0,
4555 ok(hr == S_OK, "error %#x\n", hr);
4556
4557 IWinHttpRequest_Release(request);
4558
4560}
#define open
Definition: acwin.h:95
void dispatch(HANDLE hStopEvent)
Definition: dispatch.c:70
const GUID IID_IUnknown
WCHAR OLECHAR
Definition: compat.h:2292
@ VT_R8
Definition: compat.h:2300
@ VT_EMPTY
Definition: compat.h:2295
HRESULT WINAPI DECLSPEC_HOTPATCH CLSIDFromProgID(LPCOLESTR progid, LPCLSID clsid)
Definition: compobj.c:2602
#define regid
Definition: ecma_167.h:64
GLuint id
Definition: glext.h:5910
static const WCHAR optionW[]
Definition: htmlelem.c:36
#define DISPID_HTTPREQUEST_SETAUTOLOGONPOLICY
Definition: httprequestid.h:40
#define DISPID_HTTPREQUEST_OPEN
Definition: httprequestid.h:23
static VARIANTARG static DISPID
Definition: ordinal.c:52
REFCLSID clsid
Definition: msctf.c:82
@ WinHttpRequestOption_URLCodePage
Definition: httprequest.idl:54
@ AutoLogonPolicy_Never
Definition: httprequest.idl:80
unsigned int UINT
Definition: ndis.h:50
#define DISPATCH_PROPERTYPUT
Definition: oleauto.h:1008
#define DISPATCH_METHOD
Definition: oleauto.h:1006
#define V_R8(A)
Definition: oleauto.h:262
const GUID IID_IDispatch
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197
Definition: getopt.h:109
#define DISP_E_UNKNOWNINTERFACE
Definition: winerror.h:2511
#define DISP_E_MEMBERNOTFOUND
Definition: winerror.h:2512
#define DISP_E_TYPEMISMATCH
Definition: winerror.h:2514
static void request_get_property(IWinHttpRequest *request, int property, VARIANT *ret)
Definition: winhttp.c:4327

Referenced by START_TEST().

◆ test_large_data_authentication()

static void test_large_data_authentication ( int  port)
static

Definition at line 2887 of file winhttp.c.

2888{
2889 static const WCHAR largeauthW[] = {'/','l','a','r','g','e','a','u','t','h',0};
2890 static const WCHAR getW[] = {'G','E','T',0};
2891 static WCHAR userW[] = {'u','s','e','r',0};
2892 static WCHAR passW[] = {'p','w','d',0};
2893 HINTERNET ses, con, req;
2894 DWORD status, size;
2895 BOOL ret;
2896
2898 ok(ses != NULL, "failed to open session %u\n", GetLastError());
2899
2900 con = WinHttpConnect(ses, localhostW, port, 0);
2901 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
2902
2903 req = WinHttpOpenRequest(con, getW, largeauthW, NULL, NULL, NULL, 0);
2904 ok(req != NULL, "failed to open a request %u\n", GetLastError());
2905
2907 ok(ret, "expected success\n");
2908
2910 ok(ret, "expected success\n");
2911
2912 size = sizeof(status);
2914 &status, &size, NULL);
2915 ok(ret, "expected success\n");
2916 ok(status == HTTP_STATUS_DENIED, "got %d\n", status);
2917
2919 ok(ret, "expected success\n");
2920
2922 ok(ret, "expected success %d\n", GetLastError());
2923
2925 ok(ret, "expected success\n");
2926
2927 size = sizeof(status);
2929 &status, &size, NULL);
2930 ok(ret, "expected success\n");
2931 ok(status == HTTP_STATUS_OK, "got %d\n", status);
2932
2933 WinHttpCloseHandle(req);
2934 WinHttpCloseHandle(con);
2935 WinHttpCloseHandle(ses);
2936}
static const WCHAR getW[]
Definition: object.c:50
#define WINHTTP_NO_REQUEST_DATA
Definition: winhttp.h:184
#define WINHTTP_NO_ADDITIONAL_HEADERS
Definition: winhttp.h:183

Referenced by START_TEST().

◆ test_multi_authentication()

static void test_multi_authentication ( int  port)
static

Definition at line 2832 of file winhttp.c.

2833{
2834 static const WCHAR multiauthW[] = {'/','m','u','l','t','i','a','u','t','h',0};
2835 static const WCHAR www_authenticateW[] =
2836 {'W','W','W','-','A','u','t','h','e','n','t','i','c','a','t','e',0};
2837 static const WCHAR getW[] = {'G','E','T',0};
2838 HINTERNET ses, con, req;
2839 DWORD supported, first, target, size, index;
2840 WCHAR buf[512];
2841 BOOL ret;
2842
2844 ok(ses != NULL, "failed to open session %u\n", GetLastError());
2845
2846 con = WinHttpConnect(ses, localhostW, port, 0);
2847 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
2848
2849 req = WinHttpOpenRequest(con, getW, multiauthW, NULL, NULL, NULL, 0);
2850 ok(req != NULL, "failed to open a request %u\n", GetLastError());
2851
2853 WINHTTP_NO_REQUEST_DATA,0, 0, 0 );
2854 ok(ret, "expected success\n");
2855
2857 ok(ret, "expected success\n");
2858
2859 supported = first = target = 0xdeadbeef;
2860 ret = WinHttpQueryAuthSchemes(req, &supported, &first, &target);
2861 ok(ret, "expected success\n");
2862 ok(supported == (WINHTTP_AUTH_SCHEME_BASIC | WINHTTP_AUTH_SCHEME_NTLM), "got %x\n", supported);
2863 ok(target == WINHTTP_AUTH_TARGET_SERVER, "got %x\n", target);
2864 ok(first == WINHTTP_AUTH_SCHEME_BASIC, "got %x\n", first);
2865
2866 index = 0;
2867 size = sizeof(buf);
2868 ret = WinHttpQueryHeaders(req, WINHTTP_QUERY_CUSTOM, www_authenticateW, buf, &size, &index);
2869 ok(ret, "expected success\n");
2870 ok(!strcmp_wa(buf, "Bearer"), "buf = %s\n", wine_dbgstr_w(buf));
2871 ok(size == lstrlenW(buf) * sizeof(WCHAR), "size = %u\n", size);
2872 ok(index == 1, "index = %u\n", index);
2873
2874 index = 0;
2875 size = 0xdeadbeef;
2876 ret = WinHttpQueryHeaders(req, WINHTTP_QUERY_CUSTOM, www_authenticateW, NULL, &size, &index);
2878 "WinHttpQueryHeaders returned %x(%u)\n", ret, GetLastError());
2879 ok(size == (lstrlenW(buf) + 1) * sizeof(WCHAR), "size = %u\n", size);
2880 ok(index == 0, "index = %u\n", index);
2881
2882 WinHttpCloseHandle(req);
2883 WinHttpCloseHandle(con);
2884 WinHttpCloseHandle(ses);
2885}
static int strcmp_wa(const WCHAR *str1, const char *stra)
Definition: winhttp.c:54

Referenced by START_TEST().

◆ test_multiple_reads()

static void test_multiple_reads ( int  port)
static

Definition at line 3212 of file winhttp.c.

3213{
3214 static const WCHAR bigW[] = {'b','i','g',0};
3215 HINTERNET ses, con, req;
3216 DWORD total_len = 0;
3217 BOOL ret;
3218
3220 ok(ses != NULL, "failed to open session %u\n", GetLastError());
3221
3222 con = WinHttpConnect(ses, localhostW, port, 0);
3223 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
3224
3225 req = WinHttpOpenRequest(con, NULL, bigW, NULL, NULL, NULL, 0);
3226 ok(req != NULL, "failed to open a request %u\n", GetLastError());
3227
3228 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
3229 ok(ret, "failed to send request %u\n", GetLastError());
3230
3231 trace("waiting for response\n");
3233 ok(ret == TRUE, "expected success\n");
3234
3235 trace("finished waiting for response\n");
3236
3237 for (;;)
3238 {
3239 DWORD len = 0xdeadbeef;
3241 ok( ret, "WinHttpQueryDataAvailable failed with error %u\n", GetLastError() );
3242 if (ret) ok( len != 0xdeadbeef, "WinHttpQueryDataAvailable return wrong length\n" );
3243 if (len)
3244 {
3245 DWORD bytes_read;
3246 char *buf = HeapAlloc( GetProcessHeap(), 0, len + 1 );
3247
3248 ret = WinHttpReadData( req, buf, len, &bytes_read );
3249 ok(ret, "WinHttpReadData failed: %u.\n", GetLastError());
3250 ok( len == bytes_read, "only got %u of %u available\n", bytes_read, len );
3251
3252 HeapFree( GetProcessHeap(), 0, buf );
3253 if (!bytes_read) break;
3254 total_len += bytes_read;
3255 trace("read bytes %u, total_len: %u\n", bytes_read, total_len);
3256 }
3257 if (!len) break;
3258 }
3259 ok(total_len == BIG_BUFFER_LEN, "got wrong length: 0x%x\n", total_len);
3260
3261 WinHttpCloseHandle(req);
3262 WinHttpCloseHandle(con);
3263 WinHttpCloseHandle(ses);
3264}
#define TRUE
Definition: types.h:120
static const WCHAR bigW[]
Definition: string.c:38

Referenced by START_TEST().

◆ test_no_content()

static void test_no_content ( int  port)
static

Definition at line 2974 of file winhttp.c.

2975{
2976 static const WCHAR no_contentW[] = {'/','n','o','_','c','o','n','t','e','n','t',0};
2977 HINTERNET ses, con, req;
2978 char buf[128];
2979 DWORD size, len = sizeof(buf), bytes_read, status;
2980 BOOL ret;
2981
2983 ok(ses != NULL, "failed to open session %u\n", GetLastError());
2984
2985 con = WinHttpConnect(ses, localhostW, port, 0);
2986 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
2987
2988 req = WinHttpOpenRequest(con, NULL, no_contentW, NULL, NULL, NULL, 0);
2989 ok(req != NULL, "failed to open a request %u\n", GetLastError());
2990
2991 size = 12345;
2992 SetLastError(0xdeadbeef);
2994 todo_wine {
2995 ok(!ret, "expected error\n");
2997 "expected ERROR_WINHTTP_INCORRECT_HANDLE_STATE, got 0x%08x\n", GetLastError());
2998 ok(size == 12345 || broken(size == 0) /* Win <= 2003 */,
2999 "expected 12345, got %u\n", size);
3000 }
3001
3002 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
3003 ok(ret, "expected success\n");
3004
3006 ok(ret, "expected success\n");
3007
3008 status = 0xdeadbeef;
3009 size = sizeof(status);
3011 NULL, &status, &size, NULL);
3012 ok(ret, "expected success\n");
3013 ok(status == HTTP_STATUS_NO_CONTENT, "expected status 204, got %d\n", status);
3014
3015 SetLastError(0xdeadbeef);
3016 size = sizeof(status);
3017 status = 12345;
3019 NULL, &status, &size, 0);
3020 ok(!ret, "expected no content-length header\n");
3021 ok(GetLastError() == ERROR_WINHTTP_HEADER_NOT_FOUND, "wrong error %u\n", GetLastError());
3022 ok(status == 12345, "expected 0, got %d\n", status);
3023
3024 SetLastError(0xdeadbeef);
3025 size = 12345;
3027 ok(ret, "expected success\n");
3028 ok(GetLastError() == ERROR_SUCCESS || broken(GetLastError() == 0xdeadbeef) /* < win7 */,
3029 "wrong error %u\n", GetLastError());
3030 ok(!size, "expected 0, got %u\n", size);
3031
3032 SetLastError(0xdeadbeef);
3033 ret = WinHttpReadData(req, buf, len, &bytes_read);
3034 ok(ret, "expected success\n");
3035 ok(GetLastError() ==