#include "config.h"
#include <stdarg.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "winsock2.h"
#include "ws2ipdef.h"
#include "ws2tcpip.h"
#include "winhttp.h"
#include "winreg.h"
#include "wine/winternl.h"
#include "ole2.h"
#include "dispex.h"
#include "activscp.h"
#include "wine/debug.h"
#include "winhttp_private.h"

Include dependency graph for session.c:

Classes
struct	connection_settings_header

struct	AUTO_PROXY_SCRIPT_BUFFER

Macros
#define	COBJMACROS

#define	DEFAULT_RESOLVE_TIMEOUT 0

#define	DEFAULT_CONNECT_TIMEOUT 20000

#define	DEFAULT_SEND_TIMEOUT 30000

#define	DEFAULT_RECEIVE_TIMEOUT 30000

#define	DEFAULT_RECEIVE_RESPONSE_TIMEOUT ~0u

#define	MAX_HOST_NAME_LENGTH 256

#define	INTERNET_MAX_URL_LENGTH 2084

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (winhttp)

void	send_callback (struct object_header hdr, DWORD status, void info, DWORD buflen)

BOOL WINAPI	WinHttpCheckPlatform (void)

static void	session_destroy (struct object_header *hdr)

static BOOL	session_query_option (struct object_header hdr, DWORD option, void buffer, DWORD *buflen)

static BOOL	session_set_option (struct object_header hdr, DWORD option, void buffer, DWORD buflen)

HINTERNET WINAPI	WinHttpOpen (LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags)

static void	connect_destroy (struct object_header *hdr)

static BOOL	connect_query_option (struct object_header hdr, DWORD option, void buffer, DWORD *buflen)

static BOOL	domain_matches (LPCWSTR server, LPCWSTR domain)

static BOOL	should_bypass_proxy (struct session *session, LPCWSTR server)

BOOL	set_server_for_hostname (struct connect connect, const WCHAR server, INTERNET_PORT port)

HINTERNET WINAPI	WinHttpConnect (HINTERNET hsession, LPCWSTR server, INTERNET_PORT port, DWORD reserved)

static void	request_destroy (struct object_header *hdr)

static void	str_to_buffer (WCHAR buffer, const WCHAR str, LPDWORD buflen)

static WCHAR *	blob_to_str (DWORD encoding, CERT_NAME_BLOB *blob)

static BOOL	copy_sockaddr (const struct sockaddr addr, SOCKADDR_STORAGE addr_storage)

static BOOL	request_query_option (struct object_header hdr, DWORD option, void buffer, DWORD *buflen)

static WCHAR *	buffer_to_str (WCHAR *buffer, DWORD buflen)

static BOOL	request_set_option (struct object_header hdr, DWORD option, void buffer, DWORD buflen)

static BOOL	add_accept_types_header (struct request request, const WCHAR *types)

static WCHAR *	get_request_path (const WCHAR *object)

HINTERNET WINAPI	WinHttpOpenRequest (HINTERNET hconnect, LPCWSTR verb, LPCWSTR object, LPCWSTR version, LPCWSTR referrer, LPCWSTR *types, DWORD flags)

BOOL WINAPI	WinHttpCloseHandle (HINTERNET handle)

static BOOL	query_option (struct object_header hdr, DWORD option, void buffer, DWORD *buflen)

BOOL WINAPI	WinHttpQueryOption (HINTERNET handle, DWORD option, LPVOID buffer, LPDWORD buflen)

static BOOL	set_option (struct object_header hdr, DWORD option, void buffer, DWORD buflen)

BOOL WINAPI	WinHttpSetOption (HINTERNET handle, DWORD option, LPVOID buffer, DWORD buflen)

static char *	get_computer_name (COMPUTER_NAME_FORMAT format)

static BOOL	is_domain_suffix (const char domain, const char suffix)

static int	reverse_lookup (const struct addrinfo ai, char hostname, size_t len)

static WCHAR *	build_wpad_url (const char hostname, const struct addrinfo ai)

static BOOL	get_system_proxy_autoconfig_url (char *buf, DWORD buflen)

BOOL WINAPI	WinHttpDetectAutoProxyConfigUrl (DWORD flags, LPWSTR *url)

static void	copy_char_to_wchar_sz (const BYTE src, DWORD len, WCHAR dst)

BOOL WINAPI	WinHttpGetDefaultProxyConfiguration (WINHTTP_PROXY_INFO *info)

BOOL WINAPI	WinHttpGetIEProxyConfigForCurrentUser (WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *config)

static BOOL	parse_script_result (const char result, WINHTTP_PROXY_INFO info)

static char *	download_script (const WCHAR url, DWORD out_size)

BOOL WINAPI	InternetDeInitializeAutoProxyDll (LPSTR, DWORD)

BOOL WINAPI	InternetGetProxyInfo (LPCSTR, DWORD, LPSTR, DWORD, LPSTR *, LPDWORD)

BOOL WINAPI	InternetInitializeAutoProxyDll (DWORD, LPSTR, LPSTR, void , struct AUTO_PROXY_SCRIPT_BUFFER )

static BOOL	run_script (char script, DWORD size, const WCHAR url, WINHTTP_PROXY_INFO *info)

BOOL WINAPI	WinHttpGetProxyForUrl (HINTERNET hsession, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS options, WINHTTP_PROXY_INFO info)

BOOL WINAPI	WinHttpSetDefaultProxyConfiguration (WINHTTP_PROXY_INFO *info)

WINHTTP_STATUS_CALLBACK WINAPI	WinHttpSetStatusCallback (HINTERNET handle, WINHTTP_STATUS_CALLBACK callback, DWORD flags, DWORD_PTR reserved)

BOOL WINAPI	WinHttpSetTimeouts (HINTERNET handle, int resolve, int connect, int send, int receive)

BOOL WINAPI	WinHttpTimeFromSystemTime (const SYSTEMTIME *time, LPWSTR string)

BOOL WINAPI	WinHttpTimeToSystemTime (LPCWSTR string, SYSTEMTIME *time)

Variables
static const struct object_vtbl	session_vtbl

static const struct object_vtbl	connect_vtbl

static const struct object_vtbl	request_vtbl

static const WCHAR	Connections []

static const WCHAR	WinHttpSettings []

static const DWORD	WINHTTP_SETTINGS_MAGIC = 0x18

static const DWORD	WININET_SETTINGS_MAGIC = 0x46

static const DWORD	PROXY_TYPE_DIRECT = 1

static const DWORD	PROXY_TYPE_PROXY = 2

static const DWORD	PROXY_USE_PAC_SCRIPT = 4

static const DWORD	PROXY_AUTODETECT_SETTINGS = 8

static const WCHAR	wkday [7][4]

static const WCHAR	month [12][4]

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 39 of file session.c.

◆ DEFAULT_CONNECT_TIMEOUT

#define DEFAULT_CONNECT_TIMEOUT 20000

Definition at line 50 of file session.c.

◆ DEFAULT_RECEIVE_RESPONSE_TIMEOUT

#define DEFAULT_RECEIVE_RESPONSE_TIMEOUT ~0u

Definition at line 53 of file session.c.

◆ DEFAULT_RECEIVE_TIMEOUT

#define DEFAULT_RECEIVE_TIMEOUT 30000

Definition at line 52 of file session.c.

◆ DEFAULT_RESOLVE_TIMEOUT

#define DEFAULT_RESOLVE_TIMEOUT 0

Definition at line 49 of file session.c.

◆ DEFAULT_SEND_TIMEOUT

#define DEFAULT_SEND_TIMEOUT 30000

Definition at line 51 of file session.c.

◆ INTERNET_MAX_URL_LENGTH

#define INTERNET_MAX_URL_LENGTH 2084

Definition at line 1418 of file session.c.

◆ MAX_HOST_NAME_LENGTH

#define MAX_HOST_NAME_LENGTH 256

Definition at line 443 of file session.c.

Function Documentation

◆ add_accept_types_header()

static BOOL add_accept_types_header	(	struct request *	request,
		const WCHAR **	types
	)

static

Definition at line 1087 of file session.c.

 {
     static const WCHAR acceptW[] = {'A','c','c','e','p','t',0};
     static const DWORD flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA;
 
     if (!types) return TRUE;
     while (*types)
     {
         if (!process_header( request, acceptW, *types, flags, TRUE )) return FALSE;
         types++;
     }
     return TRUE;
 }

Referenced by WinHttpOpenRequest().

◆ blob_to_str()

static WCHAR* blob_to_str	(	DWORD	encoding,
		CERT_NAME_BLOB *	blob
	)

static

Definition at line 672 of file session.c.

 {
     WCHAR *ret;
     DWORD size, format = CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG;
 
     size = CertNameToStrW( encoding, blob, format, NULL, 0 );
     if ((ret = LocalAlloc( 0, size * sizeof(WCHAR) )))
         CertNameToStrW( encoding, blob, format, ret, size );
 
     return ret;
 }

Referenced by request_query_option().

◆ buffer_to_str()

static WCHAR* buffer_to_str	(	WCHAR *	buffer,
		DWORD	buflen
	)

static

Definition at line 876 of file session.c.

 {
     WCHAR *ret;
     if ((ret = heap_alloc( (buflen + 1) * sizeof(WCHAR))))
     {
         memcpy( ret, buffer, buflen * sizeof(WCHAR) );
         ret[buflen] = 0;
         return ret;
     }
     SetLastError( ERROR_OUTOFMEMORY );
     return NULL;
 }

Referenced by request_set_option().

◆ build_wpad_url()

static WCHAR* build_wpad_url	(	const char *	hostname,
		const struct addrinfo *	ai
	)

static

Definition at line 1362 of file session.c.

 {
     static const WCHAR httpW[] = {'h','t','t','p',':','/','/',0};
     static const WCHAR wpadW[] = {'/','w','p','a','d','.','d','a','t',0};
     char name[NI_MAXHOST];
     WCHAR *ret, *p;
     int len;
 
     while (ai && ai->ai_family != AF_INET && ai->ai_family != AF_INET6) ai = ai->ai_next;
     if (!ai) return NULL;
 
     if (!reverse_lookup( ai, name, sizeof(name) )) hostname = name;
 
     len = strlenW( httpW ) + strlen( hostname ) + strlenW( wpadW );
     if (!(ret = p = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) return NULL;
     strcpyW( p, httpW );
     p += strlenW( httpW );
     while (*hostname) { *p++ = *hostname++; }
     strcpyW( p, wpadW );
     return ret;
 }

Referenced by WinHttpDetectAutoProxyConfigUrl().

◆ connect_destroy()

static void connect_destroy ( struct object_header * hdr )

static

Definition at line 318 of file session.c.

 {
     struct connect *connect = (struct connect *)hdr;
 
     TRACE("%p\n", connect);
 
     release_object( &connect->session->hdr );
 
     heap_free( connect->hostname );
     heap_free( connect->servername );
     heap_free( connect->username );
     heap_free( connect->password );
     heap_free( connect );
 }

◆ connect_query_option()

static BOOL connect_query_option	(	struct object_header *	hdr,
		DWORD	option,
		void *	buffer,
		DWORD *	buflen
	)

static

Definition at line 333 of file session.c.

 {
     struct connect *connect = (struct connect *)hdr;
 
     switch (option)
     {
     case WINHTTP_OPTION_PARENT_HANDLE:
     {
         if (!buffer || *buflen < sizeof(HINTERNET))
         {
             *buflen = sizeof(HINTERNET);
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         *(HINTERNET *)buffer = ((struct object_header *)connect->session)->handle;
         *buflen = sizeof(HINTERNET);
         return TRUE;
     }
     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
         *(DWORD *)buffer = connect->session->resolve_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_CONNECT_TIMEOUT:
         *(DWORD *)buffer = connect->session->connect_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_SEND_TIMEOUT:
         *(DWORD *)buffer = connect->session->send_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
         *(DWORD *)buffer = connect->session->receive_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
         *(DWORD *)buffer = connect->session->receive_response_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     default:
         FIXME("unimplemented option %u\n", option);
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
 }

◆ copy_char_to_wchar_sz()

static void copy_char_to_wchar_sz	(	const BYTE *	src,
		DWORD	len,
		WCHAR *	dst
	)

inlinestatic

Definition at line 1525 of file session.c.

 {
     const BYTE *begin;
 
     for (begin = src; src - begin < len; src++, dst++)
         *dst = *src;
     *dst = 0;
 }

Referenced by WinHttpGetDefaultProxyConfiguration(), and WinHttpGetIEProxyConfigForCurrentUser().

◆ copy_sockaddr()

static BOOL copy_sockaddr	(	const struct sockaddr *	addr,
		SOCKADDR_STORAGE *	addr_storage
	)

static

Definition at line 684 of file session.c.

 {
     switch (addr->sa_family)
     {
     case AF_INET:
     {
         struct sockaddr_in *addr_in = (struct sockaddr_in *)addr_storage;
 
         memcpy( addr_in, addr, sizeof(*addr_in) );
         memset( addr_in + 1, 0, sizeof(*addr_storage) - sizeof(*addr_in) );
         return TRUE;
     }
     case AF_INET6:
     {
         struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr_storage;
 
         memcpy( addr_in6, addr, sizeof(*addr_in6) );
         memset( addr_in6 + 1, 0, sizeof(*addr_storage) - sizeof(*addr_in6) );
         return TRUE;
     }
     default:
         ERR("unhandled family %u\n", addr->sa_family);
         return FALSE;
     }
 }

Referenced by request_query_option().

◆ domain_matches()

static BOOL domain_matches	(	LPCWSTR	server,
		LPCWSTR	domain
	)

static

Definition at line 391 of file session.c.

 {
     static const WCHAR localW[] = { '<','l','o','c','a','l','>',0 };
     BOOL ret = FALSE;
 
     if (!strcmpiW( domain, localW ) && !strchrW( server, '.' ))
         ret = TRUE;
     else if (*domain == '*')
     {
         if (domain[1] == '.')
         {
             LPCWSTR dot;
 
             /* For a hostname to match a wildcard, the last domain must match
              * the wildcard exactly.  E.g. if the wildcard is *.a.b, and the
              * hostname is www.foo.a.b, it matches, but a.b does not.
              */
             dot = strchrW( server, '.' );
             if (dot)
             {
                 int len = strlenW( dot + 1 );
 
                 if (len > strlenW( domain + 2 ))
                 {
                     LPCWSTR ptr;
 
                     /* The server's domain is longer than the wildcard, so it
                      * could be a subdomain.  Compare the last portion of the
                      * server's domain.
                      */
                     ptr = dot + len + 1 - strlenW( domain + 2 );
                     if (!strcmpiW( ptr, domain + 2 ))
                     {
                         /* This is only a match if the preceding character is
                          * a '.', i.e. that it is a matching domain.  E.g.
                          * if domain is '*.b.c' and server is 'www.ab.c' they
                          * do not match.
                          */
                         ret = *(ptr - 1) == '.';
                     }
                 }
                 else
                     ret = !strcmpiW( dot + 1, domain + 2 );
             }
         }
     }
     else
         ret = !strcmpiW( server, domain );
     return ret;
 }

Referenced by should_bypass_proxy().

◆ download_script()

static char* download_script	(	const WCHAR *	url,
		DWORD *	out_size
	)

static

Definition at line 1778 of file session.c.

 {
     static const WCHAR typeW[] = {'*','/','*',0};
     static const WCHAR *acceptW[] = {typeW, NULL};
     HINTERNET ses, con = NULL, req = NULL;
     WCHAR *hostname;
     URL_COMPONENTSW uc;
     DWORD status, size = sizeof(status), offset, to_read, bytes_read, flags = 0;
     char *tmp, *buffer = NULL;
 
     *out_size = 0;
 
     memset( &uc, 0, sizeof(uc) );
     uc.dwStructSize = sizeof(uc);
     uc.dwHostNameLength = -1;
     uc.dwUrlPathLength = -1;
     if (!WinHttpCrackUrl( url, 0, 0, &uc )) return NULL;
     if (!(hostname = heap_alloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) return NULL;
     memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
     hostname[uc.dwHostNameLength] = 0;
 
     if (!(ses = WinHttpOpen( NULL, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0 ))) goto done;
     if (!(con = WinHttpConnect( ses, hostname, uc.nPort, 0 ))) goto done;
     if (uc.nScheme == INTERNET_SCHEME_HTTPS) flags |= WINHTTP_FLAG_SECURE;
     if (!(req = WinHttpOpenRequest( con, NULL, uc.lpszUrlPath, NULL, NULL, acceptW, flags ))) goto done;
     if (!WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 )) goto done;
 
     if (!(WinHttpReceiveResponse( req, 0 ))) goto done;
     if (!WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE|WINHTTP_QUERY_FLAG_NUMBER, NULL, &status,
         &size, NULL ) || status != HTTP_STATUS_OK) goto done;
 
     size = 4096;
     if (!(buffer = heap_alloc( size ))) goto done;
     to_read = size;
     offset = 0;
     for (;;)
     {
         if (!WinHttpReadData( req, buffer + offset, to_read, &bytes_read )) goto done;
         if (!bytes_read) break;
         to_read -= bytes_read;
         offset += bytes_read;
         *out_size += bytes_read;
         if (!to_read)
         {
             to_read = size;
             size *= 2;
             if (!(tmp = heap_realloc( buffer, size ))) goto done;
             buffer = tmp;
         }
     }
 
 done:
     WinHttpCloseHandle( req );
     WinHttpCloseHandle( con );
     WinHttpCloseHandle( ses );
     heap_free( hostname );
     if (!buffer) SetLastError( ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT );
     return buffer;
 }

Referenced by WinHttpGetProxyForUrl().

◆ get_computer_name()

static char* get_computer_name ( COMPUTER_NAME_FORMAT format )

static

Definition at line 1332 of file session.c.

 {
     char *ret;
     DWORD size = 0;
 
     GetComputerNameExA( format, NULL, &size );
     if (GetLastError() != ERROR_MORE_DATA) return NULL;
     if (!(ret = heap_alloc( size ))) return NULL;
     if (!GetComputerNameExA( format, ret, &size ))
     {
         heap_free( ret );
         return NULL;
     }
     return ret;
 }

Referenced by WinHttpDetectAutoProxyConfigUrl().

◆ get_request_path()

static WCHAR* get_request_path ( const WCHAR * object )

static

Definition at line 1101 of file session.c.

 {
     int len = object ? strlenW(object) : 0;
     WCHAR *p, *ret;
 
     if (!object || object[0] != '/') len++;
     if (!(p = ret = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
     if (!object || object[0] != '/') *p++ = '/';
     if (object) strcpyW( p, object );
     ret[len] = 0;
     return ret;
 }

Referenced by WinHttpOpenRequest().

◆ get_system_proxy_autoconfig_url()

static BOOL get_system_proxy_autoconfig_url	(	char *	buf,
		DWORD	buflen
	)

static

Definition at line 1384 of file session.c.

 {
 #if defined(MAC_OS_X_VERSION_10_6) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
     CFDictionaryRef settings = CFNetworkCopySystemProxySettings();
     const void *ref;
     BOOL ret = FALSE;
 
     if (!settings) return FALSE;
 
     if (!(ref = CFDictionaryGetValue( settings, kCFNetworkProxiesProxyAutoConfigURLString )))
     {
         CFRelease( settings );
         return FALSE;
     }
     if (CFStringGetCString( ref, buf, buflen, kCFStringEncodingASCII ))
     {
         TRACE( "returning %s\n", debugstr_a(buf) );
         ret = TRUE;
     }
     CFRelease( settings );
     return ret;
 #else
     static BOOL first = TRUE;
     if (first)
     {
         FIXME( "no support on this platform\n" );
         first = FALSE;
     }
     else
         TRACE( "no support on this platform\n" );
     return FALSE;
 #endif
 }

Referenced by WinHttpDetectAutoProxyConfigUrl().

◆ InternetDeInitializeAutoProxyDll()

BOOL WINAPI InternetDeInitializeAutoProxyDll	(	LPSTR	,
		DWORD
	)

Definition at line 111 of file main.c.

 {
     TRACE( "%s, %u\n", debugstr_a(mime), reserved );
 
     EnterCriticalSection( &cs_jsproxy );
 
     heap_free( global_script->text );
     global_script->text = NULL;
 
     LeaveCriticalSection( &cs_jsproxy );
     return TRUE;
 }

Referenced by run_script().

◆ InternetGetProxyInfo()

BOOL WINAPI InternetGetProxyInfo	(	LPCSTR	,
		DWORD	,
		LPSTR	,
		DWORD	,
		LPSTR *	,
		LPDWORD
	)

Referenced by run_script().

◆ InternetInitializeAutoProxyDll()

BOOL WINAPI InternetInitializeAutoProxyDll	(	DWORD	,
		LPSTR	,
		LPSTR	,
		void *	,
		struct AUTO_PROXY_SCRIPT_BUFFER *
	)

Referenced by run_script().

◆ is_domain_suffix()

static BOOL is_domain_suffix	(	const char *	domain,
		const char *	suffix
	)

static

Definition at line 1348 of file session.c.

 {
     int len_domain = strlen( domain ), len_suffix = strlen( suffix );
 
     if (len_suffix > len_domain) return FALSE;
     if (!_strnicmp( domain + len_domain - len_suffix, suffix, -1 )) return TRUE;
     return FALSE;
 }

Referenced by WinHttpDetectAutoProxyConfigUrl().

◆ parse_script_result()

static BOOL parse_script_result	(	const char *	result,
		WINHTTP_PROXY_INFO *	info
	)

static

Definition at line 1744 of file session.c.

 {
     const char *p;
     WCHAR *q;
     int len;
 
     info->dwAccessType    = WINHTTP_ACCESS_TYPE_NO_PROXY;
     info->lpszProxy       = NULL;
     info->lpszProxyBypass = NULL;
 
     TRACE("%s\n", debugstr_a( result ));
 
     p = result;
     while (*p == ' ') p++;
     len = strlen( p );
     if (len >= 5 && !_strnicmp( p, "PROXY", sizeof("PROXY") - 1 ))
     {
         p += 5;
         while (*p == ' ') p++;
         if (!*p || *p == ';') return TRUE;
         if (!(info->lpszProxy = q = strdupAW( p ))) return FALSE;
         info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
         for (; *q; q++)
         {
             if (*q == ' ' || *q == ';')
             {
                 *q = 0;
                 break;
             }
         }
     }
     return TRUE;
 }

Referenced by run_script().

◆ query_option()

static BOOL query_option	(	struct object_header *	hdr,
		DWORD	option,
		void *	buffer,
		DWORD *	buflen
	)

static

Definition at line 1212 of file session.c.

 {
     BOOL ret = FALSE;
 
     if (!buflen)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
 
     switch (option)
     {
     case WINHTTP_OPTION_CONTEXT_VALUE:
     {
         if (!buffer || *buflen < sizeof(DWORD_PTR))
         {
             *buflen = sizeof(DWORD_PTR);
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         *(DWORD_PTR *)buffer = hdr->context;
         *buflen = sizeof(DWORD_PTR);
         return TRUE;
     }
     default:
         if (hdr->vtbl->query_option) ret = hdr->vtbl->query_option( hdr, option, buffer, buflen );
         else
         {
             FIXME("unimplemented option %u\n", option);
             SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
             return FALSE;
         }
         break;
     }
     return ret;
 }

Referenced by WinHttpQueryOption().

◆ request_destroy()

static void request_destroy ( struct object_header * hdr )

static

Definition at line 604 of file session.c.

 {
     struct request *request = (struct request *)hdr;
     unsigned int i, j;
 
     TRACE("%p\n", request);
 
 #ifdef __REACTOS__
     if (request->task_thread)
 #else
     if (request->task_proc_running)
 #endif
     {
         /* Signal to the task proc to quit. It will call this again when it does. */
 #ifdef __REACTOS__
         HANDLE thread = request->task_thread;
         request->task_thread = 0;
         SetEvent( request->task_cancel );
         CloseHandle( thread );
 #else
         request->task_proc_running = FALSE;
         SetEvent( request->task_cancel );
 #endif
         return;
     }
     release_object( &request->connect->hdr );
 
     if (request->cred_handle_initialized) FreeCredentialsHandle( &request->cred_handle );
     CertFreeCertificateContext( request->server_cert );
     CertFreeCertificateContext( request->client_cert );
 
     destroy_authinfo( request->authinfo );
     destroy_authinfo( request->proxy_authinfo );
 
     heap_free( request->verb );
     heap_free( request->path );
     heap_free( request->version );
     heap_free( request->raw_headers );
     heap_free( request->status_text );
     for (i = 0; i < request->num_headers; i++)
     {
         heap_free( request->headers[i].field );
         heap_free( request->headers[i].value );
     }
     heap_free( request->headers );
     for (i = 0; i < TARGET_MAX; i++)
     {
         for (j = 0; j < SCHEME_MAX; j++)
         {
             heap_free( request->creds[i][j].username );
             heap_free( request->creds[i][j].password );
         }
     }
     heap_free( request );
 }

◆ request_query_option()

static BOOL request_query_option	(	struct object_header *	hdr,
		DWORD	option,
		void *	buffer,
		DWORD *	buflen
	)

static

Definition at line 710 of file session.c.

 {
     struct request *request = (struct request *)hdr;
 
     switch (option)
     {
     case WINHTTP_OPTION_SECURITY_FLAGS:
     {
         DWORD flags;
         int bits;
 
         if (!buffer || *buflen < sizeof(flags))
         {
             *buflen = sizeof(flags);
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         flags = request->security_flags;
         if (request->netconn)
         {
             bits = netconn_get_cipher_strength( request->netconn );
             if (bits >= 128)
                 flags |= SECURITY_FLAG_STRENGTH_STRONG;
             else if (bits >= 56)
                 flags |= SECURITY_FLAG_STRENGTH_MEDIUM;
             else
                 flags |= SECURITY_FLAG_STRENGTH_WEAK;
         }
         *(DWORD *)buffer = flags;
         *buflen = sizeof(flags);
         return TRUE;
     }
     case WINHTTP_OPTION_SERVER_CERT_CONTEXT:
     {
         const CERT_CONTEXT *cert;
 
         if (!buffer || *buflen < sizeof(cert))
         {
             *buflen = sizeof(cert);
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         if (!(cert = CertDuplicateCertificateContext( request->server_cert ))) return FALSE;
         *(CERT_CONTEXT **)buffer = (CERT_CONTEXT *)cert;
         *buflen = sizeof(cert);
         return TRUE;
     }
     case WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT:
     {
         const CERT_CONTEXT *cert = request->server_cert;
         const CRYPT_OID_INFO *oidInfo;
         WINHTTP_CERTIFICATE_INFO *ci = buffer;
 
         FIXME("partial stub\n");
 
         if (!buffer || *buflen < sizeof(*ci))
         {
             *buflen = sizeof(*ci);
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
         if (!cert) return FALSE;
 
         ci->ftExpiry = cert->pCertInfo->NotAfter;
         ci->ftStart  = cert->pCertInfo->NotBefore;
         ci->lpszSubjectInfo = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Subject );
         ci->lpszIssuerInfo  = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Issuer );
         ci->lpszProtocolName      = NULL;
         oidInfo = CryptFindOIDInfo( CRYPT_OID_INFO_OID_KEY, cert->pCertInfo->SignatureAlgorithm.pszObjId, 0 );
         if (oidInfo)
             ci->lpszSignatureAlgName = (LPWSTR)oidInfo->pwszName;
         else
             ci->lpszSignatureAlgName  = NULL;
         ci->lpszEncryptionAlgName = NULL;
         ci->dwKeySize = request->netconn ? netconn_get_cipher_strength( request->netconn ) : 0;
 
         *buflen = sizeof(*ci);
         return TRUE;
     }
     case WINHTTP_OPTION_SECURITY_KEY_BITNESS:
     {
         if (!buffer || *buflen < sizeof(DWORD))
         {
             *buflen = sizeof(DWORD);
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         *(DWORD *)buffer = request->netconn ? netconn_get_cipher_strength( request->netconn ) : 0;
         *buflen = sizeof(DWORD);
         return TRUE;
     }
     case WINHTTP_OPTION_CONNECTION_INFO:
     {
         WINHTTP_CONNECTION_INFO *info = buffer;
         struct sockaddr local;
         socklen_t len = sizeof(local);
         const struct sockaddr *remote = (const struct sockaddr *)&request->connect->sockaddr;
 
         if (!buffer || *buflen < sizeof(*info))
         {
             *buflen = sizeof(*info);
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
         if (!request->netconn)
         {
             SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_STATE );
             return FALSE;
         }
         if (getsockname( request->netconn->socket, &local, &len )) return FALSE;
         if (!copy_sockaddr( &local, &info->LocalAddress )) return FALSE;
         if (!copy_sockaddr( remote, &info->RemoteAddress )) return FALSE;
         info->cbSize = sizeof(*info);
         return TRUE;
     }
     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
         *(DWORD *)buffer = request->resolve_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_CONNECT_TIMEOUT:
         *(DWORD *)buffer = request->connect_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_SEND_TIMEOUT:
         *(DWORD *)buffer = request->send_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
         *(DWORD *)buffer = request->receive_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
         *(DWORD *)buffer = request->receive_response_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_USERNAME:
         str_to_buffer( buffer, request->connect->username, buflen );
         return TRUE;
 
     case WINHTTP_OPTION_PASSWORD:
         str_to_buffer( buffer, request->connect->password, buflen );
         return TRUE;
 
     case WINHTTP_OPTION_PROXY_USERNAME:
         str_to_buffer( buffer, request->connect->session->proxy_username, buflen );
         return TRUE;
 
     case WINHTTP_OPTION_PROXY_PASSWORD:
         str_to_buffer( buffer, request->connect->session->proxy_password, buflen );
         return TRUE;
 
     default:
         FIXME("unimplemented option %u\n", option);
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
 }

◆ request_set_option()

static BOOL request_set_option	(	struct object_header *	hdr,
		DWORD	option,
		void *	buffer,
		DWORD	buflen
	)

static

Definition at line 889 of file session.c.

 {
     struct request *request = (struct request *)hdr;
 
     switch (option)
     {
     case WINHTTP_OPTION_PROXY:
     {
         WINHTTP_PROXY_INFO *pi = buffer;
 
         FIXME("%u %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass));
         return TRUE;
     }
     case WINHTTP_OPTION_DISABLE_FEATURE:
     {
         DWORD disable;
 
         if (buflen != sizeof(DWORD))
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         disable = *(DWORD *)buffer;
         TRACE("0x%x\n", disable);
         hdr->disable_flags |= disable;
         return TRUE;
     }
     case WINHTTP_OPTION_AUTOLOGON_POLICY:
     {
         DWORD policy;
 
         if (buflen != sizeof(DWORD))
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         policy = *(DWORD *)buffer;
         TRACE("0x%x\n", policy);
         hdr->logon_policy = policy;
         return TRUE;
     }
     case WINHTTP_OPTION_REDIRECT_POLICY:
     {
         DWORD policy;
 
         if (buflen != sizeof(DWORD))
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         policy = *(DWORD *)buffer;
         TRACE("0x%x\n", policy);
         hdr->redirect_policy = policy;
         return TRUE;
     }
     case WINHTTP_OPTION_SECURITY_FLAGS:
     {
         DWORD flags;
         static const DWORD accepted = SECURITY_FLAG_IGNORE_CERT_CN_INVALID   |
                                       SECURITY_FLAG_IGNORE_CERT_DATE_INVALID |
                                       SECURITY_FLAG_IGNORE_UNKNOWN_CA        |
                                       SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE;
 
         if (buflen < sizeof(DWORD))
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
         flags = *(DWORD *)buffer;
         TRACE("0x%x\n", flags);
         if (flags && (flags & ~accepted))
         {
             SetLastError( ERROR_INVALID_PARAMETER );
             return FALSE;
         }
         request->security_flags = flags;
         return TRUE;
     }
     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
         request->resolve_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_CONNECT_TIMEOUT:
         request->connect_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_SEND_TIMEOUT:
         request->send_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
         request->receive_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
         request->receive_response_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_USERNAME:
     {
         struct connect *connect = request->connect;
 
         heap_free( connect->username );
         if (!(connect->username = buffer_to_str( buffer, buflen ))) return FALSE;
         return TRUE;
     }
     case WINHTTP_OPTION_PASSWORD:
     {
         struct connect *connect = request->connect;
 
         heap_free( connect->password );
         if (!(connect->password = buffer_to_str( buffer, buflen ))) return FALSE;
         return TRUE;
     }
     case WINHTTP_OPTION_PROXY_USERNAME:
     {
         struct session *session = request->connect->session;
 
         heap_free( session->proxy_username );
         if (!(session->proxy_username = buffer_to_str( buffer, buflen ))) return FALSE;
         return TRUE;
     }
     case WINHTTP_OPTION_PROXY_PASSWORD:
     {
         struct session *session = request->connect->session;
 
         heap_free( session->proxy_password );
         if (!(session->proxy_password = buffer_to_str( buffer, buflen ))) return FALSE;
         return TRUE;
     }
     case WINHTTP_OPTION_CLIENT_CERT_CONTEXT:
     {
         const CERT_CONTEXT *cert;
 
         if (!(hdr->flags & WINHTTP_FLAG_SECURE))
         {
             SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_STATE );
             return FALSE;
         }
         if (!buffer)
         {
             CertFreeCertificateContext( request->client_cert );
             request->client_cert = NULL;
         }
         else if (buflen >= sizeof(cert))
         {
             if (!(cert = CertDuplicateCertificateContext( buffer ))) return FALSE;
             CertFreeCertificateContext( request->client_cert );
             request->client_cert = cert;
         }
         else
         {
             SetLastError( ERROR_INVALID_PARAMETER );
             return FALSE;
         }
 
         if (request->cred_handle_initialized)
         {
             FreeCredentialsHandle( &request->cred_handle );
             request->cred_handle_initialized = FALSE;
         }
 
         return TRUE;
     }
     case WINHTTP_OPTION_ENABLE_FEATURE:
         if(buflen == sizeof( DWORD ) && *(DWORD *)buffer == WINHTTP_ENABLE_SSL_REVOCATION)
         {
             request->check_revocation = TRUE;
             SetLastError( NO_ERROR );
             return TRUE;
         }
         else
         {
             SetLastError( ERROR_INVALID_PARAMETER );
             return FALSE;
         }
 
     case WINHTTP_OPTION_CONNECT_RETRIES:
         FIXME("WINHTTP_OPTION_CONNECT_RETRIES\n");
         return TRUE;
 
     default:
         FIXME("unimplemented option %u\n", option);
         SetLastError( ERROR_WINHTTP_INVALID_OPTION );
         return FALSE;
     }
 }

◆ reverse_lookup()

static int reverse_lookup	(	const struct addrinfo *	ai,
		char *	hostname,
		size_t	len
	)

static

Definition at line 1357 of file session.c.

 {
     return getnameinfo( ai->ai_addr, ai->ai_addrlen, hostname, len, NULL, 0, 0 );
 }

Referenced by build_wpad_url().

◆ run_script()

static BOOL run_script	(	char *	script,
		DWORD	size,
		const WCHAR *	url,
		WINHTTP_PROXY_INFO *	info
	)

static

Definition at line 1849 of file session.c.

 {
     BOOL ret;
     char *result, *urlA;
     DWORD len_result;
     struct AUTO_PROXY_SCRIPT_BUFFER buffer;
     URL_COMPONENTSW uc;
 
     buffer.dwStructSize = sizeof(buffer);
     buffer.lpszScriptBuffer = script;
     buffer.dwScriptBufferSize = size;
 
     if (!(urlA = strdupWA( url ))) return FALSE;
     if (!(ret = InternetInitializeAutoProxyDll( 0, NULL, NULL, NULL, &buffer )))
     {
         heap_free( urlA );
         return FALSE;
     }
 
     memset( &uc, 0, sizeof(uc) );
     uc.dwStructSize = sizeof(uc);
     uc.dwHostNameLength = -1;
 
     if (WinHttpCrackUrl( url, 0, 0, &uc ))
     {
         char *hostnameA = strdupWA_sized( uc.lpszHostName, uc.dwHostNameLength );
 
         if ((ret = InternetGetProxyInfo( urlA, strlen(urlA),
                         hostnameA, strlen(hostnameA), &result, &len_result )))
         {
             ret = parse_script_result( result, info );
             heap_free( result );
         }
 
         heap_free( hostnameA );
     }
     heap_free( urlA );
     return InternetDeInitializeAutoProxyDll( NULL, 0 );
 }

Referenced by WinHttpGetProxyForUrl().

◆ send_callback()

void send_callback	(	struct object_header *	hdr,
		DWORD	status,
		void *	info,
		DWORD	buflen
	)

Definition at line 55 of file session.c.

 {
     if (hdr->callback && (hdr->notify_mask & status))
     {
         TRACE("%p, 0x%08x, %p, %u\n", hdr, status, info, buflen);
         hdr->callback( hdr->handle, hdr->context, status, info, buflen );
         TRACE("returning from 0x%08x callback\n", status);
     }
 }

Referenced by close_connection(), handle_redirect(), open_connection(), query_data_available(), read_data(), read_more_data(), receive_response(), release_object(), send_request(), WinHttpConnect(), WinHttpOpenRequest(), and write_data().

◆ session_destroy()

static void session_destroy ( struct object_header * hdr )

static

Definition at line 77 of file session.c.

 {
     struct session *session = (struct session *)hdr;
 
     TRACE("%p\n", session);
 
     if (session->unload_event) SetEvent( session->unload_event );
     destroy_cookies( session );
 
     session->cs.DebugInfo->Spare[0] = 0;
     DeleteCriticalSection( &session->cs );
     heap_free( session->agent );
     heap_free( session->proxy_server );
     heap_free( session->proxy_bypass );
     heap_free( session->proxy_username );
     heap_free( session->proxy_password );
     heap_free( session );
 }

◆ session_query_option()

static BOOL session_query_option	(	struct object_header *	hdr,
		DWORD	option,
		void *	buffer,
		DWORD *	buflen
	)

static

Definition at line 96 of file session.c.

 {
     struct session *session = (struct session *)hdr;
 
     switch (option)
     {
     case WINHTTP_OPTION_REDIRECT_POLICY:
     {
         if (!buffer || *buflen < sizeof(DWORD))
         {
             *buflen = sizeof(DWORD);
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         *(DWORD *)buffer = hdr->redirect_policy;
         *buflen = sizeof(DWORD);
         return TRUE;
     }
     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
         *(DWORD *)buffer = session->resolve_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_CONNECT_TIMEOUT:
         *(DWORD *)buffer = session->connect_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_SEND_TIMEOUT:
         *(DWORD *)buffer = session->send_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
         *(DWORD *)buffer = session->receive_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
         *(DWORD *)buffer = session->receive_response_timeout;
         *buflen = sizeof(DWORD);
         return TRUE;
 
     default:
         FIXME("unimplemented option %u\n", option);
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
 }

◆ session_set_option()

static BOOL session_set_option	(	struct object_header *	hdr,
		DWORD	option,
		void *	buffer,
		DWORD	buflen
	)

static

Definition at line 147 of file session.c.

 {
     struct session *session = (struct session *)hdr;
 
     switch (option)
     {
     case WINHTTP_OPTION_PROXY:
     {
         WINHTTP_PROXY_INFO *pi = buffer;
 
         FIXME("%u %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass));
         return TRUE;
     }
     case WINHTTP_OPTION_REDIRECT_POLICY:
     {
         DWORD policy;
 
         if (buflen != sizeof(policy))
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         policy = *(DWORD *)buffer;
         TRACE("0x%x\n", policy);
         hdr->redirect_policy = policy;
         return TRUE;
     }
     case WINHTTP_OPTION_SECURE_PROTOCOLS:
     {
         if (buflen != sizeof(session->secure_protocols))
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
         EnterCriticalSection( &session->cs );
         session->secure_protocols = *(DWORD *)buffer;
         LeaveCriticalSection( &session->cs );
         TRACE("0x%x\n", session->secure_protocols);
         return TRUE;
     }
     case WINHTTP_OPTION_DISABLE_FEATURE:
         SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
         return FALSE;
 
     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
         session->resolve_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_CONNECT_TIMEOUT:
         session->connect_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_SEND_TIMEOUT:
         session->send_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
         session->receive_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
         session->receive_response_timeout = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_CONFIGURE_PASSPORT_AUTH:
         session->passport_flags = *(DWORD *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT:
         TRACE("WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT: %p\n", *(HANDLE *)buffer);
         session->unload_event = *(HANDLE *)buffer;
         return TRUE;
 
     case WINHTTP_OPTION_MAX_CONNS_PER_SERVER:
         FIXME("WINHTTP_OPTION_MAX_CONNS_PER_SERVER: %d\n", *(DWORD *)buffer);
         return TRUE;
 
     case WINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVER:
         FIXME("WINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVER: %d\n", *(DWORD *)buffer);
         return TRUE;
 
     default:
         FIXME("unimplemented option %u\n", option);
         SetLastError( ERROR_WINHTTP_INVALID_OPTION );
         return FALSE;
     }
 }

◆ set_option()

static BOOL set_option	(	struct object_header *	hdr,
		DWORD	option,
		void *	buffer,
		DWORD	buflen
	)

static

Definition at line 1273 of file session.c.

 {
     BOOL ret = TRUE;
 
     if (!buffer && buflen)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
 
     switch (option)
     {
     case WINHTTP_OPTION_CONTEXT_VALUE:
     {
         if (buflen != sizeof(DWORD_PTR))
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
 
         hdr->context = *(DWORD_PTR *)buffer;
         return TRUE;
     }
     default:
         if (hdr->vtbl->set_option) ret = hdr->vtbl->set_option( hdr, option, buffer, buflen );
         else
         {
             FIXME("unimplemented option %u\n", option);
             SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
             return FALSE;
         }
         break;
     }
     return ret;
 }

Referenced by WinHttpSetOption().

◆ set_server_for_hostname()

BOOL set_server_for_hostname	(	struct connect *	connect,
		const WCHAR *	server,
		INTERNET_PORT	port
	)

Definition at line 476 of file session.c.

 {
     struct session *session = connect->session;
     BOOL ret = TRUE;
 
     if (session->proxy_server && !should_bypass_proxy(session, server))
     {
         LPCWSTR colon;
 
         if ((colon = strchrW( session->proxy_server, ':' )))
         {
             if (!connect->servername || strncmpiW( connect->servername,
                 session->proxy_server, colon - session->proxy_server - 1 ))
             {
                 heap_free( connect->servername );
                 connect->resolved = FALSE;
                 if (!(connect->servername = heap_alloc(
                     (colon - session->proxy_server + 1) * sizeof(WCHAR) )))
                 {
                     ret = FALSE;
                     goto end;
                 }
                 memcpy( connect->servername, session->proxy_server,
                     (colon - session->proxy_server) * sizeof(WCHAR) );
                 connect->servername[colon - session->proxy_server] = 0;
                 if (*(colon + 1))
                     connect->serverport = atoiW( colon + 1 );
                 else
                     connect->serverport = INTERNET_DEFAULT_PORT;
             }
         }
         else
         {
             if (!connect->servername || strcmpiW( connect->servername,
                 session->proxy_server ))
             {
                 heap_free( connect->servername );
                 connect->resolved = FALSE;
                 if (!(connect->servername = strdupW( session->proxy_server )))
                 {
                     ret = FALSE;
                     goto end;
                 }
                 connect->serverport = INTERNET_DEFAULT_PORT;
             }
         }
     }
     else if (server)
     {
         heap_free( connect->servername );
         connect->resolved = FALSE;
         if (!(connect->servername = strdupW( server )))
         {
             ret = FALSE;
             goto end;
         }
         connect->serverport = port;
     }
 end:
     return ret;
 }

Referenced by handle_redirect(), and WinHttpConnect().

◆ should_bypass_proxy()

static BOOL should_bypass_proxy	(	struct session *	session,
		LPCWSTR	server
	)

static

Definition at line 445 of file session.c.

 {
     LPCWSTR ptr;
     BOOL ret = FALSE;
 
     if (!session->proxy_bypass) return FALSE;
     ptr = session->proxy_bypass;
     do {
         LPCWSTR tmp = ptr;
 
         ptr = strchrW( ptr, ';' );
         if (!ptr)
             ptr = strchrW( tmp, ' ' );
         if (ptr)
         {
             if (ptr - tmp < MAX_HOST_NAME_LENGTH)
             {
                 WCHAR domain[MAX_HOST_NAME_LENGTH];
 
                 memcpy( domain, tmp, (ptr - tmp) * sizeof(WCHAR) );
                 domain[ptr - tmp] = 0;
                 ret = domain_matches( server, domain );
             }
             ptr += 1;
         }
         else if (*tmp)
             ret = domain_matches( server, tmp );
     } while (ptr && !ret);
     return ret;
 }

Referenced by set_server_for_hostname().

◆ str_to_buffer()

static void str_to_buffer	(	WCHAR *	buffer,
		const WCHAR *	str,
		LPDWORD	buflen
	)

static

Definition at line 660 of file session.c.

 {
     int len = 0;
     if (str) len = strlenW( str );
     if (buffer && *buflen > len)
     {
         if (str) memcpy( buffer, str, len * sizeof(WCHAR) );
         buffer[len] = 0;
     }
     *buflen = len * sizeof(WCHAR);
 }

Referenced by request_query_option().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( winhttp )

◆ WinHttpCheckPlatform()

BOOL WINAPI WinHttpCheckPlatform ( void )

Definition at line 68 of file session.c.

 {
     TRACE("\n");
     return TRUE;
 }

◆ WinHttpCloseHandle()

BOOL WINAPI WinHttpCloseHandle ( HINTERNET handle )

Definition at line 1195 of file session.c.

 {
     struct object_header *hdr;
 
     TRACE("%p\n", handle);
 
     if (!(hdr = grab_object( handle )))
     {
         SetLastError( ERROR_INVALID_HANDLE );
         return FALSE;
     }
     release_object( hdr );
     free_handle( handle );
     SetLastError( ERROR_SUCCESS );
     return TRUE;
 }

Referenced by close_request(), do_request(), download_script(), free_request(), reset_request(), test_async(), test_bad_header(), test_basic_authentication(), test_basic_request(), test_chunked_read(), test_connection_cache(), test_connection_info(), test_cookies(), test_credentials(), test_empty_headers_param(), test_head_request(), test_large_data_authentication(), test_multi_authentication(), test_multiple_reads(), test_no_content(), test_no_headers(), test_not_modified(), test_passport_auth(), test_redirect(), test_request_parameter_defaults(), test_request_path_escapes(), test_resolve_timeout(), test_secure_connection(), test_timeouts(), test_WinHttpAddHeaders(), test_WinHttpGetProxyForUrl(), test_WinHttpOpenRequest(), test_WinHttpQueryOption(), test_WinHttpSendRequest(), transfer_file_http(), and winhttp_request_Open().

◆ WinHttpConnect()

HINTERNET WINAPI WinHttpConnect	(	HINTERNET	hsession,
		LPCWSTR	server,
		INTERNET_PORT	port,
		DWORD	reserved
	)

Definition at line 541 of file session.c.

 {
     struct connect *connect;
     struct session *session;
     HINTERNET hconnect = NULL;
 
     TRACE("%p, %s, %u, %x\n", hsession, debugstr_w(server), port, reserved);
 
     if (!server)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return NULL;
     }
     if (!(session = (struct session *)grab_object( hsession )))
     {
         SetLastError( ERROR_INVALID_HANDLE );
         return NULL;
     }
     if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
     {
         release_object( &session->hdr );
         SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
         return NULL;
     }
     if (!(connect = heap_alloc_zero( sizeof(struct connect) )))
     {
         release_object( &session->hdr );
         return NULL;
     }
     connect->hdr.type = WINHTTP_HANDLE_TYPE_CONNECT;
     connect->hdr.vtbl = &connect_vtbl;
     connect->hdr.refs = 1;
     connect->hdr.flags = session->hdr.flags;
     connect->hdr.callback = session->hdr.callback;
     connect->hdr.notify_mask = session->hdr.notify_mask;
     connect->hdr.context = session->hdr.context;
     connect->hdr.redirect_policy = session->hdr.redirect_policy;
     list_init( &connect->hdr.children );
 
     addref_object( &session->hdr );
     connect->session = session;
     list_add_head( &session->hdr.children, &connect->hdr.entry );
 
     if (!(connect->hostname = strdupW( server ))) goto end;
     connect->hostport = port;
     if (!set_server_for_hostname( connect, server, port )) goto end;
 
     if (!(hconnect = alloc_handle( &connect->hdr ))) goto end;
     connect->hdr.handle = hconnect;
 
     send_callback( &session->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hconnect, sizeof(hconnect) );
 
 end:
     release_object( &connect->hdr );
     release_object( &session->hdr );
     TRACE("returning %p\n", hconnect);
     if (hconnect) SetLastError( ERROR_SUCCESS );
     return hconnect;
 }

Referenced by download_script(), open_async_request(), test_async(), test_bad_header(), test_basic_authentication(), test_basic_request(), test_chunked_read(), test_connection_cache(), test_connection_info(), test_cookies(), test_credentials(), test_empty_headers_param(), test_head_request(), test_large_data_authentication(), test_multi_authentication(), test_multiple_reads(), test_no_content(), test_no_headers(), test_not_modified(), test_passport_auth(), test_redirect(), test_request_parameter_defaults(), test_request_path_escapes(), test_resolve_timeout(), test_secure_connection(), test_timeouts(), test_WinHttpAddHeaders(), test_WinHttpOpenRequest(), test_WinHttpQueryOption(), test_WinHttpSendRequest(), transfer_file_http(), and winhttp_request_Open().

◆ WinHttpDetectAutoProxyConfigUrl()

BOOL WINAPI WinHttpDetectAutoProxyConfigUrl	(	DWORD	flags,
		LPWSTR *	url
	)

Definition at line 1423 of file session.c.

 {
     BOOL ret = FALSE;
     char system_url[INTERNET_MAX_URL_LENGTH + 1];
 
     TRACE("0x%08x, %p\n", flags, url);
 
     if (!flags || !url)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
     if (get_system_proxy_autoconfig_url( system_url, sizeof(system_url) ))
     {
         WCHAR *urlW;
 
         if (!(urlW = strdupAW( system_url ))) return FALSE;
         *url = urlW;
         SetLastError( ERROR_SUCCESS );
         return TRUE;
     }
     if (flags & WINHTTP_AUTO_DETECT_TYPE_DHCP)
     {
         static int fixme_shown;
         if (!fixme_shown++) FIXME("discovery via DHCP not supported\n");
     }
     if (flags & WINHTTP_AUTO_DETECT_TYPE_DNS_A)
     {
         char *fqdn, *domain, *p;
 
         if (!(fqdn = get_computer_name( ComputerNamePhysicalDnsFullyQualified ))) return FALSE;
         if (!(domain = get_computer_name( ComputerNamePhysicalDnsDomain )))
         {
             heap_free( fqdn );
             return FALSE;
         }
         p = fqdn;
         while ((p = strchr( p, '.' )) && is_domain_suffix( p + 1, domain ))
         {
             struct addrinfo *ai;
             char *name;
             int res;
 
             if (!(name = heap_alloc( sizeof("wpad") + strlen(p) )))
             {
                 heap_free( fqdn );
                 heap_free( domain );
                 return FALSE;
             }
             strcpy( name, "wpad" );
             strcat( name, p );
             res = getaddrinfo( name, NULL, NULL, &ai );
             if (!res)
             {
                 *url = build_wpad_url( name, ai );
                 freeaddrinfo( ai );
                 if (*url)
                 {
                     TRACE("returning %s\n", debugstr_w(*url));
                     heap_free( name );
                     ret = TRUE;
                     break;
                 }
             }
             heap_free( name );
             p++;
         }
         heap_free( domain );
         heap_free( fqdn );
     }
     if (!ret)
     {
         SetLastError( ERROR_WINHTTP_AUTODETECTION_FAILED );
         *url = NULL;
     }
     else SetLastError( ERROR_SUCCESS );
     return ret;
 }

Referenced by test_WinHttpDetectAutoProxyConfigUrl(), and WinHttpGetProxyForUrl().

◆ WinHttpGetDefaultProxyConfiguration()

BOOL WINAPI WinHttpGetDefaultProxyConfiguration ( WINHTTP_PROXY_INFO * info )

Definition at line 1537 of file session.c.

 {
     LONG l;
     HKEY key;
     BOOL got_from_reg = FALSE, direct = TRUE;
     char *envproxy;
 
     TRACE("%p\n", info);
 
     l = RegOpenKeyExW( HKEY_LOCAL_MACHINE, Connections, 0, KEY_READ, &key );
     if (!l)
     {
         DWORD type, size = 0;
 
         l = RegQueryValueExW( key, WinHttpSettings, NULL, &type, NULL, &size );
         if (!l && type == REG_BINARY &&
             size >= sizeof(struct connection_settings_header) + 2 * sizeof(DWORD))
         {
             BYTE *buf = heap_alloc( size );
 
             if (buf)
             {
                 struct connection_settings_header *hdr =
                     (struct connection_settings_header *)buf;
                 DWORD *len = (DWORD *)(hdr + 1);
 
                 l = RegQueryValueExW( key, WinHttpSettings, NULL, NULL, buf,
                     &size );
                 if (!l && hdr->magic == WINHTTP_SETTINGS_MAGIC &&
                     hdr->unknown == 0)
                 {
                     if (hdr->flags & PROXY_TYPE_PROXY)
                     {
                        BOOL sane = FALSE;
                        LPWSTR proxy = NULL;
                        LPWSTR proxy_bypass = NULL;
 
                         /* Sanity-check length of proxy string */
                         if ((BYTE *)len - buf + *len <= size)
                         {
                             sane = TRUE;
                             proxy = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) );
                             if (proxy)
                                 copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy );
                             len = (DWORD *)((BYTE *)(len + 1) + *len);
                         }
                         if (sane)
                         {
                             /* Sanity-check length of proxy bypass string */
                             if ((BYTE *)len - buf + *len <= size)
                             {
                                 proxy_bypass = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) );
                                 if (proxy_bypass)
                                     copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy_bypass );
                             }
                             else
                             {
                                 sane = FALSE;
                                 GlobalFree( proxy );
                                 proxy = NULL;
                             }
                         }
                         info->lpszProxy = proxy;
                         info->lpszProxyBypass = proxy_bypass;
                         if (sane)
                         {
                             got_from_reg = TRUE;
                             direct = FALSE;
                             info->dwAccessType =
                                 WINHTTP_ACCESS_TYPE_NAMED_PROXY;
                             TRACE("http proxy (from registry) = %s, bypass = %s\n",
                                 debugstr_w(info->lpszProxy),
                                 debugstr_w(info->lpszProxyBypass));
                         }
                     }
                 }
                 heap_free( buf );
             }
         }
         RegCloseKey( key );
     }
     if (!got_from_reg && (envproxy = getenv( "http_proxy" )))
     {
         char *colon, *http_proxy = NULL;
 
         if (!(colon = strchr( envproxy, ':' ))) http_proxy = envproxy;
         else
         {
             if (*(colon + 1) == '/' && *(colon + 2) == '/')
             {
                 /* It's a scheme, check that it's http */
                 if (!strncmp( envproxy, "http://", 7 )) http_proxy = envproxy + 7;
                 else WARN("unsupported scheme in $http_proxy: %s\n", envproxy);
             }
             else http_proxy = envproxy;
         }
 
         if (http_proxy && http_proxy[0])
         {
             WCHAR *http_proxyW;
             int len;
 
             len = MultiByteToWideChar( CP_UNIXCP, 0, http_proxy, -1, NULL, 0 );
             if ((http_proxyW = GlobalAlloc( 0, len * sizeof(WCHAR))))
             {
                 MultiByteToWideChar( CP_UNIXCP, 0, http_proxy, -1, http_proxyW, len );
                 direct = FALSE;
                 info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
                 info->lpszProxy = http_proxyW;
                 info->lpszProxyBypass = NULL;
                 TRACE("http proxy (from environment) = %s\n", debugstr_w(info->lpszProxy));
             }
         }
     }
     if (direct)
     {
         info->dwAccessType    = WINHTTP_ACCESS_TYPE_NO_PROXY;
         info->lpszProxy       = NULL;
         info->lpszProxyBypass = NULL;
     }
     SetLastError( ERROR_SUCCESS );
     return TRUE;
 }

Referenced by proxy_active(), and WinHttpOpen().

◆ WinHttpGetIEProxyConfigForCurrentUser()

BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser ( WINHTTP_CURRENT_USER_IE_PROXY_CONFIG * config )

Definition at line 1664 of file session.c.

 {
     static const WCHAR settingsW[] =
         {'D','e','f','a','u','l','t','C','o','n','n','e','c','t','i','o','n','S','e','t','t','i','n','g','s',0};
     HKEY hkey = NULL;
     struct connection_settings_header *hdr = NULL;
     DWORD type, offset, len, size = 0;
     BOOL ret = FALSE;
 
     TRACE("%p\n", config);
 
     if (!config)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
     memset( config, 0, sizeof(*config) );
     config->fAutoDetect = TRUE;
 
     if (RegOpenKeyExW( HKEY_CURRENT_USER, Connections, 0, KEY_READ, &hkey ) ||
         RegQueryValueExW( hkey, settingsW, NULL, &type, NULL, &size ) ||
         type != REG_BINARY || size < sizeof(struct connection_settings_header))
     {
         ret = TRUE;
         goto done;
     }
     if (!(hdr = heap_alloc( size ))) goto done;
     if (RegQueryValueExW( hkey, settingsW, NULL, &type, (BYTE *)hdr, &size ) ||
         hdr->magic != WININET_SETTINGS_MAGIC)
     {
         ret = TRUE;
         goto done;
     }
 
     config->fAutoDetect = (hdr->flags & PROXY_AUTODETECT_SETTINGS) != 0;
     offset = sizeof(*hdr);
     if (offset + sizeof(DWORD) > size) goto done;
     len = *(DWORD *)((char *)hdr + offset);
     offset += sizeof(DWORD);
     if (len && hdr->flags & PROXY_TYPE_PROXY)
     {
         if (!(config->lpszProxy = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
         copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszProxy );
     }
     offset += len;
     if (offset + sizeof(DWORD) > size) goto done;
     len = *(DWORD *)((char *)hdr + offset);
     offset += sizeof(DWORD);
     if (len && (hdr->flags & PROXY_TYPE_PROXY))
     {
         if (!(config->lpszProxyBypass = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
         copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszProxyBypass );
     }
     offset += len;
     if (offset + sizeof(DWORD) > size) goto done;
     len = *(DWORD *)((char *)hdr + offset);
     offset += sizeof(DWORD);
     if (len && (hdr->flags & PROXY_USE_PAC_SCRIPT))
     {
         if (!(config->lpszAutoConfigUrl = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
         copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszAutoConfigUrl );
     }
     ret = TRUE;
 
 done:
     RegCloseKey( hkey );
     heap_free( hdr );
     if (!ret)
     {
         GlobalFree( config->lpszAutoConfigUrl );
         config->lpszAutoConfigUrl = NULL;
         GlobalFree( config->lpszProxy );
         config->lpszProxy = NULL;
         GlobalFree( config->lpszProxyBypass );
         config->lpszProxyBypass = NULL;
     }
     else SetLastError( ERROR_SUCCESS );
     return ret;
 }

Referenced by test_WinHttpGetIEProxyConfigForCurrentUser().

◆ WinHttpGetProxyForUrl()

BOOL WINAPI WinHttpGetProxyForUrl	(	HINTERNET	hsession,
		LPCWSTR	url,
		WINHTTP_AUTOPROXY_OPTIONS *	options,
		WINHTTP_PROXY_INFO *	info
	)

Definition at line 1892 of file session.c.

 {
     WCHAR *detected_pac_url = NULL;
     const WCHAR *pac_url;
     struct session *session;
     char *script;
     DWORD size;
     BOOL ret = FALSE;
 
     TRACE("%p, %s, %p, %p\n", hsession, debugstr_w(url), options, info);
 
     if (!(session = (struct session *)grab_object( hsession )))
     {
         SetLastError( ERROR_INVALID_HANDLE );
         return FALSE;
     }
     if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
     {
         release_object( &session->hdr );
         SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
         return FALSE;
     }
     if (!url || !options || !info ||
         !(options->dwFlags & (WINHTTP_AUTOPROXY_AUTO_DETECT|WINHTTP_AUTOPROXY_CONFIG_URL)) ||
         ((options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT) && !options->dwAutoDetectFlags) ||
         ((options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT) &&
          (options->dwFlags & WINHTTP_AUTOPROXY_CONFIG_URL)))
     {
         release_object( &session->hdr );
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
     if (options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT &&
         !WinHttpDetectAutoProxyConfigUrl( options->dwAutoDetectFlags, &detected_pac_url ))
         goto done;
 
     if (options->dwFlags & WINHTTP_AUTOPROXY_CONFIG_URL) pac_url = options->lpszAutoConfigUrl;
     else pac_url = detected_pac_url;
 
     if ((script = download_script( pac_url, &size )))
     {
         ret = run_script( script, size, url, info );
         heap_free( script );
     }
 
 done:
     GlobalFree( detected_pac_url );
     release_object( &session->hdr );
     if (ret) SetLastError( ERROR_SUCCESS );
     return ret;
 }

Referenced by test_WinHttpGetProxyForUrl().

◆ WinHttpOpen()

HINTERNET WINAPI WinHttpOpen	(	LPCWSTR	agent,
		DWORD	access,
		LPCWSTR	proxy,
		LPCWSTR	bypass,
		DWORD	flags
	)

Definition at line 250 of file session.c.

 {
     struct session *session;
     HINTERNET handle = NULL;
 
     TRACE("%s, %u, %s, %s, 0x%08x\n", debugstr_w(agent), access, debugstr_w(proxy), debugstr_w(bypass), flags);
 
     if (!(session = heap_alloc_zero( sizeof(struct session) ))) return NULL;
 
     session->hdr.type = WINHTTP_HANDLE_TYPE_SESSION;
     session->hdr.vtbl = &session_vtbl;
     session->hdr.flags = flags;
     session->hdr.refs = 1;
     session->hdr.redirect_policy = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP;
     list_init( &session->hdr.children );
     session->resolve_timeout = DEFAULT_RESOLVE_TIMEOUT;
     session->connect_timeout = DEFAULT_CONNECT_TIMEOUT;
     session->send_timeout = DEFAULT_SEND_TIMEOUT;
     session->receive_timeout = DEFAULT_RECEIVE_TIMEOUT;
     session->receive_response_timeout = DEFAULT_RECEIVE_RESPONSE_TIMEOUT;
     list_init( &session->cookie_cache );
     InitializeCriticalSection( &session->cs );
     session->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": session.cs");
 
     if (agent && !(session->agent = strdupW( agent ))) goto end;
     if (access == WINHTTP_ACCESS_TYPE_DEFAULT_PROXY)
     {
         WINHTTP_PROXY_INFO info;
 
         WinHttpGetDefaultProxyConfiguration( &info );
         session->access = info.dwAccessType;
         if (info.lpszProxy && !(session->proxy_server = strdupW( info.lpszProxy )))
         {
             GlobalFree( (LPWSTR)info.lpszProxy );
             GlobalFree( (LPWSTR)info.lpszProxyBypass );
             goto end;
         }
         if (info.lpszProxyBypass && !(session->proxy_bypass = strdupW( info.lpszProxyBypass )))
         {
             GlobalFree( (LPWSTR)info.lpszProxy );
             GlobalFree( (LPWSTR)info.lpszProxyBypass );
             goto end;
         }
     }
     else if (access == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
     {
         session->access = access;
         if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end;
         if (bypass && !(session->proxy_bypass = strdupW( bypass ))) goto end;
     }
 
     if (!(handle = alloc_handle( &session->hdr ))) goto end;
     session->hdr.handle = handle;
 
 #ifdef __REACTOS__
     winsock_init();
 #endif
 
 end:
     release_object( &session->hdr );
     TRACE("returning %p\n", handle);
     if (handle) SetLastError( ERROR_SUCCESS );
     return handle;
 }

Referenced by download_script(), open_async_request(), test_async(), test_bad_header(), test_basic_authentication(), test_basic_request(), test_chunked_read(), test_connection_cache(), test_connection_info(), test_cookies(), test_credentials(), test_empty_headers_param(), test_head_request(), test_large_data_authentication(), test_multi_authentication(), test_multiple_reads(), test_no_content(), test_no_headers(), test_not_modified(), test_passport_auth(), test_redirect(), test_request_parameter_defaults(), test_request_path_escapes(), test_resolve_timeout(), test_secure_connection(), test_timeouts(), test_WinHttpAddHeaders(), test_WinHttpGetProxyForUrl(), test_WinHttpOpenRequest(), test_WinHttpQueryOption(), test_WinHttpSendRequest(), transfer_file_http(), and winhttp_request_Open().

◆ WinHttpOpenRequest()

HINTERNET WINAPI WinHttpOpenRequest	(	HINTERNET	hconnect,
		LPCWSTR	verb,
		LPCWSTR	object,
		LPCWSTR	version,
		LPCWSTR	referrer,
		LPCWSTR *	types,
		DWORD	flags
	)

Definition at line 1117 of file session.c.

 {
     struct request *request;
     struct connect *connect;
     HINTERNET hrequest = NULL;
 
     TRACE("%p, %s, %s, %s, %s, %p, 0x%08x\n", hconnect, debugstr_w(verb), debugstr_w(object),
           debugstr_w(version), debugstr_w(referrer), types, flags);
 
     if (types && TRACE_ON(winhttp))
     {
         const WCHAR **iter;
         TRACE("accept types:\n");
         for (iter = types; *iter; iter++) TRACE("    %s\n", debugstr_w(*iter));
     }
 
     if (!(connect = (struct connect *)grab_object( hconnect )))
     {
         SetLastError( ERROR_INVALID_HANDLE );
         return NULL;
     }
     if (connect->hdr.type != WINHTTP_HANDLE_TYPE_CONNECT)
     {
         release_object( &connect->hdr );
         SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
         return NULL;
     }
     if (!(request = heap_alloc_zero( sizeof(struct request) )))
     {
         release_object( &connect->hdr );
         return NULL;
     }
     request->hdr.type = WINHTTP_HANDLE_TYPE_REQUEST;
     request->hdr.vtbl = &request_vtbl;
     request->hdr.refs = 1;
     request->hdr.flags = flags;
     request->hdr.callback = connect->hdr.callback;
     request->hdr.notify_mask = connect->hdr.notify_mask;
     request->hdr.context = connect->hdr.context;
     request->hdr.redirect_policy = connect->hdr.redirect_policy;
     list_init( &request->hdr.children );
     list_init( &request->task_queue );
 
     addref_object( &connect->hdr );
     request->connect = connect;
     list_add_head( &connect->hdr.children, &request->hdr.entry );
 
     request->resolve_timeout = connect->session->resolve_timeout;
     request->connect_timeout = connect->session->connect_timeout;
     request->send_timeout = connect->session->send_timeout;
     request->receive_timeout = connect->session->receive_timeout;
     request->receive_response_timeout = connect->session->receive_response_timeout;
 
     if (!verb || !verb[0]) verb = getW;
     if (!(request->verb = strdupW( verb ))) goto end;
     if (!(request->path = get_request_path( object ))) goto end;
 
     if (!version || !version[0]) version = http1_1;
     if (!(request->version = strdupW( version ))) goto end;
     if (!(add_accept_types_header( request, types ))) goto end;
 
     if (!(hrequest = alloc_handle( &request->hdr ))) goto end;
     request->hdr.handle = hrequest;
 
     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hrequest, sizeof(hrequest) );
 
 end:
     release_object( &request->hdr );
     release_object( &connect->hdr );
     TRACE("returning %p\n", hrequest);
     if (hrequest) SetLastError( ERROR_SUCCESS );
     return hrequest;
 }

Referenced by do_request(), download_script(), open_async_request(), test_async(), test_bad_header(), test_basic_authentication(), test_basic_request(), test_chunked_read(), test_connection_cache(), test_connection_info(), test_cookies(), test_credentials(), test_empty_headers_param(), test_head_request(), test_large_data_authentication(), test_multi_authentication(), test_multiple_reads(), test_no_content(), test_no_headers(), test_not_modified(), test_passport_auth(), test_redirect(), test_request_parameter_defaults(), test_resolve_timeout(), test_secure_connection(), test_timeouts(), test_WinHttpAddHeaders(), test_WinHttpOpenRequest(), test_WinHttpQueryOption(), test_WinHttpSendRequest(), transfer_file_http(), and winhttp_request_Open().

◆ WinHttpQueryOption()

BOOL WINAPI WinHttpQueryOption	(	HINTERNET	handle,
		DWORD	option,
		LPVOID	buffer,
		LPDWORD	buflen
	)

Definition at line 1253 of file session.c.

 {
     BOOL ret = FALSE;
     struct object_header *hdr;
 
     TRACE("%p, %u, %p, %p\n", handle, option, buffer, buflen);
 
     if (!(hdr = grab_object( handle )))
     {
         SetLastError( ERROR_INVALID_HANDLE );
         return FALSE;
     }
 
     ret = query_option( hdr, option, buffer, buflen );
 
     release_object( hdr );
     if (ret) SetLastError( ERROR_SUCCESS );
     return ret;
 }

Referenced by check_notification(), test_basic_request(), test_connection_info(), test_credentials(), test_secure_connection(), test_timeouts(), test_WinHttpQueryOption(), and test_WinHttpSendRequest().

◆ WinHttpSetDefaultProxyConfiguration()

BOOL WINAPI WinHttpSetDefaultProxyConfiguration ( WINHTTP_PROXY_INFO * info )

Definition at line 1948 of file session.c.

 {
     LONG l;
     HKEY key;
     BOOL ret = FALSE;
     const WCHAR *src;
 
     TRACE("%p\n", info);
 
     if (!info)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
     switch (info->dwAccessType)
     {
     case WINHTTP_ACCESS_TYPE_NO_PROXY:
         break;
     case WINHTTP_ACCESS_TYPE_NAMED_PROXY:
         if (!info->lpszProxy)
         {
             SetLastError( ERROR_INVALID_PARAMETER );
             return FALSE;
         }
         /* Only ASCII characters are allowed */
         for (src = info->lpszProxy; *src; src++)
             if (*src > 0x7f)
             {
                 SetLastError( ERROR_INVALID_PARAMETER );
                 return FALSE;
             }
         if (info->lpszProxyBypass)
         {
             for (src = info->lpszProxyBypass; *src; src++)
                 if (*src > 0x7f)
                 {
                     SetLastError( ERROR_INVALID_PARAMETER );
                     return FALSE;
                 }
         }
         break;
     default:
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
 
     l = RegCreateKeyExW( HKEY_LOCAL_MACHINE, Connections, 0, NULL, 0,
         KEY_WRITE, NULL, &key, NULL );
     if (!l)
     {
         DWORD size = sizeof(struct connection_settings_header) + 2 * sizeof(DWORD);
         BYTE *buf;
 
         if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
         {
             size += strlenW( info->lpszProxy );
             if (info->lpszProxyBypass)
                 size += strlenW( info->lpszProxyBypass );
         }
         buf = heap_alloc( size );
         if (buf)
         {
             struct connection_settings_header *hdr =
                 (struct connection_settings_header *)buf;
             DWORD *len = (DWORD *)(hdr + 1);
 
             hdr->magic = WINHTTP_SETTINGS_MAGIC;
             hdr->unknown = 0;
             if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
             {
                 BYTE *dst;
 
                 hdr->flags = PROXY_TYPE_PROXY;
                 *len++ = strlenW( info->lpszProxy );
                 for (dst = (BYTE *)len, src = info->lpszProxy; *src;
                     src++, dst++)
                     *dst = *src;
                 len = (DWORD *)dst;
                 if (info->lpszProxyBypass)
                 {
                     *len++ = strlenW( info->lpszProxyBypass );
                     for (dst = (BYTE *)len, src = info->lpszProxyBypass; *src;
                         src++, dst++)
                         *dst = *src;
                 }
                 else
                     *len++ = 0;
             }
             else
             {
                 hdr->flags = PROXY_TYPE_DIRECT;
                 *len++ = 0;
                 *len++ = 0;
             }
             l = RegSetValueExW( key, WinHttpSettings, 0, REG_BINARY, buf, size );
             if (!l)
                 ret = TRUE;
             heap_free( buf );
         }
         RegCloseKey( key );
     }
     if (ret) SetLastError( ERROR_SUCCESS );
     return ret;
 }

Referenced by test_set_default_proxy_config().

◆ WinHttpSetOption()

BOOL WINAPI WinHttpSetOption	(	HINTERNET	handle,
		DWORD	option,
		LPVOID	buffer,
		DWORD	buflen
	)

Definition at line 1312 of file session.c.

 {
     BOOL ret = FALSE;
     struct object_header *hdr;
 
     TRACE("%p, %u, %p, %u\n", handle, option, buffer, buflen);
 
     if (!(hdr = grab_object( handle )))
     {
         SetLastError( ERROR_INVALID_HANDLE );
         return FALSE;
     }
 
     ret = set_option( hdr, option, buffer, buflen );
 
     release_object( hdr );
     if (ret) SetLastError( ERROR_SUCCESS );
     return ret;
 }

Referenced by open_async_request(), request_set_parameters(), test_async(), test_basic_authentication(), test_basic_request(), test_connection_cache(), test_credentials(), test_passport_auth(), test_redirect(), test_resolve_timeout(), test_secure_connection(), test_timeouts(), test_WinHttpQueryOption(), test_WinHttpSendRequest(), transfer_file_http(), and winhttp_request_Open().

◆ WinHttpSetStatusCallback()

WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback	(	HINTERNET	handle,
		WINHTTP_STATUS_CALLBACK	callback,
		DWORD	flags,
		DWORD_PTR	reserved
	)

Definition at line 2056 of file session.c.

 {
     struct object_header *hdr;
     WINHTTP_STATUS_CALLBACK ret;
 
     TRACE("%p, %p, 0x%08x, 0x%lx\n", handle, callback, flags, reserved);
 
     if (!(hdr = grab_object( handle )))
     {
         SetLastError( ERROR_INVALID_HANDLE );
         return WINHTTP_INVALID_STATUS_CALLBACK;
     }
     ret = hdr->callback;
     hdr->callback = callback;
     hdr->notify_mask = flags;
 
     release_object( hdr );
     SetLastError( ERROR_SUCCESS );
     return ret;
 }

Referenced by open_async_request(), test_async(), test_connection_cache(), test_redirect(), test_secure_connection(), transfer_file_http(), and wait_set_status_callback().

◆ WinHttpSetTimeouts()

BOOL WINAPI WinHttpSetTimeouts	(	HINTERNET	handle,
		int	resolve,
		int	connect,
		int	send,
		int	receive
	)

Definition at line 2081 of file session.c.

 {
     BOOL ret = TRUE;
     struct object_header *hdr;
 
     TRACE(

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ COBJMACROS

◆ DEFAULT_CONNECT_TIMEOUT

◆ DEFAULT_RECEIVE_RESPONSE_TIMEOUT

◆ DEFAULT_RECEIVE_TIMEOUT

◆ DEFAULT_RESOLVE_TIMEOUT

◆ DEFAULT_SEND_TIMEOUT

◆ INTERNET_MAX_URL_LENGTH

◆ MAX_HOST_NAME_LENGTH

Function Documentation

◆ add_accept_types_header()

◆ blob_to_str()

◆ buffer_to_str()

◆ build_wpad_url()

◆ connect_destroy()

◆ connect_query_option()

◆ copy_char_to_wchar_sz()

◆ copy_sockaddr()

◆ domain_matches()

◆ download_script()

◆ get_computer_name()

◆ get_request_path()

◆ get_system_proxy_autoconfig_url()

◆ InternetDeInitializeAutoProxyDll()

◆ InternetGetProxyInfo()

◆ InternetInitializeAutoProxyDll()

◆ is_domain_suffix()

◆ parse_script_result()

◆ query_option()

◆ request_destroy()

◆ request_query_option()

◆ request_set_option()

◆ reverse_lookup()

◆ run_script()

◆ send_callback()

◆ session_destroy()

◆ session_query_option()

◆ session_set_option()

◆ set_option()

◆ set_server_for_hostname()

◆ should_bypass_proxy()

◆ str_to_buffer()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

◆ WinHttpCheckPlatform()

◆ WinHttpCloseHandle()

◆ WinHttpConnect()

◆ WinHttpDetectAutoProxyConfigUrl()

◆ WinHttpGetDefaultProxyConfiguration()

◆ WinHttpGetIEProxyConfigForCurrentUser()

◆ WinHttpGetProxyForUrl()

◆ WinHttpOpen()

◆ WinHttpOpenRequest()

◆ WinHttpQueryOption()

◆ WinHttpSetDefaultProxyConfiguration()

◆ WinHttpSetOption()

◆ WinHttpSetStatusCallback()

◆ WinHttpSetTimeouts()