diff --git a/dlls/winhttp/Makefile.in b/dlls/winhttp/Makefile.in index 893c990..a007251 100644 --- a/dlls/winhttp/Makefile.in +++ b/dlls/winhttp/Makefile.in @@ -3,7 +3,7 @@ TOPOBJDIR = ../.. SRCDIR = @srcdir@ VPATH = @srcdir@ MODULE = winhttp.dll -IMPORTS = kernel32 +IMPORTS = wininet kernel32 C_SRCS = main.c diff --git a/dlls/winhttp/main.c b/dlls/winhttp/main.c index e90352d..9363edf 100644 --- a/dlls/winhttp/main.c +++ b/dlls/winhttp/main.c @@ -1,5 +1,6 @@ /* * Copyright 2007 Jacek Caban for CodeWeavers + * Copyright 2007 Hans Leidekker * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -24,11 +25,278 @@ #include "windef.h" #include "winbase.h" +#include "wininet.h" +#include "winhttp.h" #include "wine/debug.h" +#include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(winhttp); +static inline WCHAR *winhttp_strdup( const WCHAR *src ) +{ + WCHAR *dst; + + if (!src) return NULL; + if ((dst = HeapAlloc( GetProcessHeap(), 0, (strlenW( src ) + 1) * sizeof(WCHAR) ))) + strcpyW( dst, src ); + return dst; +} + +static DWORD map_access(DWORD type) +{ + switch (type) + { + case WINHTTP_ACCESS_TYPE_DEFAULT_PROXY: return INTERNET_OPEN_TYPE_PRECONFIG; + case WINHTTP_ACCESS_TYPE_NO_PROXY: return INTERNET_OPEN_TYPE_DIRECT; + case WINHTTP_ACCESS_TYPE_NAMED_PROXY: return INTERNET_OPEN_TYPE_PROXY; + default: + WARN("unknown access type: %x\n", type); + return INTERNET_OPEN_TYPE_DIRECT; + } +} + +#define QUERY_MODIFIER_FLAGS_MASK ( WINHTTP_QUERY_FLAG_REQUEST_HEADERS \ + | WINHTTP_QUERY_FLAG_SYSTEMTIME \ + | WINHTTP_QUERY_FLAG_NUMBER \ + ) +#define QUERY_HEADER_MASK (~QUERY_MODIFIER_FLAGS_MASK) + +static DWORD map_info_level(DWORD level) +{ + DWORD ret = 0; + + switch (level & QUERY_HEADER_MASK) + { + case WINHTTP_QUERY_MIME_VERSION: ret = HTTP_QUERY_MIME_VERSION; break; + case WINHTTP_QUERY_CONTENT_TYPE: ret = HTTP_QUERY_CONTENT_TYPE; break; + case WINHTTP_QUERY_CONTENT_TRANSFER_ENCODING: ret = HTTP_QUERY_CONTENT_TRANSFER_ENCODING; break; + case WINHTTP_QUERY_CONTENT_ID: ret = HTTP_QUERY_CONTENT_ID; break; + case WINHTTP_QUERY_CONTENT_DESCRIPTION: ret = HTTP_QUERY_CONTENT_DESCRIPTION; break; + case WINHTTP_QUERY_CONTENT_LENGTH: ret = HTTP_QUERY_CONTENT_LENGTH; break; + case WINHTTP_QUERY_CONTENT_LANGUAGE: ret = HTTP_QUERY_CONTENT_LANGUAGE; break; + case WINHTTP_QUERY_ALLOW: ret = HTTP_QUERY_ALLOW; break; + case WINHTTP_QUERY_PUBLIC: ret = HTTP_QUERY_PUBLIC; break; + case WINHTTP_QUERY_DATE: ret = HTTP_QUERY_DATE; break; + case WINHTTP_QUERY_EXPIRES: ret = HTTP_QUERY_EXPIRES; break; + case WINHTTP_QUERY_LAST_MODIFIED: ret = HTTP_QUERY_LAST_MODIFIED; break; + case WINHTTP_QUERY_MESSAGE_ID: ret = HTTP_QUERY_MESSAGE_ID; break; + case WINHTTP_QUERY_URI: ret = HTTP_QUERY_URI; break; + case WINHTTP_QUERY_DERIVED_FROM: ret = HTTP_QUERY_DERIVED_FROM; break; + case WINHTTP_QUERY_COST: ret = HTTP_QUERY_COST; break; + case WINHTTP_QUERY_LINK: ret = HTTP_QUERY_LINK; break; + case WINHTTP_QUERY_PRAGMA: ret = HTTP_QUERY_PRAGMA; break; + case WINHTTP_QUERY_VERSION: ret = HTTP_QUERY_VERSION; break; + case WINHTTP_QUERY_STATUS_CODE: ret = HTTP_QUERY_STATUS_CODE; break; + case WINHTTP_QUERY_STATUS_TEXT: ret = HTTP_QUERY_STATUS_TEXT; break; + case WINHTTP_QUERY_RAW_HEADERS: ret = HTTP_QUERY_RAW_HEADERS; break; + case WINHTTP_QUERY_RAW_HEADERS_CRLF: ret = HTTP_QUERY_RAW_HEADERS_CRLF; break; + case WINHTTP_QUERY_CONNECTION: ret = HTTP_QUERY_CONNECTION; break; + case WINHTTP_QUERY_ACCEPT: ret = HTTP_QUERY_ACCEPT; break; + case WINHTTP_QUERY_ACCEPT_CHARSET: ret = HTTP_QUERY_ACCEPT_CHARSET; break; + case WINHTTP_QUERY_ACCEPT_ENCODING: ret = HTTP_QUERY_ACCEPT_ENCODING; break; + case WINHTTP_QUERY_ACCEPT_LANGUAGE: ret = HTTP_QUERY_ACCEPT_LANGUAGE; break; + case WINHTTP_QUERY_AUTHORIZATION: ret = HTTP_QUERY_AUTHORIZATION; break; + case WINHTTP_QUERY_CONTENT_ENCODING: ret = HTTP_QUERY_CONTENT_ENCODING; break; + case WINHTTP_QUERY_FORWARDED: ret = HTTP_QUERY_FORWARDED; break; + case WINHTTP_QUERY_FROM: ret = HTTP_QUERY_FROM; break; + case WINHTTP_QUERY_IF_MODIFIED_SINCE: ret = HTTP_QUERY_IF_MODIFIED_SINCE; break; + case WINHTTP_QUERY_LOCATION: ret = HTTP_QUERY_LOCATION; break; + case WINHTTP_QUERY_ORIG_URI: ret = HTTP_QUERY_ORIG_URI; break; + case WINHTTP_QUERY_REFERER: ret = HTTP_QUERY_REFERER; break; + case WINHTTP_QUERY_RETRY_AFTER: ret = HTTP_QUERY_RETRY_AFTER; break; + case WINHTTP_QUERY_SERVER: ret = HTTP_QUERY_SERVER; break; + case WINHTTP_QUERY_TITLE: ret = HTTP_QUERY_TITLE; break; + case WINHTTP_QUERY_USER_AGENT: ret = HTTP_QUERY_USER_AGENT; break; + case WINHTTP_QUERY_WWW_AUTHENTICATE: ret = HTTP_QUERY_WWW_AUTHENTICATE; break; + case WINHTTP_QUERY_PROXY_AUTHENTICATE: ret = HTTP_QUERY_PROXY_AUTHENTICATE; break; + case WINHTTP_QUERY_ACCEPT_RANGES: ret = HTTP_QUERY_ACCEPT_RANGES; break; + case WINHTTP_QUERY_SET_COOKIE: ret = HTTP_QUERY_SET_COOKIE; break; + case WINHTTP_QUERY_COOKIE: ret = HTTP_QUERY_COOKIE; break; + case WINHTTP_QUERY_REQUEST_METHOD: ret = HTTP_QUERY_REQUEST_METHOD; break; + case WINHTTP_QUERY_REFRESH: ret = HTTP_QUERY_REFRESH; break; + case WINHTTP_QUERY_CONTENT_DISPOSITION: ret = HTTP_QUERY_CONTENT_DISPOSITION; break; + case WINHTTP_QUERY_AGE: ret = HTTP_QUERY_AGE; break; + case WINHTTP_QUERY_CACHE_CONTROL: ret = HTTP_QUERY_CACHE_CONTROL; break; + case WINHTTP_QUERY_CONTENT_BASE: ret = HTTP_QUERY_CONTENT_BASE; break; + case WINHTTP_QUERY_CONTENT_LOCATION: ret = HTTP_QUERY_CONTENT_LOCATION; break; + case WINHTTP_QUERY_CONTENT_MD5: ret = HTTP_QUERY_CONTENT_MD5; break; + case WINHTTP_QUERY_CONTENT_RANGE: ret = HTTP_QUERY_CONTENT_RANGE; break; + case WINHTTP_QUERY_ETAG: ret = HTTP_QUERY_ETAG; break; + case WINHTTP_QUERY_HOST: ret = HTTP_QUERY_HOST; break; + case WINHTTP_QUERY_IF_MATCH: ret = HTTP_QUERY_IF_MATCH; break; + case WINHTTP_QUERY_IF_NONE_MATCH: ret = HTTP_QUERY_IF_NONE_MATCH; break; + case WINHTTP_QUERY_IF_RANGE: ret = HTTP_QUERY_IF_RANGE; break; + case WINHTTP_QUERY_IF_UNMODIFIED_SINCE: ret = HTTP_QUERY_IF_UNMODIFIED_SINCE; break; + case WINHTTP_QUERY_MAX_FORWARDS: ret = HTTP_QUERY_MAX_FORWARDS; break; + case WINHTTP_QUERY_PROXY_AUTHORIZATION: ret = HTTP_QUERY_PROXY_AUTHORIZATION; break; + case WINHTTP_QUERY_RANGE: ret = HTTP_QUERY_RANGE; break; + case WINHTTP_QUERY_TRANSFER_ENCODING: ret = HTTP_QUERY_TRANSFER_ENCODING; break; + case WINHTTP_QUERY_UPGRADE: ret = HTTP_QUERY_UPGRADE; break; + case WINHTTP_QUERY_VARY: ret = HTTP_QUERY_VARY; break; + case WINHTTP_QUERY_VIA: ret = HTTP_QUERY_VIA; break; + case WINHTTP_QUERY_WARNING: ret = HTTP_QUERY_WARNING; break; + case WINHTTP_QUERY_EXPECT: ret = HTTP_QUERY_EXPECT; break; + case WINHTTP_QUERY_PROXY_CONNECTION: ret = HTTP_QUERY_PROXY_CONNECTION; break; + case WINHTTP_QUERY_UNLESS_MODIFIED_SINCE: ret = HTTP_QUERY_UNLESS_MODIFIED_SINCE; break; + case WINHTTP_QUERY_PROXY_SUPPORT: ret = HTTP_QUERY_PROXY_SUPPORT; break; + case WINHTTP_QUERY_AUTHENTICATION_INFO: ret = HTTP_QUERY_AUTHENTICATION_INFO; break; + case WINHTTP_QUERY_PASSPORT_URLS: ret = HTTP_QUERY_PASSPORT_URLS; break; + case WINHTTP_QUERY_PASSPORT_CONFIG: ret = HTTP_QUERY_PASSPORT_CONFIG; break; + case WINHTTP_QUERY_CUSTOM: ret = HTTP_QUERY_CUSTOM; break; + default: + WARN("unknown info level: %x\n", level); + return 0; + } + if (level & WINHTTP_QUERY_FLAG_REQUEST_HEADERS) ret |= HTTP_QUERY_FLAG_REQUEST_HEADERS; + if (level & WINHTTP_QUERY_FLAG_SYSTEMTIME) ret |= HTTP_QUERY_FLAG_SYSTEMTIME; + if (level & WINHTTP_QUERY_FLAG_NUMBER) ret |= HTTP_QUERY_FLAG_NUMBER; + return ret; +} + +static DWORD map_option(DWORD option, BOOL *retval) +{ + DWORD opt; + + *retval = TRUE; + switch (option) + { + case WINHTTP_OPTION_CALLBACK: opt = INTERNET_OPTION_CALLBACK; break; + case WINHTTP_OPTION_CONNECT_TIMEOUT: opt = INTERNET_OPTION_CONNECT_TIMEOUT; break; + case WINHTTP_OPTION_CONNECT_RETRIES: opt = INTERNET_OPTION_CONNECT_RETRIES; break; + case WINHTTP_OPTION_SEND_TIMEOUT: opt = INTERNET_OPTION_SEND_TIMEOUT; break; + case WINHTTP_OPTION_RECEIVE_TIMEOUT: opt = INTERNET_OPTION_RECEIVE_TIMEOUT; break; + case WINHTTP_OPTION_HANDLE_TYPE: opt = INTERNET_OPTION_HANDLE_TYPE; break; + case WINHTTP_OPTION_READ_BUFFER_SIZE: opt = INTERNET_OPTION_READ_BUFFER_SIZE; break; + case WINHTTP_OPTION_WRITE_BUFFER_SIZE: opt = INTERNET_OPTION_WRITE_BUFFER_SIZE; break; + case WINHTTP_OPTION_PARENT_HANDLE: opt = INTERNET_OPTION_PARENT_HANDLE; break; + case WINHTTP_OPTION_EXTENDED_ERROR: opt = INTERNET_OPTION_EXTENDED_ERROR; break; + case WINHTTP_OPTION_SECURITY_FLAGS: opt = INTERNET_OPTION_SECURITY_FLAGS; break; + case WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT: opt = INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT; break; + case WINHTTP_OPTION_URL: opt = INTERNET_OPTION_URL; break; + case WINHTTP_OPTION_SECURITY_KEY_BITNESS: opt = INTERNET_OPTION_SECURITY_KEY_BITNESS; break; + case WINHTTP_OPTION_PROXY: opt = INTERNET_OPTION_PROXY; break; + case WINHTTP_OPTION_USER_AGENT: opt = INTERNET_OPTION_USER_AGENT; break; + case WINHTTP_OPTION_CONTEXT_VALUE: opt = INTERNET_OPTION_CONTEXT_VALUE; break; + case WINHTTP_OPTION_CLIENT_CERT_CONTEXT: opt = INTERNET_OPTION_SECURITY_SELECT_CLIENT_CERT; break; + case WINHTTP_OPTION_REQUEST_PRIORITY: opt = INTERNET_OPTION_REQUEST_PRIORITY; break; + case WINHTTP_OPTION_HTTP_VERSION: opt = INTERNET_OPTION_HTTP_VERSION; break; + case WINHTTP_OPTION_CODEPAGE: opt = INTERNET_OPTION_CODEPAGE; break; + case WINHTTP_OPTION_MAX_CONNS_PER_SERVER: opt = INTERNET_OPTION_MAX_CONNS_PER_SERVER; break; + case WINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVER: opt = INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER; break; + case WINHTTP_OPTION_USERNAME: opt = INTERNET_OPTION_USERNAME; break; + case WINHTTP_OPTION_PASSWORD: opt = INTERNET_OPTION_PASSWORD; break; + case WINHTTP_OPTION_PROXY_USERNAME: opt = INTERNET_OPTION_PROXY_USERNAME; break; + case WINHTTP_OPTION_PROXY_PASSWORD: opt = INTERNET_OPTION_PROXY_PASSWORD; break; + + case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT: + case WINHTTP_OPTION_RESOLVE_TIMEOUT: + case WINHTTP_OPTION_DISABLE_FEATURE: + case WINHTTP_OPTION_AUTOLOGON_POLICY: + case WINHTTP_OPTION_SERVER_CERT_CONTEXT: + case WINHTTP_OPTION_ENABLE_FEATURE: + case WINHTTP_OPTION_WORKER_THREAD_COUNT: + case WINHTTP_OPTION_PASSPORT_COBRANDING_TEXT: + case WINHTTP_OPTION_PASSPORT_COBRANDING_URL: + case WINHTTP_OPTION_CONFIGURE_PASSPORT_AUTH: + case WINHTTP_OPTION_SECURE_PROTOCOLS: + case WINHTTP_OPTION_ENABLETRACING: + case WINHTTP_OPTION_PASSPORT_SIGN_OUT: + case WINHTTP_OPTION_PASSPORT_RETURN_URL: + case WINHTTP_OPTION_REDIRECT_POLICY: + case WINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTS: + case WINHTTP_OPTION_MAX_HTTP_STATUS_CONTINUE: + case WINHTTP_OPTION_MAX_RESPONSE_HEADER_SIZE: + case WINHTTP_OPTION_MAX_RESPONSE_DRAIN_SIZE: + FIXME("option not supported: %x\n", option); + return 0; + default: + WARN("unknown option: %x\n", option); + *retval = FALSE; + return 0; + } + return opt; +} + +static DWORD map_open_flags(DWORD flags) +{ + DWORD ret = 0; + + if (flags & WINHTTP_FLAG_ASYNC) ret |= INTERNET_FLAG_ASYNC; + return ret; +} + +static DWORD map_req_flags(DWORD flags) +{ + DWORD ret = 0; + + if (flags & WINHTTP_FLAG_SECURE) ret |= INTERNET_FLAG_SECURE; + if (flags & WINHTTP_FLAG_BYPASS_PROXY_CACHE) ret |= INTERNET_FLAG_PRAGMA_NOCACHE; + + if (flags & WINHTTP_FLAG_ESCAPE_PERCENT) FIXME("WINHTTP_FLAG_ESCAPE_PERCENT not implemented\n"); + if (flags & WINHTTP_FLAG_NULL_CODEPAGE) FIXME("WINHTTP_FLAG_NULL_CODEPAGE not implemented\n"); + if (flags & WINHTTP_FLAG_ESCAPE_DISABLE) FIXME("WINHTTP_FLAG_ESCAPE_DISABLE not implemented\n"); + if (flags & WINHTTP_FLAG_ESCAPE_DISABLE_QUERY) FIXME("WINHTTP_FLAG_ESCAPE_DISABLE_QUERY not implemented\n"); + return ret; +} + +static DWORD map_req_modifiers(DWORD modifiers) +{ + DWORD ret = 0; + + if (modifiers & WINHTTP_ADDREQ_FLAG_ADD) ret |= HTTP_ADDREQ_FLAG_ADD; + if (modifiers & WINHTTP_ADDREQ_FLAG_ADD_IF_NEW) ret |= HTTP_ADDREQ_FLAG_ADD_IF_NEW; + if (modifiers & WINHTTP_ADDREQ_FLAG_COALESCE) ret |= HTTP_ADDREQ_FLAG_COALESCE; + if (modifiers & WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA) ret |= HTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA; + if (modifiers & WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON) ret |= HTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON; + if (modifiers & WINHTTP_ADDREQ_FLAG_REPLACE) ret |= HTTP_ADDREQ_FLAG_REPLACE; + return ret; +} + +/*********************************************************************** + * HTTP_EncodeBase64 (taken from dlls/wininet/http.c) + */ +static UINT HTTP_EncodeBase64( LPCSTR bin, unsigned int len, LPWSTR base64 ) +{ + UINT n = 0, x; + static const CHAR HTTP_Base64Enc[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + while( len > 0 ) + { + /* first 6 bits, all from bin[0] */ + base64[n++] = HTTP_Base64Enc[(bin[0] & 0xfc) >> 2]; + x = (bin[0] & 3) << 4; + + /* next 6 bits, 2 from bin[0] and 4 from bin[1] */ + if( len == 1 ) + { + base64[n++] = HTTP_Base64Enc[x]; + base64[n++] = '='; + base64[n++] = '='; + break; + } + base64[n++] = HTTP_Base64Enc[ x | ( (bin[1]&0xf0) >> 4 ) ]; + x = ( bin[1] & 0x0f ) << 2; + + /* next 6 bits 4 from bin[1] and 2 from bin[2] */ + if( len == 2 ) + { + base64[n++] = HTTP_Base64Enc[x]; + base64[n++] = '='; + break; + } + base64[n++] = HTTP_Base64Enc[ x | ( (bin[2]&0xc0 ) >> 6 ) ]; + + /* last 6 bits, all from bin [2] */ + base64[n++] = HTTP_Base64Enc[ bin[2] & 0x3f ]; + bin += 3; + len -= 3; + } + base64[n] = 0; + return n; +} + /****************************************************************** * DllMain (winhttp.@) */ @@ -82,3 +350,475 @@ HRESULT WINAPI DllUnregisterServer(void) FIXME("()\n"); return S_OK; } + +/*********************************************************************** + * WinHttpAddRequestHeaders (winhttp.@) + */ +BOOL WINAPI WinHttpAddRequestHeaders(HINTERNET request, LPCWSTR headers, DWORD len, DWORD modifiers) +{ + TRACE("(%p %s %d %x)\n", request, debugstr_w(headers), len, modifiers); + return HttpAddRequestHeadersW(request, headers, len, map_req_modifiers(modifiers)); +} + +/*********************************************************************** + * WinHttpCheckPlatform (winhttp.@) + */ +BOOL WINAPI WinHttpCheckPlatform(void) +{ + TRACE("()\n"); + return TRUE; +} + +/*********************************************************************** + * WinHttpCloseHandle (winhttp.@) + */ +BOOL WINAPI WinHttpCloseHandle(HINTERNET handle) +{ + TRACE("(%p)\n", handle); + return InternetCloseHandle(handle); +} + +/*********************************************************************** + * WinHttpConnect (winhttp.@) + */ +HINTERNET WINAPI WinHttpConnect(HINTERNET session, LPCWSTR server, INTERNET_PORT port, DWORD reserved) +{ + TRACE("(%p %s %d %x)\n", session, debugstr_w(server), port, reserved); + return InternetConnectW(session, server, port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); +} + +/*********************************************************************** + * WinHttpCrackUrl (winhttp.@) + */ +BOOL WINAPI WinHttpCrackUrl(LPCWSTR url, DWORD len, DWORD flags, LPURL_COMPONENTSW components) +{ + TRACE("(%s %d %x %p)\n", debugstr_w(url), len, flags, components); + return InternetCrackUrlW(url, len, flags, components); +} + +/*********************************************************************** + * WinHttpCreateUrl (winhttp.@) + */ +BOOL WINAPI WinHttpCreateUrl(LPURL_COMPONENTSW components, DWORD flags, LPWSTR url, LPDWORD len) +{ + TRACE("(%p %x %p %p)\n", components, flags, url, len); + return InternetCreateUrlW(components, flags, url, len); +} + +/*********************************************************************** + * WinHttpDetectAutoProxyConfigUrl (winhttp.@) + */ +BOOL WINAPI WinHttpDetectAutoProxyConfigUrl(DWORD flags, LPWSTR *url) +{ + FIXME("(%x %p)\n", flags, url); + + SetLastError(ERROR_WINHTTP_AUTODETECTION_FAILED); + return FALSE; +} + +/*********************************************************************** + * WinHttpGetDefaultProxyConfiguration (winhttp.@) + */ +BOOL WINAPI WinHttpGetDefaultProxyConfiguration(WINHTTP_PROXY_INFO *info) +{ + INTERNET_PROXY_INFOW proxy; + DWORD size; + + TRACE("(%p)\n", info); + + size = sizeof(proxy); + if (!InternetQueryOptionW(NULL, INTERNET_OPTION_PROXY, &proxy, &size)) + return FALSE; + + switch (proxy.dwAccessType) + { + case INTERNET_OPEN_TYPE_PRECONFIG: info->dwAccessType = WINHTTP_ACCESS_TYPE_DEFAULT_PROXY; break; + case INTERNET_OPEN_TYPE_DIRECT: info->dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY; break; + case INTERNET_OPEN_TYPE_PROXY: info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY; break; + default: + ERR("unknown access type: %x\n", proxy.dwAccessType); + return FALSE; + } + info->lpszProxy = winhttp_strdup(proxy.lpszProxy); + info->lpszProxyBypass = winhttp_strdup(proxy.lpszProxyBypass); + + return TRUE; +} + +/*********************************************************************** + * WinHttpGetIEProxyConfigForCurrentUser (winhttp.@) + */ +BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser(WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *config) +{ + TRACE("(%p)\n", config); + return FALSE; +} + +/*********************************************************************** + * WinHttpGetProxyForUrl (winhttp.@) + */ +BOOL WINAPI WinHttpGetProxyForUrl(HINTERNET session, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS *options, + WINHTTP_PROXY_INFO *info) +{ + FIXME("(%p %s %p %p)\n", session, debugstr_w(url), options, info); + return FALSE; +} + +/*********************************************************************** + * WinHttpOpen (winhttp.@) + */ +HINTERNET WINAPI WinHttpOpen(LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags) +{ + TRACE("(%s %x %s %s %x)\n", debugstr_w(agent), access, debugstr_w(proxy), debugstr_w(bypass), flags); + return InternetOpenW(agent, access, proxy, bypass, map_open_flags(flags)); +} + +/*********************************************************************** + * WinHttpOpenRequest (winhttp.@) + */ +HINTERNET WINAPI WinHttpOpenRequest(HINTERNET handle, LPCWSTR verb, LPCWSTR object, LPCWSTR version, + LPCWSTR referrer, LPCWSTR *accept, DWORD flags) +{ + DWORD flags_new; + + TRACE("(%p %s %s %s %s %p %x)\n", handle, debugstr_w(verb), debugstr_w(object), debugstr_w(version), + debugstr_w(referrer), accept, flags); + + flags_new = map_req_flags(flags) | INTERNET_FLAG_KEEP_CONNECTION; + return HttpOpenRequestW(handle, verb, object, version, referrer, accept, flags_new, 0); +} + +#define ARRAYSIZE(array) (sizeof(array) / sizeof((array)[0])) + +static DWORD auth_scheme_from_header(WCHAR *header) +{ + static const WCHAR basic[] = { 'B','a','s','i','c' }; + static const WCHAR ntlm[] = { 'N','T','L','M' }; + static const WCHAR passport[] = { 'P','a','s','s','p','o','r','t' }; + static const WCHAR digest[] = { 'D','i','g','e','s','t' }; + static const WCHAR negotiate[] = { 'N','e','g','o','t','i','a','t','e' }; + + if (!strncmpiW(header, basic, ARRAYSIZE(basic)) && + (header[ARRAYSIZE(basic)] != ' ' || !header[ARRAYSIZE(basic)])) return WINHTTP_AUTH_SCHEME_BASIC; + + if (!strncmpiW(header, ntlm, ARRAYSIZE(ntlm)) && + (header[ARRAYSIZE(ntlm)] != ' ' || !header[ARRAYSIZE(ntlm)])) return WINHTTP_AUTH_SCHEME_NTLM; + + if (!strncmpiW(header, passport, ARRAYSIZE(passport)) && + (header[ARRAYSIZE(passport)] != ' ' || !header[ARRAYSIZE(passport)])) return WINHTTP_AUTH_SCHEME_PASSPORT; + + if (!strncmpiW(header, digest, ARRAYSIZE(digest)) && + (header[ARRAYSIZE(digest)] != ' ' || !header[ARRAYSIZE(digest)])) return WINHTTP_AUTH_SCHEME_DIGEST; + + if (!strncmpiW(header, negotiate, ARRAYSIZE(negotiate)) && + (header[ARRAYSIZE(negotiate)] != ' ' || !header[ARRAYSIZE(negotiate)])) return WINHTTP_AUTH_SCHEME_NEGOTIATE; + + return 0; +} + +static BOOL query_auth_schemes(HINTERNET request, DWORD level, LPDWORD supported, LPDWORD first, LPDWORD target) +{ + DWORD index = 0; + BOOL ret = FALSE; + + *supported = *first = 0; + for (;;) + { + DWORD len, scheme; + WCHAR *buffer; + + len = 0; + HttpQueryInfoW(request, level, NULL, &len, &index); + if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) break; + + index--; + if (!(buffer = HeapAlloc(GetProcessHeap(), 0, len + sizeof(WCHAR)))) return FALSE; + if (!HttpQueryInfoW(request, level, buffer, &len, &index)) + { + HeapFree(GetProcessHeap(), 0, buffer); + return FALSE; + } + scheme = auth_scheme_from_header(buffer); + if (index == 1) *first = scheme; + *supported |= scheme; + + HeapFree(GetProcessHeap(), 0, buffer); + ret = TRUE; + index++; + } + return ret; +} + +/*********************************************************************** + * WinHttpQueryAuthSchemes (winhttp.@) + */ +BOOL WINAPI WinHttpQueryAuthSchemes(HINTERNET request, LPDWORD supported, LPDWORD first, LPDWORD target) +{ + BOOL ret = FALSE; + + TRACE("(%p %p %p %p)\n", request, supported, first, target); + + if (query_auth_schemes(request, HTTP_QUERY_WWW_AUTHENTICATE, supported, first, target)) + { + *target = WINHTTP_AUTH_TARGET_SERVER; + ret = TRUE; + } + if (query_auth_schemes(request, HTTP_QUERY_PROXY_AUTHENTICATE, supported, first, target)) + { + *target |= WINHTTP_AUTH_TARGET_PROXY; + ret = TRUE; + } + return ret; +} + +/*********************************************************************** + * WinHttpQueryDataAvailable (winhttp.@) + */ +BOOL WINAPI WinHttpQueryDataAvailable(HINTERNET request, LPDWORD available) +{ + TRACE("(%p %p)\n", request, available); + return InternetQueryDataAvailable(request, available, 0, 0); +} + +/*********************************************************************** + * WinHttpQueryHeaders (winhttp.@) + */ +BOOL WINAPI WinHttpQueryHeaders(HINTERNET request, DWORD level, LPCWSTR name, LPVOID buffer, + LPDWORD len, LPDWORD index) +{ + TRACE("(%p %d %s %p %p %p)\n", request, level, debugstr_w(name), buffer, len, index); + return HttpQueryInfoW(request, map_info_level(level), buffer, len, index); +} + +/*********************************************************************** + * WinHttpQueryOption (winhttp.@) + */ +BOOL WINAPI WinHttpQueryOption(HINTERNET handle, DWORD option, LPVOID buffer, LPDWORD len) +{ + BOOL ret; + DWORD opt = 0; + + TRACE("(%p %x %p %p)\n", handle, option, buffer, len); + + if (!option || ((opt = map_option(option, &ret)) && ret)) + ret = InternetQueryOptionW(handle, opt, buffer, len); + + return ret; +} + +/*********************************************************************** + * WinHttpReadData (winhttp.@) + */ +BOOL WINAPI WinHttpReadData(HINTERNET request, LPVOID buffer, DWORD to_read, LPDWORD read) +{ + TRACE("(%p %p %d %p)\n", request, buffer, to_read, read); + return InternetReadFile(request, buffer, to_read, read); +} + +/*********************************************************************** + * WinHttpReceiveResponse (winhttp.@) + */ +BOOL WINAPI WinHttpReceiveResponse(HINTERNET request, LPVOID reserved) +{ + TRACE("(%p %p)\n", request, reserved); + return HttpEndRequestW(request, 0, 0, 0); +} + +/*********************************************************************** + * WinHttpSendRequest (winhttp.@) + */ +BOOL WINAPI WinHttpSendRequest(HINTERNET request, LPCWSTR headers, DWORD headers_len, + LPVOID optional, DWORD optional_len, DWORD total_len, DWORD_PTR context) +{ + INTERNET_BUFFERSW buffers; + + TRACE("(%p %s %d %p %d %d %lx)\n", request, debugstr_w(headers), headers_len, optional, + optional_len, total_len, context); + + memset(&buffers, 0, sizeof(buffers)); + buffers.dwStructSize = sizeof(buffers); + if (headers) + { + buffers.lpcszHeader = headers; + if (headers_len == ~0UL) buffers.dwHeadersLength = strlenW(buffers.lpcszHeader) + 1; + else buffers.dwHeadersLength = headers_len; + } + buffers.lpvBuffer = optional; + buffers.dwBufferLength = optional_len; + buffers.dwBufferTotal = total_len; + + return HttpSendRequestExW(request, &buffers, NULL, 0, context); +} + +/*********************************************************************** + * WinHttpSetCredentials (winhttp.@) + */ +BOOL WINAPI WinHttpSetCredentials(HINTERNET request, DWORD target, DWORD scheme, LPCWSTR username, + LPCWSTR password, LPVOID params) +{ + static const WCHAR basic[] = + { 'B','a','s','i','c',' ',0 }; + static const WCHAR auth_server[] = + { 'A','u','t','h','o','r','i','z','a','t','i','o','n',':',' ',0 }; + static const WCHAR auth_proxy[] = + { 'P','r','o','x','y','-','A','u','t','h','o','r','i','z','a','t','i','o','n',':',' ',0 }; + + const WCHAR *auth_scheme, *auth_target; + WCHAR *auth_header; + DWORD len, auth_data_len; + char *auth_data; + BOOL ret; + + TRACE("(%p %x %x %s %s %p)\n", request, target, scheme, debugstr_w(username), + debugstr_w(password), params); + + switch (target) + { + case WINHTTP_AUTH_TARGET_SERVER: auth_target = auth_server; break; + case WINHTTP_AUTH_TARGET_PROXY: auth_target = auth_proxy; break; + default: + ERR("unknown target %x\n", target); + return FALSE; + } + switch (scheme) + { + case WINHTTP_AUTH_SCHEME_BASIC: + { + int userlen = WideCharToMultiByte(CP_UTF8, 0, username, strlenW(username), NULL, 0, NULL, NULL); + int passlen = WideCharToMultiByte(CP_UTF8, 0, password, strlenW(password), NULL, 0, NULL, NULL); + + TRACE("basic authentication\n"); + + auth_scheme = basic; + auth_data_len = userlen + 1 + passlen; + if (!(auth_data = HeapAlloc(GetProcessHeap(), 0, auth_data_len))) return FALSE; + + WideCharToMultiByte(CP_UTF8, 0, username, -1, auth_data, userlen, NULL, NULL); + auth_data[userlen] = ':'; + WideCharToMultiByte(CP_UTF8, 0, password, -1, &auth_data[userlen + 1], passlen, NULL, NULL); + break; + } + case WINHTTP_AUTH_SCHEME_NTLM: + case WINHTTP_AUTH_SCHEME_PASSPORT: + case WINHTTP_AUTH_SCHEME_DIGEST: + case WINHTTP_AUTH_SCHEME_NEGOTIATE: + FIXME("unimplemented authentication scheme %x\n", scheme); + return FALSE; + default: + ERR("unknown authentication scheme %x\n", scheme); + return FALSE; + } + + len = strlenW(auth_target) + strlenW(auth_scheme) + ((auth_data_len + 2) * 4) / 3; + if (!(auth_header = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR)))) + { + HeapFree(GetProcessHeap(), 0, auth_data); + return FALSE; + } + strcpyW(auth_header, auth_target); + strcatW(auth_header, auth_scheme); + HTTP_EncodeBase64(auth_data, auth_data_len, auth_header + strlenW(auth_header)); + + ret = WinHttpSendRequest(request, auth_header, ~0UL, NULL, 0, 0, 0); + + HeapFree(GetProcessHeap(), 0, auth_data); + HeapFree(GetProcessHeap(), 0, auth_header); + return ret; +} + +/*********************************************************************** + * WinHttpSetDefaultProxyConfiguration (winhttp.@) + */ +BOOL WINAPI WinHttpSetDefaultProxyConfiguration(WINHTTP_PROXY_INFO *info) +{ + INTERNET_PROXY_INFOW proxy; + + TRACE("(%p)\n", info); + + proxy.dwAccessType = map_access(info->dwAccessType); + proxy.lpszProxy = info->lpszProxy; + proxy.lpszProxyBypass = info->lpszProxyBypass; + + return InternetSetOptionW(NULL, INTERNET_OPTION_PROXY, &proxy, sizeof(proxy)); +} + +/*********************************************************************** + * WinHttpSetOption (winhttp.@) + */ +BOOL WINAPI WinHttpSetOption(HINTERNET handle, DWORD option, LPVOID buffer, DWORD len) +{ + BOOL ret; + DWORD opt = 0; + + TRACE("(%p %x %p %d)\n", handle, option, buffer, len); + + if (!option || ((opt = map_option(option, &ret)) && ret)) + ret = InternetSetOptionW(handle, opt, buffer, len); + + return ret; +} + +/*********************************************************************** + * WinHttpSetStatusCallback (winhttp.@) + */ +WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback(HINTERNET handle, WINHTTP_STATUS_CALLBACK callback, + DWORD flags, DWORD_PTR reserved) +{ + TRACE("(%p %p %x %lx)\n", handle, callback, flags, reserved); + + if (flags) FIXME("flags not supported\n"); + return InternetSetStatusCallbackW(handle, callback); +} + +/*********************************************************************** + * WinHttpSetTimeouts (winhttp.@) + */ +BOOL WINAPI WinHttpSetTimeouts(HINTERNET handle, int resolve, int connect, int send, int receive) +{ + ULONG timeout; + + TRACE("(%p %d %d %d %d)\n", handle, resolve, connect, send, receive); + + if (resolve < -1 || connect < -1 || send < -1 || receive < -1) + return ERROR_INVALID_PARAMETER; + + if (resolve > 0) FIXME("resolve timeout not supported\n"); + + timeout = (connect > 0) ? connect : 0xffffff; + InternetSetOptionW(handle, INTERNET_OPTION_CONNECT_TIMEOUT, &timeout, sizeof(timeout)); + + timeout = (send > 0) ? send : 0xffffff; + InternetSetOptionW(handle, INTERNET_OPTION_SEND_TIMEOUT, &timeout, sizeof(timeout)); + + timeout = (receive > 0) ? receive : 0xffffff; + InternetSetOptionW(handle, INTERNET_OPTION_RECEIVE_TIMEOUT, &timeout, sizeof(timeout)); + + return TRUE; +} + +/*********************************************************************** + * WinHttpTimeFromSystemTime (winhttp.@) + */ +BOOL WINAPI WinHttpTimeFromSystemTime(const SYSTEMTIME *st, LPWSTR time) +{ + TRACE("(%p %p)\n", st, time); + return InternetTimeFromSystemTimeW(st, INTERNET_RFC1123_FORMAT, time, WINHTTP_TIME_FORMAT_BUFSIZE); +} + +/*********************************************************************** + * WinHttpTimeToSystemTime (winhttp.@) + */ +BOOL WINAPI WinHttpTimeToSystemTime(LPCWSTR time, SYSTEMTIME *st) +{ + TRACE("(%s %p)\n", debugstr_w(time), st); + return InternetTimeToSystemTimeW(time, st, 0); +} + +/*********************************************************************** + * WinHttpWriteData (winhttp.@) + */ +BOOL WINAPI WinHttpWriteData(HINTERNET request, LPCVOID buffer, DWORD to_write, LPDWORD written) +{ + TRACE("(%p %p %d %p)\n", request, buffer, to_write, written); + return InternetWriteFile(request, buffer, to_write, written); +} diff --git a/dlls/winhttp/winhttp.spec b/dlls/winhttp/winhttp.spec index 73eae07..700628e 100644 --- a/dlls/winhttp/winhttp.spec +++ b/dlls/winhttp/winhttp.spec @@ -2,30 +2,30 @@ @ stdcall -private DllGetClassObject(ptr ptr ptr) @ stdcall -private DllRegisterServer() @ stdcall -private DllUnregisterServer() -@ stub WinHttpAddRequestHeaders -@ stub WinHttpCheckPlatform -@ stub WinHttpCloseHandle -@ stub WinHttpConnect -@ stub WinHttpCrackUrl -@ stub WinHttpCreateUrl -@ stub WinHttpDetectAutoProxyConfigUrl -@ stub WinHttpGetDefaultProxyConfiguration -@ stub WinHttpGetIEProxyConfigForCurrentUser -@ stub WinHttpGetProxyForUrl -@ stub WinHttpOpen -@ stub WinHttpOpenRequest -@ stub WinHttpQueryAuthSchemes -@ stub WinHttpQueryDataAvailable -@ stub WinHttpQueryHeaders -@ stub WinHttpQueryOption -@ stub WinHttpReadData -@ stub WinHttpReceiveResponse -@ stub WinHttpSendRequest -@ stub WinHttpSetCredentials -@ stub WinHttpSetDefaultProxyConfiguration -@ stub WinHttpSetOption -@ stub WinHttpSetStatusCallback -@ stub WinHttpSetTimeouts -@ stub WinHttpTimeFromSystemTime -@ stub WinHttpTimeToSystemTime -@ stub WinHttpWriteData +@ stdcall WinHttpAddRequestHeaders(long wstr long long) +@ stdcall WinHttpCheckPlatform() +@ stdcall WinHttpCloseHandle(long) +@ stdcall WinHttpConnect(long wstr long long) +@ stdcall WinHttpCrackUrl(wstr long long ptr) +@ stdcall WinHttpCreateUrl(ptr long ptr ptr) +@ stdcall WinHttpDetectAutoProxyConfigUrl(long ptr) +@ stdcall WinHttpGetDefaultProxyConfiguration(ptr) +@ stdcall WinHttpGetIEProxyConfigForCurrentUser(ptr) +@ stdcall WinHttpGetProxyForUrl(long wstr ptr ptr) +@ stdcall WinHttpOpen(wstr long wstr wstr long) +@ stdcall WinHttpOpenRequest(long wstr wstr wstr wstr ptr long) +@ stdcall WinHttpQueryAuthSchemes(long ptr ptr ptr) +@ stdcall WinHttpQueryDataAvailable(long ptr) +@ stdcall WinHttpQueryHeaders(long long wstr ptr ptr ptr) +@ stdcall WinHttpQueryOption(long long ptr ptr) +@ stdcall WinHttpReadData(long ptr long ptr) +@ stdcall WinHttpReceiveResponse(long ptr) +@ stdcall WinHttpSendRequest(long wstr long ptr long long ptr) +@ stdcall WinHttpSetCredentials(long long long wstr wstr ptr) +@ stdcall WinHttpSetDefaultProxyConfiguration(ptr) +@ stdcall WinHttpSetOption(long long ptr long) +@ stdcall WinHttpSetStatusCallback(long ptr long ptr) +@ stdcall WinHttpSetTimeouts(long long long long long) +@ stdcall WinHttpTimeFromSystemTime(ptr ptr) +@ stdcall WinHttpTimeToSystemTime(wstr ptr) +@ stdcall WinHttpWriteData(long ptr long ptr) diff --git a/dlls/wininet/http.c b/dlls/wininet/http.c index 8c50ec9..b7bdad6 100644 --- a/dlls/wininet/http.c +++ b/dlls/wininet/http.c @@ -2597,13 +2597,6 @@ BOOL WINAPI HTTP_HttpSendRequestW(LPWININETHTTPREQW lpwhr, LPCWSTR lpszHeaders, HTTP_FixURL(lpwhr); - /* add the headers the caller supplied */ - if( lpszHeaders && dwHeaderLength ) - { - HTTP_HttpAddRequestHeadersW(lpwhr, lpszHeaders, dwHeaderLength, - HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REPLACE); - } - HTTP_ProcessHeader(lpwhr, szConnection, lpwhr->hdr.dwFlags & INTERNET_FLAG_KEEP_CONNECTION ? szKeepAlive : szClose, HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE); @@ -2611,6 +2604,13 @@ BOOL WINAPI HTTP_HttpSendRequestW(LPWININETHTTPREQW lpwhr, LPCWSTR lpszHeaders, HTTP_InsertAuthorization(lpwhr); HTTP_InsertProxyAuthorization(lpwhr); + /* add the headers the caller supplied */ + if( lpszHeaders && dwHeaderLength ) + { + HTTP_HttpAddRequestHeadersW(lpwhr, lpszHeaders, dwHeaderLength, + HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REPLACE); + } + requestString = HTTP_BuildHeaderRequestString(lpwhr, lpwhr->lpszVerb, lpwhr->lpszPath, FALSE); TRACE("Request header -> %s\n", debugstr_w(requestString) ); --- /dev/null 2007-04-11 18:08:27.000000000 +0200 +++ b/include/winhttp.h 2007-08-05 21:45:33.000000000 +0200 @@ -0,0 +1,258 @@ +/* + * Copyright (C) 2007 Hans Leidekker + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_WINHTTP_H +#define __WINE_WINHTTP_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define WINHTTP_TIME_FORMAT_BUFSIZE 62 + +#define WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS 0xffffffff + +#define WINHTTP_ERROR_BASE 12000 +#define ERROR_WINHTTP_AUTODETECTION_FAILED (WINHTTP_ERROR_BASE + 180) + +typedef VOID (CALLBACK *WINHTTP_STATUS_CALLBACK)(HINTERNET, DWORD_PTR, DWORD, LPVOID, DWORD); +typedef WINHTTP_STATUS_CALLBACK *LPWINHTTP_STATUS_CALLBACK; + +#define WINHTTP_QUERY_MIME_VERSION 0 +#define WINHTTP_QUERY_CONTENT_TYPE 1 +#define WINHTTP_QUERY_CONTENT_TRANSFER_ENCODING 2 +#define WINHTTP_QUERY_CONTENT_ID 3 +#define WINHTTP_QUERY_CONTENT_DESCRIPTION 4 +#define WINHTTP_QUERY_CONTENT_LENGTH 5 +#define WINHTTP_QUERY_CONTENT_LANGUAGE 6 +#define WINHTTP_QUERY_ALLOW 7 +#define WINHTTP_QUERY_PUBLIC 8 +#define WINHTTP_QUERY_DATE 9 +#define WINHTTP_QUERY_EXPIRES 10 +#define WINHTTP_QUERY_LAST_MODIFIED 11 +#define WINHTTP_QUERY_MESSAGE_ID 12 +#define WINHTTP_QUERY_URI 13 +#define WINHTTP_QUERY_DERIVED_FROM 14 +#define WINHTTP_QUERY_COST 15 +#define WINHTTP_QUERY_LINK 16 +#define WINHTTP_QUERY_PRAGMA 17 +#define WINHTTP_QUERY_VERSION 18 +#define WINHTTP_QUERY_STATUS_CODE 19 +#define WINHTTP_QUERY_STATUS_TEXT 20 +#define WINHTTP_QUERY_RAW_HEADERS 21 +#define WINHTTP_QUERY_RAW_HEADERS_CRLF 22 +#define WINHTTP_QUERY_CONNECTION 23 +#define WINHTTP_QUERY_ACCEPT 24 +#define WINHTTP_QUERY_ACCEPT_CHARSET 25 +#define WINHTTP_QUERY_ACCEPT_ENCODING 26 +#define WINHTTP_QUERY_ACCEPT_LANGUAGE 27 +#define WINHTTP_QUERY_AUTHORIZATION 28 +#define WINHTTP_QUERY_CONTENT_ENCODING 29 +#define WINHTTP_QUERY_FORWARDED 30 +#define WINHTTP_QUERY_FROM 31 +#define WINHTTP_QUERY_IF_MODIFIED_SINCE 32 +#define WINHTTP_QUERY_LOCATION 33 +#define WINHTTP_QUERY_ORIG_URI 34 +#define WINHTTP_QUERY_REFERER 35 +#define WINHTTP_QUERY_RETRY_AFTER 36 +#define WINHTTP_QUERY_SERVER 37 +#define WINHTTP_QUERY_TITLE 38 +#define WINHTTP_QUERY_USER_AGENT 39 +#define WINHTTP_QUERY_WWW_AUTHENTICATE 40 +#define WINHTTP_QUERY_PROXY_AUTHENTICATE 41 +#define WINHTTP_QUERY_ACCEPT_RANGES 42 +#define WINHTTP_QUERY_SET_COOKIE 43 +#define WINHTTP_QUERY_COOKIE 44 +#define WINHTTP_QUERY_REQUEST_METHOD 45 +#define WINHTTP_QUERY_REFRESH 46 +#define WINHTTP_QUERY_CONTENT_DISPOSITION 47 +#define WINHTTP_QUERY_AGE 48 +#define WINHTTP_QUERY_CACHE_CONTROL 49 +#define WINHTTP_QUERY_CONTENT_BASE 50 +#define WINHTTP_QUERY_CONTENT_LOCATION 51 +#define WINHTTP_QUERY_CONTENT_MD5 52 +#define WINHTTP_QUERY_CONTENT_RANGE 53 +#define WINHTTP_QUERY_ETAG 54 +#define WINHTTP_QUERY_HOST 55 +#define WINHTTP_QUERY_IF_MATCH 56 +#define WINHTTP_QUERY_IF_NONE_MATCH 57 +#define WINHTTP_QUERY_IF_RANGE 58 +#define WINHTTP_QUERY_IF_UNMODIFIED_SINCE 59 +#define WINHTTP_QUERY_MAX_FORWARDS 60 +#define WINHTTP_QUERY_PROXY_AUTHORIZATION 61 +#define WINHTTP_QUERY_RANGE 62 +#define WINHTTP_QUERY_TRANSFER_ENCODING 63 +#define WINHTTP_QUERY_UPGRADE 64 +#define WINHTTP_QUERY_VARY 65 +#define WINHTTP_QUERY_VIA 66 +#define WINHTTP_QUERY_WARNING 67 +#define WINHTTP_QUERY_EXPECT 68 +#define WINHTTP_QUERY_PROXY_CONNECTION 69 +#define WINHTTP_QUERY_UNLESS_MODIFIED_SINCE 70 +#define WINHTTP_QUERY_PROXY_SUPPORT 75 +#define WINHTTP_QUERY_AUTHENTICATION_INFO 76 +#define WINHTTP_QUERY_PASSPORT_URLS 77 +#define WINHTTP_QUERY_PASSPORT_CONFIG 78 +#define WINHTTP_QUERY_CUSTOM 65535 + +#define WINHTTP_QUERY_FLAG_REQUEST_HEADERS 0x80000000 +#define WINHTTP_QUERY_FLAG_SYSTEMTIME 0x40000000 +#define WINHTTP_QUERY_FLAG_NUMBER 0x20000000 + +#define WINHTTP_OPTION_CALLBACK 1 +#define WINHTTP_OPTION_RESOLVE_TIMEOUT 2 +#define WINHTTP_OPTION_CONNECT_TIMEOUT 3 +#define WINHTTP_OPTION_CONNECT_RETRIES 4 +#define WINHTTP_OPTION_SEND_TIMEOUT 5 +#define WINHTTP_OPTION_RECEIVE_TIMEOUT 6 +#define WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT 7 +#define WINHTTP_OPTION_HANDLE_TYPE 9 +#define WINHTTP_OPTION_READ_BUFFER_SIZE 12 +#define WINHTTP_OPTION_WRITE_BUFFER_SIZE 13 +#define WINHTTP_OPTION_PARENT_HANDLE 21 +#define WINHTTP_OPTION_EXTENDED_ERROR 24 +#define WINHTTP_OPTION_SECURITY_FLAGS 31 +#define WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT 32 +#define WINHTTP_OPTION_URL 34 +#define WINHTTP_OPTION_SECURITY_KEY_BITNESS 36 +#define WINHTTP_OPTION_PROXY 38 +#define WINHTTP_OPTION_USER_AGENT 41 +#define WINHTTP_OPTION_CONTEXT_VALUE 45 +#define WINHTTP_OPTION_CLIENT_CERT_CONTEXT 47 +#define WINHTTP_OPTION_REQUEST_PRIORITY 58 +#define WINHTTP_OPTION_HTTP_VERSION 59 +#define WINHTTP_OPTION_DISABLE_FEATURE 63 +#define WINHTTP_OPTION_CODEPAGE 68 +#define WINHTTP_OPTION_MAX_CONNS_PER_SERVER 73 +#define WINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVER 74 +#define WINHTTP_OPTION_AUTOLOGON_POLICY 77 +#define WINHTTP_OPTION_SERVER_CERT_CONTEXT 78 +#define WINHTTP_OPTION_ENABLE_FEATURE 79 +#define WINHTTP_OPTION_WORKER_THREAD_COUNT 80 +#define WINHTTP_OPTION_PASSPORT_COBRANDING_TEXT 81 +#define WINHTTP_OPTION_PASSPORT_COBRANDING_URL 82 +#define WINHTTP_OPTION_CONFIGURE_PASSPORT_AUTH 83 +#define WINHTTP_OPTION_SECURE_PROTOCOLS 84 +#define WINHTTP_OPTION_ENABLETRACING 85 +#define WINHTTP_OPTION_PASSPORT_SIGN_OUT 86 +#define WINHTTP_OPTION_PASSPORT_RETURN_URL 87 +#define WINHTTP_OPTION_REDIRECT_POLICY 88 +#define WINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTS 89 +#define WINHTTP_OPTION_MAX_HTTP_STATUS_CONTINUE 90 +#define WINHTTP_OPTION_MAX_RESPONSE_HEADER_SIZE 91 +#define WINHTTP_OPTION_MAX_RESPONSE_DRAIN_SIZE 92 + +#define WINHTTP_OPTION_USERNAME 0x1000 +#define WINHTTP_OPTION_PASSWORD 0x1001 +#define WINHTTP_OPTION_PROXY_USERNAME 0x1002 +#define WINHTTP_OPTION_PROXY_PASSWORD 0x1003 + +#define WINHTTP_QUERY_STATUS_CODE 19 + +#define WINHTTP_QUERY_FLAG_NUMBER 0x20000000 +#define WINHTTP_QUERY_FLAG_SYSTEMTIME 0x40000000 +#define WINHTTP_QUERY_FLAG_REQUEST_HEADERS 0x80000000 + +#define WINHTTP_FLAG_SECURE 0x00800000 +#define WINHTTP_FLAG_ESCAPE_PERCENT 0x00000004 +#define WINHTTP_FLAG_NULL_CODEPAGE 0x00000008 +#define WINHTTP_FLAG_ESCAPE_DISABLE 0x00000040 +#define WINHTTP_FLAG_ESCAPE_DISABLE_QUERY 0x00000080 +#define WINHTTP_FLAG_BYPASS_PROXY_CACHE 0x00000100 +#define WINHTTP_FLAG_REFRESH WINHTTP_FLAG_BYPASS_PROXY_CACHE + +#define WINHTTP_FLAG_ASYNC 0x10000000 + +#define WINHTTP_ADDREQ_FLAG_ADD_IF_NEW 0x10000000 +#define WINHTTP_ADDREQ_FLAG_ADD 0x20000000 +#define WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA 0x40000000 +#define WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON 0x01000000 +#define WINHTTP_ADDREQ_FLAG_COALESCE WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA +#define WINHTTP_ADDREQ_FLAG_REPLACE 0x80000000 + +#define WINHTTP_AUTH_TARGET_SERVER 0x00000000 +#define WINHTTP_AUTH_TARGET_PROXY 0x00000001 + +#define WINHTTP_AUTH_SCHEME_BASIC 0x00000001 +#define WINHTTP_AUTH_SCHEME_NTLM 0x00000002 +#define WINHTTP_AUTH_SCHEME_PASSPORT 0x00000004 +#define WINHTTP_AUTH_SCHEME_DIGEST 0x00000008 +#define WINHTTP_AUTH_SCHEME_NEGOTIATE 0x00000010 + +#define WINHTTP_ACCESS_TYPE_DEFAULT_PROXY 0 +#define WINHTTP_ACCESS_TYPE_NO_PROXY 1 +#define WINHTTP_ACCESS_TYPE_NAMED_PROXY 3 + +typedef struct +{ + DWORD dwAccessType; + LPWSTR lpszProxy; + LPWSTR lpszProxyBypass; +} WINHTTP_PROXY_INFO, *LPWINHTTP_PROXY_INFO; + +typedef struct +{ + DWORD dwFlags; + DWORD dwAutoDetectFlags; + LPCWSTR lpszAutoConfigUrl; + LPVOID lpvReserved; + DWORD dwReserved; + BOOL fAutoLogonIfChallenged; +} WINHTTP_AUTOPROXY_OPTIONS; + +typedef struct +{ + BOOL fAutoDetect; + LPWSTR lpszAutoConfigUrl; + LPWSTR lpszProxy; + LPWSTR lpszProxyBypass; +} WINHTTP_CURRENT_USER_IE_PROXY_CONFIG; + +BOOL WINAPI WinHttpAddRequestHeaders(HINTERNET, LPCWSTR, DWORD, DWORD); +BOOL WINAPI WinHttpCheckPlatform(void); +BOOL WINAPI WinHttpCloseHandle(HINTERNET); +HINTERNET WINAPI WinHttpConnect(HINTERNET, LPCWSTR, INTERNET_PORT, DWORD); +BOOL WINAPI WinHttpCrackUrl(LPCWSTR, DWORD, DWORD, LPURL_COMPONENTSW); +BOOL WINAPI WinHttpCreateUrl(LPURL_COMPONENTSW, DWORD, LPWSTR, LPDWORD); +BOOL WINAPI WinHttpDetectAutoProxyConfigUrl(DWORD flags, LPWSTR *); +BOOL WINAPI WinHttpGetDefaultProxyConfiguration(WINHTTP_PROXY_INFO *); +BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser(WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *); +BOOL WINAPI WinHttpGetProxyForUrl(HINTERNET, LPCWSTR, WINHTTP_AUTOPROXY_OPTIONS *, WINHTTP_PROXY_INFO *); +HINTERNET WINAPI WinHttpOpen(LPCWSTR, DWORD, LPCWSTR, LPCWSTR, DWORD); +HINTERNET WINAPI WinHttpOpenRequest(HINTERNET, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR *, DWORD); +BOOL WINAPI WinHttpQueryAuthSchemes(HINTERNET, LPDWORD, LPDWORD, LPDWORD); +BOOL WINAPI WinHttpQueryDataAvailable(HINTERNET, LPDWORD); +BOOL WINAPI WinHttpQueryHeaders(HINTERNET, DWORD, LPCWSTR, LPVOID, LPDWORD, LPDWORD); +BOOL WINAPI WinHttpQueryOption(HINTERNET, DWORD, LPVOID, LPDWORD); +BOOL WINAPI WinHttpReadData(HINTERNET, LPVOID, DWORD, LPDWORD); +BOOL WINAPI WinHttpReceiveResponse(HINTERNET, LPVOID); +BOOL WINAPI WinHttpSendRequest(HINTERNET, LPCWSTR, DWORD, LPVOID, DWORD, DWORD, DWORD_PTR); +BOOL WINAPI WinHttpSetCredentials(HINTERNET, DWORD, DWORD, LPCWSTR, LPCWSTR, LPVOID); +BOOL WINAPI WinHttpSetDefaultProxyConfiguration(WINHTTP_PROXY_INFO *); +BOOL WINAPI WinHttpSetOption(HINTERNET, DWORD, LPVOID, DWORD); +WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback(HINTERNET, WINHTTP_STATUS_CALLBACK, DWORD, DWORD_PTR); +BOOL WINAPI WinHttpSetTimeouts(HINTERNET, int, int, int, int); +BOOL WINAPI WinHttpTimeFromSystemTime(CONST SYSTEMTIME *, LPWSTR); +BOOL WINAPI WinHttpTimeToSystemTime(LPCWSTR, SYSTEMTIME *); +BOOL WINAPI WinHttpWriteData(HINTERNET, LPCVOID, DWORD, LPDWORD); + +#ifdef __cplusplus +} +#endif + +#endif /* __WINE_WINHTTP_H */ --- /dev/null 2007-04-11 18:08:27.000000000 +0200 +++ b/dlls/winhttp/tests/Makefile.in 2007-08-04 15:26:52.000000000 +0200 @@ -0,0 +1,14 @@ +TOPSRCDIR = @top_srcdir@ +TOPOBJDIR = ../../.. +SRCDIR = @srcdir@ +VPATH = @srcdir@ +TESTDLL = winhttp.dll +IMPORTS = kernel32 + +CTESTS = \ + http.c \ + url.c + +@MAKE_TEST_RULES@ + +@DEPENDENCIES@ # everything below this line is overwritten by make depend --- /dev/null 2007-04-11 18:08:27.000000000 +0200 +++ b/dlls/winhttp/tests/http.c 2007-08-06 14:14:13.000000000 +0200 @@ -0,0 +1,218 @@ +/* + * Copyright 2007 Hans Leidekker + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include + +#include "windows.h" +#include "wininet.h" +#include "winhttp.h" + +#include "wine/test.h" + +static HMODULE winhttp; + +static BOOL (WINAPI *pWinHttpCloseHandle)(HINTERNET); +static HINTERNET (WINAPI *pWinHttpOpen)( LPCWSTR, DWORD, LPCWSTR, LPCWSTR, DWORD ); +static HINTERNET (WINAPI *pWinHttpConnect)(HINTERNET, LPCWSTR, INTERNET_PORT, DWORD); +static HINTERNET (WINAPI *pWinHttpOpenRequest)(HINTERNET, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR *, DWORD); +static BOOL (WINAPI *pWinHttpQueryAuthSchemes)(HINTERNET, LPDWORD, LPDWORD, LPDWORD); +static BOOL (WINAPI *pWinHttpQueryHeaders)(HINTERNET, DWORD, LPCWSTR, LPVOID, LPDWORD, LPDWORD); +static BOOL (WINAPI *pWinHttpReceiveResponse)(HINTERNET, LPVOID); +static BOOL (WINAPI *pWinHttpSendRequest)(HINTERNET, LPCWSTR, DWORD, LPVOID, DWORD, DWORD, DWORD_PTR); +static BOOL (WINAPI *pWinHttpSetCredentials)( HINTERNET, DWORD, DWORD, LPCWSTR, LPCWSTR, LPVOID ); +static BOOL (WINAPI *pWinHttpTimeFromSystemTime)( const SYSTEMTIME *, LPWSTR ); +static BOOL (WINAPI *pWinHttpTimeToSystemTime)( LPCWSTR, SYSTEMTIME * ); + +#define GETFUNCPTR(func) p##func = (void *)GetProcAddress( winhttp, #func ); + +static void init_function_ptrs( void ) +{ + GETFUNCPTR(WinHttpCloseHandle) + GETFUNCPTR(WinHttpConnect) + GETFUNCPTR(WinHttpOpen) + GETFUNCPTR(WinHttpOpenRequest) + GETFUNCPTR(WinHttpQueryAuthSchemes) + GETFUNCPTR(WinHttpQueryHeaders) + GETFUNCPTR(WinHttpReceiveResponse) + GETFUNCPTR(WinHttpSendRequest) + GETFUNCPTR(WinHttpSetCredentials) + GETFUNCPTR(WinHttpTimeFromSystemTime) + GETFUNCPTR(WinHttpTimeToSystemTime) +} + +static void test_wininet( void ) +{ + static const WCHAR agent[] = { 'w','i','n','e','t','e','s','t',0 }; + static const WCHAR server[] = { 'l','o','c','a','l','h','o','s','t',0 }; + static const WCHAR object[] = { '/',0 }; + static const WCHAR verb[] = { 'G','E','T',0 }; + static const WCHAR any[] = { '*',0 }; + + WCHAR auth[] = + { 'A','u','t','h','o','r','i','z','a','t','i','o','n',':',' ','B','a','s','i','c',' ', + 'Z','n','m','o','d','3','m','a','e','F','W','z','P','n','K','j','M','I','W','a','\r','\n',0 }; + + static const WCHAR *types[2] = { any, NULL }; + DWORD status, size; + HINTERNET session, connect, request; + BOOL ret; + + session = InternetOpenW( agent, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0 ); + ok(session != NULL, "InternetOpenW failed\n"); + + connect = InternetConnectW( session, server, 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0 ); + ok(connect != NULL, "InternetConnectW failed\n"); + + request = HttpOpenRequestW( connect, verb, object, NULL, NULL, types, INTERNET_FLAG_KEEP_CONNECTION, 0 ); + ok(request != NULL, "HttpOpenRequestW failed\n"); + + ret = HttpSendRequestW( request, NULL, 0, NULL, 0 ); + ok(ret, "HttpSendRequestW failed\n"); + + size = sizeof(status); + ret = HttpQueryInfoW( request, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, + &status, &size, NULL ); + ok(ret, "HttpQueryInfoW failed\n"); + + ret = HttpSendRequestW( request, auth, ~0UL, NULL, 0 ); + ok(ret, "HttpSendRequestW failed\n"); + + size = sizeof(status); + ret = HttpQueryInfoW( request, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, + &status, &size, NULL ); + ok(ret, "HttpQueryInfoW failed\n"); + ok(status == 200, "request failed: %d\n", status); + + InternetCloseHandle( request ); + InternetCloseHandle( connect ); + InternetCloseHandle( session ); +} + +static void test_WinHttpSetCredentials( void ) +{ + static const WCHAR agent[] = { 'w','i','n','e','t','e','s','t',0 }; + static const WCHAR server[] = { 'l','o','c','a','l','h','o','s','t',0 }; + static const WCHAR object[] = { '/',0 }; + static const WCHAR user[] = { 'u','s','e','r',0 }; + static const WCHAR pwd[] = { 'p','w','d',0 }; + static const WCHAR verb[] = { 'G','E','T',0 }; + static const WCHAR any[] = { '*',0 }; + + static const WCHAR *types[2] = { any, NULL }; + DWORD status, size, supported, first, target; + HINTERNET session, connect, request; + BOOL ret; + + session = pWinHttpOpen( agent, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0 ); + ok(session != NULL, "WinHttpOpen failed\n"); + + connect = pWinHttpConnect( session, server, 80, 0 ); + ok(connect != NULL, "WinHttpConnect failed\n"); + + request = pWinHttpOpenRequest( connect, verb, object, NULL, NULL, types, 0 ); + ok(request != NULL, "WinHttpOpenRequest failed\n"); + + ret = pWinHttpSendRequest( request, NULL, 0, NULL, 0, 0, 0 ); + ok(ret, "WinHttpSendRequest failed\n"); + + ret = pWinHttpReceiveResponse( request, NULL ); + ok(ret, "WinHttpReceiveResponse failed\n"); + + size = sizeof(status); + ret = pWinHttpQueryHeaders( request, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, + NULL, &status, &size, NULL ); + ok(ret, "WinHttpQueryHeaders failed\n"); + + ret = pWinHttpQueryAuthSchemes( request, &supported, &first, &target ); + ok(ret, "WinHttpQueryAuthSchemes failed\n"); + + trace("%x\n", supported); + trace("%x\n", first); + trace("%x\n", target); + + ret = pWinHttpSetCredentials( request, 0, WINHTTP_AUTH_SCHEME_BASIC, user, pwd, NULL ); + ok(ret, "WinHttpSetCredentials failed\n"); + + ret = pWinHttpSendRequest( request, NULL, 0, NULL, 0, 0, 0 ); + ok(ret, "WinHttpSendRequest failed\n"); + + ret = pWinHttpReceiveResponse( request, NULL ); + ok(ret, "WinHttpReceiveResponse failed\n"); + + pWinHttpCloseHandle( request ); + pWinHttpCloseHandle( connect ); + pWinHttpCloseHandle( session ); +} + +static void test_WinHttpTimeFromSystemTime( void ) +{ + BOOL ret; + WCHAR string[WINHTTP_TIME_FORMAT_BUFSIZE]; + static const SYSTEMTIME time = { 2005, 1, 5, 7, 12, 6, 35, 0 }; + static const WCHAR expect[] = + { 'F','r','i',',',' ','0','7',' ','J','a','n',' ','2','0','0','5',' ', + '1','2',':','0','6',':','3','5',' ','G','M','T',0 }; + + ret = pWinHttpTimeFromSystemTime( NULL, string ); + ok(!ret, "WinHttpTimeFromSystemTime failed\n"); + + ret = pWinHttpTimeFromSystemTime( &time, NULL ); + ok(!ret, "WinHttpTimeFromSystemTime failed\n"); + + ret = pWinHttpTimeFromSystemTime( &time, string ); + ok(ret, "WinHttpTimeFromSystemTime failed\n"); + ok(!memcmp( string, expect, sizeof(expect)), "WinHttpTimeFromSystemTime failed\n"); +} + +static void test_WinHttpTimeToSystemTime( void ) +{ + BOOL ret; + SYSTEMTIME time; + static const SYSTEMTIME expect = { 2005, 1, 5, 7, 12, 6, 35, 0 }; + static const WCHAR string[] = + { 'F','r','i',',',' ','0','7',' ','J','a','n',' ','2','0','0','5',' ', + '1','2',':','0','6',':','3','5',' ','G','M','T',0 }; + + ret = pWinHttpTimeToSystemTime( NULL, NULL ); + ok(!ret, "WinHttpTimeToSystemTime succeeded (%u)\n", GetLastError()); + + ret = pWinHttpTimeToSystemTime( NULL, &time ); + ok(!ret, "WinHttpTimeToSystemTime succeeded (%u)\n", GetLastError()); + + ret = pWinHttpTimeToSystemTime( string, NULL ); + ok(!ret, "WinHttpTimeToSystemTime succeeded (%u)\n", GetLastError()); + + ret = pWinHttpTimeToSystemTime( string, &time ); + ok(ret, "WinHttpTimeToSystemTime failed (%u)\n", GetLastError()); + ok(!memcmp( &time, &expect, sizeof(expect)), "WinHttpTimeToSystemTime failed\n"); +} + +START_TEST(http) +{ + if (!(winhttp = LoadLibraryA( "winhttp.dll" ))) + { + skip("winhttp.dll cannot be loaded\n"); + return; + } + init_function_ptrs(); + + test_wininet(); + if (pWinHttpSetCredentials) test_WinHttpSetCredentials(); + if (pWinHttpTimeFromSystemTime) test_WinHttpTimeFromSystemTime(); + if (pWinHttpTimeToSystemTime) test_WinHttpTimeToSystemTime(); +} --- /dev/null 2007-04-11 18:08:27.000000000 +0200 +++ b/dlls/winhttp/tests/url.c 2007-08-04 19:18:21.000000000 +0200 @@ -0,0 +1,169 @@ +/* + * Copyright 2007 Hans Leidekker + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include + +#include "windows.h" +#include "wininet.h" +#include "winhttp.h" + +#include "wine/test.h" + +static HMODULE winhttp; + +BOOL (WINAPI *pWinHttpCrackUrl)( LPCWSTR, DWORD, DWORD, LPURL_COMPONENTSW ); +BOOL (WINAPI *pWinHttpCreateUrl)( LPURL_COMPONENTSW, DWORD, LPWSTR, LPDWORD ); + +#define GETFUNCPTR(func) p##func = (void *)GetProcAddress( winhttp, #func ); + +static void init_function_ptrs( void ) +{ + GETFUNCPTR(WinHttpCrackUrl) + GETFUNCPTR(WinHttpCreateUrl) +} + +static void test_WinHttpCrackUrl(void) +{ + static const WCHAR url[] = { + 'h','t','t','p',':','/','/','u','s','e','r','n','a','m','e',':','p','a','s','s', + 'w','o','r','d','@','1','9','2','.','1','6','8','.','0','.','2','2','/', + 'C','F','I','D','E','/','m','a','i','n','.','c','f','m','?','C','F','S','V','R', + '=','I','D','E','&','A','C','T','I','O','N','=','I','D','E','_','D','E','F','A', + 'U','L','T', 0 }; + URL_COMPONENTSW comp; + WCHAR scheme[20], host[20], user[20], pwd[20], urlpath[50], extra[50]; + DWORD error; + BOOL ret; + + scheme[0] = 0; + host[0] = 0; + user[0] = 0; + pwd[0] = 0; + urlpath[0] = 0; + extra[0] = 0; + + memset( &comp, 0, sizeof(comp) ); + comp.dwStructSize = sizeof(comp); + comp.lpszScheme = scheme; + comp.dwSchemeLength = sizeof(scheme); + comp.lpszHostName = host; + comp.dwHostNameLength = sizeof(host); + comp.lpszUserName = user; + comp.dwUserNameLength = sizeof(user); + comp.lpszPassword = pwd; + comp.dwPasswordLength = sizeof(pwd); + comp.lpszUrlPath = urlpath; + comp.dwUrlPathLength = sizeof(urlpath); + comp.lpszExtraInfo = extra; + comp.dwExtraInfoLength = sizeof(extra); + + SetLastError( 0xdeadbeef ); + ret = pWinHttpCrackUrl( NULL, 0, 0, &comp ); + ok(!ret, "WinHttpCrackUrl failed\n"); + error = GetLastError(); + ok(error == ERROR_INVALID_PARAMETER , "last error %u\n", error); + + SetLastError( 0xdeadbeef ); + ret = pWinHttpCrackUrl( url, 0, 0, NULL ); + ok(!ret, "WinHttpCrackUrl failed\n"); + error = GetLastError(); + ok(error == ERROR_INVALID_PARAMETER , "last error %u\n", error); + + SetLastError( 0xdeadbeef ); + ret = pWinHttpCrackUrl( url, 0, 0, &comp ); + ok(ret, "WinHttpCrackUrl failed\n"); + error = GetLastError(); + ok(error == ERROR_SUCCESS , "last error %u\n", error); + ok(comp.dwSchemeLength == 4, "scheme length wrong, got %d\n", comp.dwSchemeLength); + ok(comp.dwHostNameLength == 12, "host length wrong, got %d\n", comp.dwHostNameLength); + ok(comp.dwUserNameLength == 8, "user length wrong, got %d\n", comp.dwUserNameLength); + ok(comp.dwPasswordLength == 8, "password length wrong, got %d\n", comp.dwPasswordLength); + ok(comp.dwUrlPathLength == 15, "url length wrong, got %d\n", comp.dwUrlPathLength); + ok(comp.dwExtraInfoLength == 29, "extra length wrong, got %d\n", comp.dwExtraInfoLength); +} + +static void test_WinHttpCreateUrl(void) +{ + static WCHAR empty[] = { 0 }; + static WCHAR http[] = { 'h','t','t','p',0 }; + static WCHAR winehq[] = { 'w','w','w','.','w','i','n','e','h','q','.','o','r','g',0 }; + static WCHAR username[] = { 'u','s','e','r','n','a','m','e',0 }; + static WCHAR password[] = { 'p','a','s','s','w','o','r','d',0 }; + static WCHAR site_about[] = { '/','s','i','t','e','/','a','b','o','u','t',0 }; + + URL_COMPONENTSW comp; + DWORD error, len; + WCHAR url[0x100]; + BOOL ret; + + memset( &comp, 0, sizeof(comp) ); + comp.dwStructSize = sizeof(URL_COMPONENTSW); + comp.lpszScheme = http; + comp.dwSchemeLength = 0; + comp.nScheme = INTERNET_SCHEME_HTTP; + comp.lpszHostName = winehq; + comp.dwHostNameLength = 0; + comp.nPort = 80; + comp.lpszUserName = username; + comp.dwUserNameLength = 0; + comp.lpszPassword = password; + comp.dwPasswordLength = 0; + comp.lpszUrlPath = site_about; + comp.dwUrlPathLength = 0; + comp.lpszExtraInfo = empty; + comp.dwExtraInfoLength = 0; + + SetLastError( 0xdeadbeef ); + ret = pWinHttpCreateUrl( NULL, 0, NULL, NULL ); + ok(!ret, "WinHttpCreateUrl failed\n"); + error = GetLastError(); + ok(error == ERROR_INVALID_PARAMETER , "last error %u\n", error); + + SetLastError( 0xdeadbeef ); + ret = pWinHttpCreateUrl( &comp, 0, NULL, NULL ); + ok(!ret, "WinHttpCreateUrl failed\n"); + error = GetLastError(); + ok(error == ERROR_INVALID_PARAMETER , "last error %u\n", error); + + SetLastError( 0xdeadbeef ); + ret = pWinHttpCreateUrl( &comp, 0, url, NULL ); + ok(!ret, "WinHttpCreateUrl failed\n"); + error = GetLastError(); + ok(error == ERROR_INVALID_PARAMETER , "last error %u\n", error); + + len = sizeof(url) / sizeof(WCHAR); + SetLastError( 0xdeadbeef ); + ret = pWinHttpCreateUrl( &comp, 0, url, &len ); + ok(ret, "WinHttpCreateUrl failed\n"); + error = GetLastError(); + ok(error == ERROR_SUCCESS , "last error %u\n", error); + ok(len == 50 , "len %u\n", len); +} + +START_TEST(url) +{ + if (!(winhttp = LoadLibraryA( "winhttp.dll" ))) + { + skip("winhttp.dll cannot be loaded\n"); + return; + } + init_function_ptrs(); + + if (pWinHttpCrackUrl) test_WinHttpCrackUrl(); + if (pWinHttpCreateUrl) test_WinHttpCreateUrl(); +}