mirror of
https://github.com/reactos/wine.git
synced 2024-12-05 02:07:16 +00:00
2332 lines
69 KiB
C
2332 lines
69 KiB
C
/*
|
|
* Copyright 2008 Hans Leidekker for CodeWeavers
|
|
*
|
|
* 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 "config.h"
|
|
#include "wine/port.h"
|
|
#include "wine/debug.h"
|
|
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winhttp.h"
|
|
#include "wincrypt.h"
|
|
#include "winreg.h"
|
|
#define COBJMACROS
|
|
#include "ole2.h"
|
|
#include "dispex.h"
|
|
#include "activscp.h"
|
|
|
|
#include "winhttp_private.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
|
|
|
|
#define DEFAULT_RESOLVE_TIMEOUT 0
|
|
#define DEFAULT_CONNECT_TIMEOUT 20000
|
|
#define DEFAULT_SEND_TIMEOUT 30000
|
|
#define DEFAULT_RECEIVE_TIMEOUT 30000
|
|
|
|
static const WCHAR global_funcsW[] = {'g','l','o','b','a','l','_','f','u','n','c','s',0};
|
|
static const WCHAR dns_resolveW[] = {'d','n','s','_','r','e','s','o','l','v','e',0};
|
|
|
|
void set_last_error( DWORD error )
|
|
{
|
|
/* FIXME */
|
|
SetLastError( error );
|
|
}
|
|
|
|
DWORD get_last_error( void )
|
|
{
|
|
/* FIXME */
|
|
return GetLastError();
|
|
}
|
|
|
|
void send_callback( object_header_t *hdr, DWORD status, LPVOID info, DWORD buflen )
|
|
{
|
|
TRACE("%p, 0x%08x, %p, %u\n", hdr, status, info, buflen);
|
|
|
|
if (hdr->callback && (hdr->notify_mask & status)) hdr->callback( hdr->handle, hdr->context, status, info, buflen );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpCheckPlatform (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpCheckPlatform( void )
|
|
{
|
|
TRACE("\n");
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* session_destroy (internal)
|
|
*/
|
|
static void session_destroy( object_header_t *hdr )
|
|
{
|
|
session_t *session = (session_t *)hdr;
|
|
struct list *item, *next;
|
|
domain_t *domain;
|
|
|
|
TRACE("%p\n", session);
|
|
|
|
LIST_FOR_EACH_SAFE( item, next, &session->cookie_cache )
|
|
{
|
|
domain = LIST_ENTRY( item, domain_t, entry );
|
|
delete_domain( domain );
|
|
}
|
|
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 );
|
|
}
|
|
|
|
static BOOL session_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
|
|
{
|
|
session_t *session = (session_t *)hdr;
|
|
|
|
switch (option)
|
|
{
|
|
case WINHTTP_OPTION_REDIRECT_POLICY:
|
|
{
|
|
if (!buffer || *buflen < sizeof(DWORD))
|
|
{
|
|
*buflen = sizeof(DWORD);
|
|
set_last_error( 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->recv_timeout;
|
|
*buflen = sizeof(DWORD);
|
|
return TRUE;
|
|
default:
|
|
FIXME("unimplemented option %u\n", option);
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static BOOL session_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
|
|
{
|
|
session_t *session = (session_t *)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))
|
|
{
|
|
set_last_error( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
|
|
policy = *(DWORD *)buffer;
|
|
TRACE("0x%x\n", policy);
|
|
hdr->redirect_policy = policy;
|
|
return TRUE;
|
|
}
|
|
case WINHTTP_OPTION_DISABLE_FEATURE:
|
|
set_last_error( 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->recv_timeout = *(DWORD *)buffer;
|
|
return TRUE;
|
|
default:
|
|
FIXME("unimplemented option %u\n", option);
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static const object_vtbl_t session_vtbl =
|
|
{
|
|
session_destroy,
|
|
session_query_option,
|
|
session_set_option
|
|
};
|
|
|
|
/***********************************************************************
|
|
* WinHttpOpen (winhttp.@)
|
|
*/
|
|
HINTERNET WINAPI WinHttpOpen( LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags )
|
|
{
|
|
session_t *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(session_t) ))) 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->recv_timeout = DEFAULT_RECEIVE_TIMEOUT;
|
|
list_init( &session->cookie_cache );
|
|
|
|
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;
|
|
|
|
end:
|
|
release_object( &session->hdr );
|
|
TRACE("returning %p\n", handle);
|
|
return handle;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* connect_destroy (internal)
|
|
*/
|
|
static void connect_destroy( object_header_t *hdr )
|
|
{
|
|
connect_t *connect = (connect_t *)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 );
|
|
}
|
|
|
|
static BOOL connect_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
|
|
{
|
|
connect_t *connect = (connect_t *)hdr;
|
|
|
|
switch (option)
|
|
{
|
|
case WINHTTP_OPTION_PARENT_HANDLE:
|
|
{
|
|
if (!buffer || *buflen < sizeof(HINTERNET))
|
|
{
|
|
*buflen = sizeof(HINTERNET);
|
|
set_last_error( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
|
|
*(HINTERNET *)buffer = ((object_header_t *)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->recv_timeout;
|
|
*buflen = sizeof(DWORD);
|
|
return TRUE;
|
|
default:
|
|
FIXME("unimplemented option %u\n", option);
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static const object_vtbl_t connect_vtbl =
|
|
{
|
|
connect_destroy,
|
|
connect_query_option,
|
|
NULL
|
|
};
|
|
|
|
static BOOL domain_matches(LPCWSTR server, LPCWSTR domain)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* Matches INTERNET_MAX_HOST_NAME_LENGTH in wininet.h, also RFC 1035 */
|
|
#define MAX_HOST_NAME_LENGTH 256
|
|
|
|
static BOOL should_bypass_proxy(session_t *session, LPCWSTR server)
|
|
{
|
|
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;
|
|
}
|
|
|
|
BOOL set_server_for_hostname( connect_t *connect, LPCWSTR server, INTERNET_PORT port )
|
|
{
|
|
session_t *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;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpConnect (winhttp.@)
|
|
*/
|
|
HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, LPCWSTR server, INTERNET_PORT port, DWORD reserved )
|
|
{
|
|
connect_t *connect;
|
|
session_t *session;
|
|
HINTERNET hconnect = NULL;
|
|
|
|
TRACE("%p, %s, %u, %x\n", hsession, debugstr_w(server), port, reserved);
|
|
|
|
if (!server)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return NULL;
|
|
}
|
|
if (!(session = (session_t *)grab_object( hsession )))
|
|
{
|
|
set_last_error( ERROR_INVALID_HANDLE );
|
|
return NULL;
|
|
}
|
|
if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
|
|
{
|
|
release_object( &session->hdr );
|
|
set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
|
|
return NULL;
|
|
}
|
|
if (!(connect = heap_alloc_zero( sizeof(connect_t) )))
|
|
{
|
|
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;
|
|
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);
|
|
return hconnect;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* request_destroy (internal)
|
|
*/
|
|
static void request_destroy( object_header_t *hdr )
|
|
{
|
|
request_t *request = (request_t *)hdr;
|
|
unsigned int i;
|
|
|
|
TRACE("%p\n", request);
|
|
|
|
release_object( &request->connect->hdr );
|
|
|
|
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 < request->num_accept_types; i++) heap_free( request->accept_types[i] );
|
|
heap_free( request->accept_types );
|
|
heap_free( request );
|
|
}
|
|
|
|
static void str_to_buffer( WCHAR *buffer, const WCHAR *str, LPDWORD buflen )
|
|
{
|
|
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);
|
|
}
|
|
|
|
static WCHAR *blob_to_str( DWORD encoding, CERT_NAME_BLOB *blob )
|
|
{
|
|
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;
|
|
}
|
|
|
|
static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
|
|
{
|
|
request_t *request = (request_t *)hdr;
|
|
|
|
switch (option)
|
|
{
|
|
case WINHTTP_OPTION_SECURITY_FLAGS:
|
|
{
|
|
DWORD flags;
|
|
int bits;
|
|
|
|
if (!buffer || *buflen < sizeof(flags))
|
|
{
|
|
*buflen = sizeof(flags);
|
|
set_last_error( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
|
|
flags = 0;
|
|
if (hdr->flags & WINHTTP_FLAG_SECURE) flags |= SECURITY_FLAG_SECURE;
|
|
flags |= request->netconn.security_flags;
|
|
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);
|
|
set_last_error( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
|
|
if (!(cert = netconn_get_certificate( &request->netconn ))) return FALSE;
|
|
*(CERT_CONTEXT **)buffer = (CERT_CONTEXT *)cert;
|
|
*buflen = sizeof(cert);
|
|
return TRUE;
|
|
}
|
|
case WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT:
|
|
{
|
|
const CERT_CONTEXT *cert;
|
|
const CRYPT_OID_INFO *oidInfo;
|
|
WINHTTP_CERTIFICATE_INFO *ci = buffer;
|
|
|
|
FIXME("partial stub\n");
|
|
|
|
if (!buffer || *buflen < sizeof(*ci))
|
|
{
|
|
*buflen = sizeof(*ci);
|
|
set_last_error( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
if (!(cert = netconn_get_certificate( &request->netconn ))) 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 = netconn_get_cipher_strength( &request->netconn );
|
|
|
|
CertFreeCertificateContext( cert );
|
|
*buflen = sizeof(*ci);
|
|
return TRUE;
|
|
}
|
|
case WINHTTP_OPTION_SECURITY_KEY_BITNESS:
|
|
{
|
|
if (!buffer || *buflen < sizeof(DWORD))
|
|
{
|
|
*buflen = sizeof(DWORD);
|
|
set_last_error( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
|
|
*(DWORD *)buffer = netconn_get_cipher_strength( &request->netconn );
|
|
*buflen = sizeof(DWORD);
|
|
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->recv_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);
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static WCHAR *buffer_to_str( WCHAR *buffer, DWORD buflen )
|
|
{
|
|
WCHAR *ret;
|
|
if ((ret = heap_alloc( (buflen + 1) * sizeof(WCHAR))))
|
|
{
|
|
memcpy( ret, buffer, buflen * sizeof(WCHAR) );
|
|
ret[buflen] = 0;
|
|
return ret;
|
|
}
|
|
set_last_error( ERROR_OUTOFMEMORY );
|
|
return NULL;
|
|
}
|
|
|
|
static BOOL request_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
|
|
{
|
|
request_t *request = (request_t *)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))
|
|
{
|
|
set_last_error( 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))
|
|
{
|
|
set_last_error( 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))
|
|
{
|
|
set_last_error( 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;
|
|
|
|
if (buflen < sizeof(DWORD))
|
|
{
|
|
set_last_error( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
flags = *(DWORD *)buffer;
|
|
TRACE("0x%x\n", flags);
|
|
if (!(flags & (SECURITY_FLAG_IGNORE_CERT_CN_INVALID |
|
|
SECURITY_FLAG_IGNORE_CERT_DATE_INVALID |
|
|
SECURITY_FLAG_IGNORE_UNKNOWN_CA |
|
|
SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE)))
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
request->netconn.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->recv_timeout = *(DWORD *)buffer;
|
|
return TRUE;
|
|
|
|
case WINHTTP_OPTION_USERNAME:
|
|
{
|
|
connect_t *connect = request->connect;
|
|
|
|
heap_free( connect->username );
|
|
if (!(connect->username = buffer_to_str( buffer, buflen ))) return FALSE;
|
|
return TRUE;
|
|
}
|
|
case WINHTTP_OPTION_PASSWORD:
|
|
{
|
|
connect_t *connect = request->connect;
|
|
|
|
heap_free( connect->password );
|
|
if (!(connect->password = buffer_to_str( buffer, buflen ))) return FALSE;
|
|
return TRUE;
|
|
}
|
|
case WINHTTP_OPTION_PROXY_USERNAME:
|
|
{
|
|
session_t *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:
|
|
{
|
|
session_t *session = request->connect->session;
|
|
|
|
heap_free( session->proxy_password );
|
|
if (!(session->proxy_password = buffer_to_str( buffer, buflen ))) return FALSE;
|
|
return TRUE;
|
|
}
|
|
default:
|
|
FIXME("unimplemented option %u\n", option);
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
static const object_vtbl_t request_vtbl =
|
|
{
|
|
request_destroy,
|
|
request_query_option,
|
|
request_set_option
|
|
};
|
|
|
|
static BOOL store_accept_types( request_t *request, const WCHAR **accept_types )
|
|
{
|
|
const WCHAR **types = accept_types;
|
|
int i;
|
|
|
|
if (!types) return TRUE;
|
|
while (*types)
|
|
{
|
|
request->num_accept_types++;
|
|
types++;
|
|
}
|
|
if (!request->num_accept_types) return TRUE;
|
|
if (!(request->accept_types = heap_alloc( request->num_accept_types * sizeof(WCHAR *))))
|
|
{
|
|
request->num_accept_types = 0;
|
|
return FALSE;
|
|
}
|
|
types = accept_types;
|
|
for (i = 0; i < request->num_accept_types; i++)
|
|
{
|
|
if (!(request->accept_types[i] = strdupW( *types )))
|
|
{
|
|
for (; i >= 0; i--) heap_free( request->accept_types[i] );
|
|
heap_free( request->accept_types );
|
|
request->accept_types = NULL;
|
|
request->num_accept_types = 0;
|
|
return FALSE;
|
|
}
|
|
types++;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpOpenRequest (winhttp.@)
|
|
*/
|
|
HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR object, LPCWSTR version,
|
|
LPCWSTR referrer, LPCWSTR *types, DWORD flags )
|
|
{
|
|
request_t *request;
|
|
connect_t *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 (!(connect = (connect_t *)grab_object( hconnect )))
|
|
{
|
|
set_last_error( ERROR_INVALID_HANDLE );
|
|
return NULL;
|
|
}
|
|
if (connect->hdr.type != WINHTTP_HANDLE_TYPE_CONNECT)
|
|
{
|
|
release_object( &connect->hdr );
|
|
set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
|
|
return NULL;
|
|
}
|
|
if (!(request = heap_alloc_zero( sizeof(request_t) )))
|
|
{
|
|
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;
|
|
list_init( &request->hdr.children );
|
|
|
|
addref_object( &connect->hdr );
|
|
request->connect = connect;
|
|
list_add_head( &connect->hdr.children, &request->hdr.entry );
|
|
|
|
if (!netconn_init( &request->netconn, request->hdr.flags & WINHTTP_FLAG_SECURE )) goto end;
|
|
request->resolve_timeout = connect->session->resolve_timeout;
|
|
request->connect_timeout = connect->session->connect_timeout;
|
|
request->send_timeout = connect->session->send_timeout;
|
|
request->recv_timeout = connect->session->recv_timeout;
|
|
|
|
if (!verb || !verb[0]) verb = getW;
|
|
if (!(request->verb = strdupW( verb ))) goto end;
|
|
|
|
if (object)
|
|
{
|
|
WCHAR *path, *p;
|
|
unsigned int len;
|
|
|
|
len = strlenW( object ) + 1;
|
|
if (object[0] != '/') len++;
|
|
if (!(p = path = heap_alloc( len * sizeof(WCHAR) ))) goto end;
|
|
|
|
if (object[0] != '/') *p++ = '/';
|
|
strcpyW( p, object );
|
|
request->path = path;
|
|
}
|
|
else if (!(request->path = strdupW( slashW ))) goto end;
|
|
|
|
if (!version || !version[0]) version = http1_1;
|
|
if (!(request->version = strdupW( version ))) goto end;
|
|
if (!(store_accept_types( 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);
|
|
return hrequest;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpCloseHandle (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpCloseHandle( HINTERNET handle )
|
|
{
|
|
object_header_t *hdr;
|
|
|
|
TRACE("%p\n", handle);
|
|
|
|
if (!(hdr = grab_object( handle )))
|
|
{
|
|
set_last_error( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
release_object( hdr );
|
|
free_handle( handle );
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
if (!buflen)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
switch (option)
|
|
{
|
|
case WINHTTP_OPTION_CONTEXT_VALUE:
|
|
{
|
|
if (!buffer || *buflen < sizeof(DWORD_PTR))
|
|
{
|
|
*buflen = sizeof(DWORD_PTR);
|
|
set_last_error( 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);
|
|
set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpQueryOption (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpQueryOption( HINTERNET handle, DWORD option, LPVOID buffer, LPDWORD buflen )
|
|
{
|
|
BOOL ret = FALSE;
|
|
object_header_t *hdr;
|
|
|
|
TRACE("%p, %u, %p, %p\n", handle, option, buffer, buflen);
|
|
|
|
if (!(hdr = grab_object( handle )))
|
|
{
|
|
set_last_error( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
ret = query_option( hdr, option, buffer, buflen );
|
|
|
|
release_object( hdr );
|
|
return ret;
|
|
}
|
|
|
|
static BOOL set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
|
|
{
|
|
BOOL ret = TRUE;
|
|
|
|
if (!buffer)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
switch (option)
|
|
{
|
|
case WINHTTP_OPTION_CONTEXT_VALUE:
|
|
{
|
|
if (buflen != sizeof(DWORD_PTR))
|
|
{
|
|
set_last_error( 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);
|
|
set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpSetOption (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpSetOption( HINTERNET handle, DWORD option, LPVOID buffer, DWORD buflen )
|
|
{
|
|
BOOL ret = FALSE;
|
|
object_header_t *hdr;
|
|
|
|
TRACE("%p, %u, %p, %u\n", handle, option, buffer, buflen);
|
|
|
|
if (!(hdr = grab_object( handle )))
|
|
{
|
|
set_last_error( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
ret = set_option( hdr, option, buffer, buflen );
|
|
|
|
release_object( hdr );
|
|
return ret;
|
|
}
|
|
|
|
static char *get_computer_name( COMPUTER_NAME_FORMAT format )
|
|
{
|
|
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;
|
|
}
|
|
|
|
static BOOL is_domain_suffix( const char *domain, const char *suffix )
|
|
{
|
|
int len_domain = strlen( domain ), len_suffix = strlen( suffix );
|
|
|
|
if (len_suffix > len_domain) return FALSE;
|
|
if (!strcasecmp( domain + len_domain - len_suffix, suffix )) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
static void printf_addr( const WCHAR *fmt, WCHAR *buf, struct sockaddr_in *addr )
|
|
{
|
|
sprintfW( buf, fmt,
|
|
(unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 24 & 0xff),
|
|
(unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 16 & 0xff),
|
|
(unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 8 & 0xff),
|
|
(unsigned int)(ntohl( addr->sin_addr.s_addr ) & 0xff) );
|
|
}
|
|
|
|
static WCHAR *build_wpad_url( const struct addrinfo *ai )
|
|
{
|
|
static const WCHAR fmtW[] =
|
|
{'h','t','t','p',':','/','/','%','u','.','%','u','.','%','u','.','%','u',
|
|
'/','w','p','a','d','.','d','a','t',0};
|
|
WCHAR *ret;
|
|
|
|
while (ai && ai->ai_family != AF_INET) ai = ai->ai_next;
|
|
if (!ai) return NULL;
|
|
|
|
if (!(ret = GlobalAlloc( 0, sizeof(fmtW) + 12 * sizeof(WCHAR) ))) return NULL;
|
|
printf_addr( fmtW, ret, (struct sockaddr_in *)ai->ai_addr );
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpDetectAutoProxyConfigUrl (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpDetectAutoProxyConfigUrl( DWORD flags, LPWSTR *url )
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
TRACE("0x%08x, %p\n", flags, url);
|
|
|
|
if (!flags || !url)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
if (flags & WINHTTP_AUTO_DETECT_TYPE_DHCP) FIXME("discovery via DHCP not supported\n");
|
|
if (flags & WINHTTP_AUTO_DETECT_TYPE_DNS_A)
|
|
{
|
|
#ifdef HAVE_GETADDRINFO
|
|
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 );
|
|
heap_free( name );
|
|
if (!res)
|
|
{
|
|
*url = build_wpad_url( ai );
|
|
freeaddrinfo( ai );
|
|
if (*url)
|
|
{
|
|
TRACE("returning %s\n", debugstr_w(*url));
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
heap_free( domain );
|
|
heap_free( fqdn );
|
|
#else
|
|
FIXME("getaddrinfo not found at build time\n");
|
|
#endif
|
|
}
|
|
if (!ret) set_last_error( ERROR_WINHTTP_AUTODETECTION_FAILED );
|
|
return ret;
|
|
}
|
|
|
|
static const WCHAR Connections[] = {
|
|
'S','o','f','t','w','a','r','e','\\',
|
|
'M','i','c','r','o','s','o','f','t','\\',
|
|
'W','i','n','d','o','w','s','\\',
|
|
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
|
|
'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
|
|
'C','o','n','n','e','c','t','i','o','n','s',0 };
|
|
static const WCHAR WinHttpSettings[] = {
|
|
'W','i','n','H','t','t','p','S','e','t','t','i','n','g','s',0 };
|
|
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;
|
|
|
|
struct connection_settings_header
|
|
{
|
|
DWORD magic;
|
|
DWORD unknown; /* always zero? */
|
|
DWORD flags; /* one or more of PROXY_* */
|
|
};
|
|
|
|
static inline void copy_char_to_wchar_sz(const BYTE *src, DWORD len, WCHAR *dst)
|
|
{
|
|
const BYTE *begin;
|
|
|
|
for (begin = src; src - begin < len; src++, dst++)
|
|
*dst = *src;
|
|
*dst = 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpGetDefaultProxyConfiguration (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
|
|
{
|
|
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;
|
|
|
|
if ((colon = strchr( envproxy, ':' )))
|
|
{
|
|
if (*(colon + 1) == '/' && *(colon + 2) == '/')
|
|
{
|
|
static const char http[] = "http://";
|
|
|
|
/* It's a scheme, check that it's http */
|
|
if (!strncmp( envproxy, http, strlen( http ) ))
|
|
http_proxy = envproxy + strlen( http );
|
|
else
|
|
{
|
|
WARN("unsupported scheme in $http_proxy: %s\n", envproxy);
|
|
http_proxy = NULL;
|
|
}
|
|
}
|
|
else
|
|
http_proxy = envproxy;
|
|
}
|
|
else
|
|
http_proxy = envproxy;
|
|
if (http_proxy)
|
|
{
|
|
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;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpGetIEProxyConfigForCurrentUser (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *config )
|
|
{
|
|
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)
|
|
{
|
|
set_last_error( 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)
|
|
{
|
|
heap_free( config->lpszAutoConfigUrl );
|
|
config->lpszAutoConfigUrl = NULL;
|
|
heap_free( config->lpszProxy );
|
|
config->lpszProxy = NULL;
|
|
heap_free( config->lpszProxyBypass );
|
|
config->lpszProxyBypass = NULL;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_QueryInterface(
|
|
IDispatchEx *iface, REFIID riid, void **ppv )
|
|
{
|
|
*ppv = NULL;
|
|
|
|
if (IsEqualGUID( riid, &IID_IUnknown ) ||
|
|
IsEqualGUID( riid, &IID_IDispatch ) ||
|
|
IsEqualGUID( riid, &IID_IDispatchEx ))
|
|
*ppv = iface;
|
|
else
|
|
return E_NOINTERFACE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG WINAPI dispex_AddRef(
|
|
IDispatchEx *iface )
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
static ULONG WINAPI dispex_Release(
|
|
IDispatchEx *iface )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_GetTypeInfoCount(
|
|
IDispatchEx *iface, UINT *info )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_GetTypeInfo(
|
|
IDispatchEx *iface, UINT info, LCID lcid, ITypeInfo **type_info )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_GetIDsOfNames(
|
|
IDispatchEx *iface, REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *id )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_Invoke(
|
|
IDispatchEx *iface, DISPID member, REFIID riid, LCID lcid, WORD flags,
|
|
DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep, UINT *err )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_DeleteMemberByName(
|
|
IDispatchEx *iface, BSTR name, DWORD flags )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_DeleteMemberByDispID(
|
|
IDispatchEx *iface, DISPID id )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_GetMemberProperties(
|
|
IDispatchEx *iface, DISPID id, DWORD flags_fetch, DWORD *flags )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_GetMemberName(
|
|
IDispatchEx *iface, DISPID id, BSTR *name )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_GetNextDispID(
|
|
IDispatchEx *iface, DWORD flags, DISPID id, DISPID *next )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_GetNameSpaceParent(
|
|
IDispatchEx *iface, IUnknown **unk )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
#define DISPID_GLOBAL_DNSRESOLVE 0x1000
|
|
|
|
static HRESULT WINAPI dispex_GetDispID(
|
|
IDispatchEx *iface, BSTR name, DWORD flags, DISPID *id )
|
|
{
|
|
if (!strcmpW( name, dns_resolveW ))
|
|
{
|
|
*id = DISPID_GLOBAL_DNSRESOLVE;
|
|
return S_OK;
|
|
}
|
|
return DISP_E_UNKNOWNNAME;
|
|
}
|
|
|
|
static HRESULT dns_resolve( const WCHAR *hostname, VARIANT *result )
|
|
{
|
|
#ifdef HAVE_GETADDRINFO
|
|
static const WCHAR fmtW[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
|
|
WCHAR addr[16];
|
|
struct addrinfo *ai, *elem;
|
|
char *hostnameA;
|
|
int res;
|
|
|
|
if (hostname[0])
|
|
hostnameA = strdupWA( hostname );
|
|
else
|
|
hostnameA = get_computer_name( ComputerNamePhysicalDnsFullyQualified );
|
|
|
|
if (!hostnameA) return E_OUTOFMEMORY;
|
|
res = getaddrinfo( hostnameA, NULL, NULL, &ai );
|
|
heap_free( hostnameA );
|
|
if (res) return S_FALSE;
|
|
|
|
elem = ai;
|
|
while (elem && elem->ai_family != AF_INET) elem = elem->ai_next;
|
|
if (!elem)
|
|
{
|
|
freeaddrinfo( ai );
|
|
return S_FALSE;
|
|
}
|
|
printf_addr( fmtW, addr, (struct sockaddr_in *)elem->ai_addr );
|
|
freeaddrinfo( ai );
|
|
V_VT( result ) = VT_BSTR;
|
|
V_BSTR( result ) = SysAllocString( addr );
|
|
return S_OK;
|
|
#else
|
|
FIXME("getaddrinfo not found at build time\n");
|
|
return S_FALSE;
|
|
#endif
|
|
}
|
|
|
|
static HRESULT WINAPI dispex_InvokeEx(
|
|
IDispatchEx *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
|
|
VARIANT *result, EXCEPINFO *exep, IServiceProvider *caller )
|
|
{
|
|
if (id == DISPID_GLOBAL_DNSRESOLVE)
|
|
{
|
|
if (params->cArgs != 1) return DISP_E_BADPARAMCOUNT;
|
|
if (V_VT(¶ms->rgvarg[0]) != VT_BSTR) return DISP_E_BADVARTYPE;
|
|
return dns_resolve( V_BSTR(¶ms->rgvarg[0]), result );
|
|
}
|
|
return DISP_E_MEMBERNOTFOUND;
|
|
}
|
|
|
|
static const IDispatchExVtbl dispex_vtbl =
|
|
{
|
|
dispex_QueryInterface,
|
|
dispex_AddRef,
|
|
dispex_Release,
|
|
dispex_GetTypeInfoCount,
|
|
dispex_GetTypeInfo,
|
|
dispex_GetIDsOfNames,
|
|
dispex_Invoke,
|
|
dispex_GetDispID,
|
|
dispex_InvokeEx,
|
|
dispex_DeleteMemberByName,
|
|
dispex_DeleteMemberByDispID,
|
|
dispex_GetMemberProperties,
|
|
dispex_GetMemberName,
|
|
dispex_GetNextDispID,
|
|
dispex_GetNameSpaceParent
|
|
};
|
|
|
|
static IDispatchEx global_dispex = { &dispex_vtbl };
|
|
|
|
static HRESULT WINAPI site_QueryInterface(
|
|
IActiveScriptSite *iface, REFIID riid, void **ppv )
|
|
{
|
|
*ppv = NULL;
|
|
|
|
if (IsEqualGUID( &IID_IUnknown, riid ))
|
|
*ppv = iface;
|
|
else if (IsEqualGUID( &IID_IActiveScriptSite, riid ))
|
|
*ppv = iface;
|
|
else
|
|
return E_NOINTERFACE;
|
|
|
|
IUnknown_AddRef( (IUnknown *)*ppv );
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG WINAPI site_AddRef(
|
|
IActiveScriptSite *iface )
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
static ULONG WINAPI site_Release(
|
|
IActiveScriptSite *iface )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static HRESULT WINAPI site_GetLCID(
|
|
IActiveScriptSite *iface, LCID *lcid )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI site_GetItemInfo(
|
|
IActiveScriptSite *iface, LPCOLESTR name, DWORD mask,
|
|
IUnknown **item, ITypeInfo **type_info )
|
|
{
|
|
if (!strcmpW( name, global_funcsW ) && mask == SCRIPTINFO_IUNKNOWN)
|
|
{
|
|
*item = (IUnknown *)&global_dispex;
|
|
return S_OK;
|
|
}
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI site_GetDocVersionString(
|
|
IActiveScriptSite *iface, BSTR *version )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI site_OnScriptTerminate(
|
|
IActiveScriptSite *iface, const VARIANT *result, const EXCEPINFO *info )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI site_OnStateChange(
|
|
IActiveScriptSite *iface, SCRIPTSTATE state )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI site_OnScriptError(
|
|
IActiveScriptSite *iface, IActiveScriptError *error )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI site_OnEnterScript(
|
|
IActiveScriptSite *iface )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI site_OnLeaveScript(
|
|
IActiveScriptSite *iface )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IActiveScriptSiteVtbl site_vtbl =
|
|
{
|
|
site_QueryInterface,
|
|
site_AddRef,
|
|
site_Release,
|
|
site_GetLCID,
|
|
site_GetItemInfo,
|
|
site_GetDocVersionString,
|
|
site_OnScriptTerminate,
|
|
site_OnStateChange,
|
|
site_OnScriptError,
|
|
site_OnEnterScript,
|
|
site_OnLeaveScript
|
|
};
|
|
|
|
static IActiveScriptSite script_site = { &site_vtbl };
|
|
|
|
static BOOL parse_script_result( VARIANT result, WINHTTP_PROXY_INFO *info )
|
|
{
|
|
static const WCHAR proxyW[] = {'P','R','O','X','Y'};
|
|
const WCHAR *p;
|
|
WCHAR *q;
|
|
int len;
|
|
|
|
info->dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
|
|
info->lpszProxy = NULL;
|
|
info->lpszProxyBypass = NULL;
|
|
|
|
if (V_VT( &result ) != VT_BSTR) return TRUE;
|
|
TRACE("%s\n", debugstr_w( V_BSTR( &result ) ));
|
|
|
|
p = V_BSTR( &result );
|
|
while (*p == ' ') p++;
|
|
len = strlenW( p );
|
|
if (len >= 5 && !memicmpW( p, proxyW, sizeof(proxyW)/sizeof(WCHAR) ))
|
|
{
|
|
p += 5;
|
|
while (*p == ' ') p++;
|
|
if (!*p || *p == ';') return TRUE;
|
|
if (!(info->lpszProxy = q = strdupW( p ))) return FALSE;
|
|
info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
|
|
for (; *q; q++)
|
|
{
|
|
if (*q == ' ' || *q == ';')
|
|
{
|
|
*q = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static BSTR include_pac_utils( BSTR script )
|
|
{
|
|
static const WCHAR pacjsW[] = {'p','a','c','.','j','s',0};
|
|
HMODULE hmod = GetModuleHandleA( "winhttp.dll" );
|
|
HRSRC rsrc;
|
|
DWORD size;
|
|
const char *data;
|
|
BSTR ret;
|
|
int len;
|
|
|
|
if (!(rsrc = FindResourceW( hmod, pacjsW, (LPCWSTR)40 ))) return NULL;
|
|
size = SizeofResource( hmod, rsrc );
|
|
data = LoadResource( hmod, rsrc );
|
|
|
|
len = MultiByteToWideChar( CP_ACP, 0, data, size, NULL, 0 );
|
|
if (!(ret = SysAllocStringLen( NULL, len + SysStringLen( script ) + 1 ))) return NULL;
|
|
MultiByteToWideChar( CP_ACP, 0, data, size, ret, len );
|
|
ret[len] = 0;
|
|
strcatW( ret, script );
|
|
return ret;
|
|
}
|
|
|
|
static BOOL run_script( const BSTR script, const WCHAR *url, WINHTTP_PROXY_INFO *info )
|
|
{
|
|
static const WCHAR jscriptW[] = {'J','S','c','r','i','p','t',0};
|
|
static const WCHAR findproxyW[] = {'F','i','n','d','P','r','o','x','y','F','o','r','U','R','L',0};
|
|
IActiveScriptParse *parser = NULL;
|
|
IActiveScript *engine = NULL;
|
|
IDispatch *dispatch = NULL;
|
|
BOOL ret = FALSE;
|
|
CLSID clsid;
|
|
DISPID dispid;
|
|
BSTR func = NULL, hostname = NULL, full_script = NULL;
|
|
URL_COMPONENTSW uc;
|
|
VARIANT args[2], result;
|
|
DISPPARAMS params;
|
|
HRESULT hr, init;
|
|
|
|
memset( &uc, 0, sizeof(uc) );
|
|
uc.dwStructSize = sizeof(uc);
|
|
if (!WinHttpCrackUrl( url, 0, 0, &uc )) return FALSE;
|
|
if (!(hostname = SysAllocStringLen( NULL, uc.dwHostNameLength + 1 ))) return FALSE;
|
|
memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
|
|
hostname[uc.dwHostNameLength] = 0;
|
|
|
|
init = CoInitialize( NULL );
|
|
hr = CLSIDFromProgID( jscriptW, &clsid );
|
|
if (hr != S_OK) goto done;
|
|
|
|
hr = CoCreateInstance( &clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
|
|
&IID_IActiveScript, (void **)&engine );
|
|
if (hr != S_OK) goto done;
|
|
|
|
hr = IActiveScript_QueryInterface( engine, &IID_IActiveScriptParse, (void **)&parser );
|
|
if (hr != S_OK) goto done;
|
|
|
|
hr = IActiveScriptParse64_InitNew( parser );
|
|
if (hr != S_OK) goto done;
|
|
|
|
hr = IActiveScript_SetScriptSite( engine, &script_site );
|
|
if (hr != S_OK) goto done;
|
|
|
|
hr = IActiveScript_AddNamedItem( engine, global_funcsW, SCRIPTITEM_GLOBALMEMBERS );
|
|
if (hr != S_OK) goto done;
|
|
|
|
if (!(full_script = include_pac_utils( script ))) goto done;
|
|
|
|
hr = IActiveScriptParse64_ParseScriptText( parser, full_script, NULL, NULL, NULL, 0, 0, 0, NULL, NULL );
|
|
if (hr != S_OK) goto done;
|
|
|
|
hr = IActiveScript_SetScriptState( engine, SCRIPTSTATE_STARTED );
|
|
if (hr != S_OK) goto done;
|
|
|
|
hr = IActiveScript_GetScriptDispatch( engine, NULL, &dispatch );
|
|
if (hr != S_OK) goto done;
|
|
|
|
if (!(func = SysAllocString( findproxyW ))) goto done;
|
|
hr = IDispatch_GetIDsOfNames( dispatch, &IID_NULL, &func, 1, LOCALE_SYSTEM_DEFAULT, &dispid );
|
|
if (hr != S_OK) goto done;
|
|
|
|
V_VT( &args[0] ) = VT_BSTR;
|
|
V_BSTR( &args[0] ) = hostname;
|
|
V_VT( &args[1] ) = VT_BSTR;
|
|
V_BSTR( &args[1] ) = SysAllocString( url );
|
|
|
|
params.rgvarg = args;
|
|
params.rgdispidNamedArgs = NULL;
|
|
params.cArgs = 2;
|
|
params.cNamedArgs = 0;
|
|
hr = IDispatch_Invoke( dispatch, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD,
|
|
¶ms, &result, NULL, NULL );
|
|
VariantClear( &args[1] );
|
|
if (hr != S_OK)
|
|
{
|
|
WARN("script failed 0x%08x\n", hr);
|
|
goto done;
|
|
}
|
|
ret = parse_script_result( result, info );
|
|
|
|
done:
|
|
SysFreeString( full_script );
|
|
SysFreeString( hostname );
|
|
SysFreeString( func );
|
|
if (dispatch) IDispatch_Release( dispatch );
|
|
if (parser) IUnknown_Release( parser );
|
|
if (engine) IActiveScript_Release( engine );
|
|
if (SUCCEEDED( init )) CoUninitialize();
|
|
if (!ret) set_last_error( ERROR_WINHTTP_BAD_AUTO_PROXY_SCRIPT );
|
|
return ret;
|
|
}
|
|
|
|
static BSTR download_script( const WCHAR *url )
|
|
{
|
|
static const WCHAR typeW[] = {'*','/','*',0};
|
|
static const WCHAR *acceptW[] = {typeW, NULL};
|
|
HINTERNET ses, con = NULL, req = NULL;
|
|
WCHAR *hostname;
|
|
URL_COMPONENTSW uc;
|
|
DWORD size = 4096, offset, to_read, bytes_read, flags = 0;
|
|
char *tmp, *buffer = NULL;
|
|
BSTR script = NULL;
|
|
int len;
|
|
|
|
memset( &uc, 0, sizeof(uc) );
|
|
uc.dwStructSize = sizeof(uc);
|
|
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 (!(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;
|
|
if (!to_read)
|
|
{
|
|
to_read = size;
|
|
size *= 2;
|
|
if (!(tmp = heap_realloc( buffer, size ))) goto done;
|
|
buffer = tmp;
|
|
}
|
|
}
|
|
len = MultiByteToWideChar( CP_ACP, 0, buffer, offset, NULL, 0 );
|
|
if (!(script = SysAllocStringLen( NULL, len ))) goto done;
|
|
MultiByteToWideChar( CP_ACP, 0, buffer, offset, script, len );
|
|
script[len] = 0;
|
|
|
|
done:
|
|
WinHttpCloseHandle( req );
|
|
WinHttpCloseHandle( con );
|
|
WinHttpCloseHandle( ses );
|
|
heap_free( buffer );
|
|
heap_free( hostname );
|
|
if (!script) set_last_error( ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT );
|
|
return script;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpGetProxyForUrl (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS *options,
|
|
WINHTTP_PROXY_INFO *info )
|
|
{
|
|
WCHAR *detected_pac_url = NULL;
|
|
const WCHAR *pac_url;
|
|
session_t *session;
|
|
BSTR script;
|
|
BOOL ret = FALSE;
|
|
|
|
TRACE("%p, %s, %p, %p\n", hsession, debugstr_w(url), options, info);
|
|
|
|
if (!(session = (session_t *)grab_object( hsession )))
|
|
{
|
|
set_last_error( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
|
|
{
|
|
release_object( &session->hdr );
|
|
set_last_error( 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 );
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
if (options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT &&
|
|
!WinHttpDetectAutoProxyConfigUrl( options->dwAutoDetectFlags, &detected_pac_url ))
|
|
{
|
|
set_last_error( ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR );
|
|
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 ))) goto done;
|
|
ret = run_script( script, url, info );
|
|
SysFreeString( script );
|
|
|
|
done:
|
|
GlobalFree( detected_pac_url );
|
|
release_object( &session->hdr );
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpSetDefaultProxyConfiguration (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
|
|
{
|
|
LONG l;
|
|
HKEY key;
|
|
BOOL ret = FALSE;
|
|
const WCHAR *src;
|
|
|
|
TRACE("%p\n", info);
|
|
|
|
if (!info)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
switch (info->dwAccessType)
|
|
{
|
|
case WINHTTP_ACCESS_TYPE_NO_PROXY:
|
|
break;
|
|
case WINHTTP_ACCESS_TYPE_NAMED_PROXY:
|
|
if (!info->lpszProxy)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
/* Only ASCII characters are allowed */
|
|
for (src = info->lpszProxy; *src; src++)
|
|
if (*src > 0x7f)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
if (info->lpszProxyBypass)
|
|
{
|
|
for (src = info->lpszProxyBypass; *src; src++)
|
|
if (*src > 0x7f)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
set_last_error( 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 );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpSetStatusCallback (winhttp.@)
|
|
*/
|
|
WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback( HINTERNET handle, WINHTTP_STATUS_CALLBACK callback,
|
|
DWORD flags, DWORD_PTR reserved )
|
|
{
|
|
object_header_t *hdr;
|
|
WINHTTP_STATUS_CALLBACK ret;
|
|
|
|
TRACE("%p, %p, 0x%08x, 0x%lx\n", handle, callback, flags, reserved);
|
|
|
|
if (!(hdr = grab_object( handle )))
|
|
{
|
|
set_last_error( ERROR_INVALID_HANDLE );
|
|
return WINHTTP_INVALID_STATUS_CALLBACK;
|
|
}
|
|
ret = hdr->callback;
|
|
hdr->callback = callback;
|
|
hdr->notify_mask = flags;
|
|
|
|
release_object( hdr );
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpSetTimeouts (winhttp.@)
|
|
*/
|
|
BOOL WINAPI WinHttpSetTimeouts( HINTERNET handle, int resolve, int connect, int send, int receive )
|
|
{
|
|
BOOL ret = TRUE;
|
|
object_header_t *hdr;
|
|
request_t *request;
|
|
session_t *session;
|
|
|
|
TRACE("%p, %d, %d, %d, %d\n", handle, resolve, connect, send, receive);
|
|
|
|
if (resolve < -1 || connect < -1 || send < -1 || receive < -1)
|
|
{
|
|
set_last_error( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
if (!(hdr = grab_object( handle )))
|
|
{
|
|
set_last_error( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
switch(hdr->type)
|
|
{
|
|
case WINHTTP_HANDLE_TYPE_REQUEST:
|
|
request = (request_t *)hdr;
|
|
request->connect_timeout = connect;
|
|
|
|
if (resolve < 0) resolve = 0;
|
|
request->resolve_timeout = resolve;
|
|
|
|
if (send < 0) send = 0;
|
|
request->send_timeout = send;
|
|
|
|
if (receive < 0) receive = 0;
|
|
request->recv_timeout = receive;
|
|
|
|
if (netconn_connected( &request->netconn ))
|
|
{
|
|
if (netconn_set_timeout( &request->netconn, TRUE, send )) ret = FALSE;
|
|
if (netconn_set_timeout( &request->netconn, FALSE, receive )) ret = FALSE;
|
|
}
|
|
|
|
release_object( &request->hdr );
|
|
break;
|
|
|
|
case WINHTTP_HANDLE_TYPE_SESSION:
|
|
session = (session_t *)hdr;
|
|
session->connect_timeout = connect;
|
|
|
|
if (resolve < 0) resolve = 0;
|
|
session->resolve_timeout = resolve;
|
|
|
|
if (send < 0) send = 0;
|
|
session->send_timeout = send;
|
|
|
|
if (receive < 0) receive = 0;
|
|
session->recv_timeout = receive;
|
|
break;
|
|
|
|
default:
|
|
release_object( hdr );
|
|
set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
|
|
return FALSE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const WCHAR wkday[7][4] =
|
|
{{'S','u','n', 0}, {'M','o','n', 0}, {'T','u','e', 0}, {'W','e','d', 0},
|
|
{'T','h','u', 0}, {'F','r','i', 0}, {'S','a','t', 0}};
|
|
static const WCHAR month[12][4] =
|
|
{{'J','a','n', 0}, {'F','e','b', 0}, {'M','a','r', 0}, {'A','p','r', 0},
|
|
{'M','a','y', 0}, {'J','u','n', 0}, {'J','u','l', 0}, {'A','u','g', 0},
|
|
{'S','e','p', 0}, {'O','c','t', 0}, {'N','o','v', 0}, {'D','e','c', 0}};
|
|
|
|
/***********************************************************************
|
|
* WinHttpTimeFromSystemTime (WININET.@)
|
|
*/
|
|
BOOL WINAPI WinHttpTimeFromSystemTime( const SYSTEMTIME *time, LPWSTR string )
|
|
{
|
|
static const WCHAR format[] =
|
|
{'%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
|
|
'2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0};
|
|
|
|
TRACE("%p, %p\n", time, string);
|
|
|
|
if (!time || !string) return FALSE;
|
|
|
|
sprintfW( string, format,
|
|
wkday[time->wDayOfWeek],
|
|
time->wDay,
|
|
month[time->wMonth - 1],
|
|
time->wYear,
|
|
time->wHour,
|
|
time->wMinute,
|
|
time->wSecond );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WinHttpTimeToSystemTime (WININET.@)
|
|
*/
|
|
BOOL WINAPI WinHttpTimeToSystemTime( LPCWSTR string, SYSTEMTIME *time )
|
|
{
|
|
unsigned int i;
|
|
const WCHAR *s = string;
|
|
WCHAR *end;
|
|
|
|
TRACE("%s, %p\n", debugstr_w(string), time);
|
|
|
|
if (!string || !time) return FALSE;
|
|
|
|
/* Windows does this too */
|
|
GetSystemTime( time );
|
|
|
|
/* Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
|
|
* a SYSTEMTIME structure.
|
|
*/
|
|
|
|
while (*s && !isalphaW( *s )) s++;
|
|
if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
|
|
time->wDayOfWeek = 7;
|
|
|
|
for (i = 0; i < 7; i++)
|
|
{
|
|
if (toupperW( wkday[i][0] ) == toupperW( s[0] ) &&
|
|
toupperW( wkday[i][1] ) == toupperW( s[1] ) &&
|
|
toupperW( wkday[i][2] ) == toupperW( s[2] ) )
|
|
{
|
|
time->wDayOfWeek = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (time->wDayOfWeek > 6) return TRUE;
|
|
while (*s && !isdigitW( *s )) s++;
|
|
time->wDay = strtolW( s, &end, 10 );
|
|
s = end;
|
|
|
|
while (*s && !isalphaW( *s )) s++;
|
|
if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
|
|
time->wMonth = 0;
|
|
|
|
for (i = 0; i < 12; i++)
|
|
{
|
|
if (toupperW( month[i][0]) == toupperW( s[0] ) &&
|
|
toupperW( month[i][1]) == toupperW( s[1] ) &&
|
|
toupperW( month[i][2]) == toupperW( s[2] ) )
|
|
{
|
|
time->wMonth = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
if (time->wMonth == 0) return TRUE;
|
|
|
|
while (*s && !isdigitW( *s )) s++;
|
|
if (*s == '\0') return TRUE;
|
|
time->wYear = strtolW( s, &end, 10 );
|
|
s = end;
|
|
|
|
while (*s && !isdigitW( *s )) s++;
|
|
if (*s == '\0') return TRUE;
|
|
time->wHour = strtolW( s, &end, 10 );
|
|
s = end;
|
|
|
|
while (*s && !isdigitW( *s )) s++;
|
|
if (*s == '\0') return TRUE;
|
|
time->wMinute = strtolW( s, &end, 10 );
|
|
s = end;
|
|
|
|
while (*s && !isdigitW( *s )) s++;
|
|
if (*s == '\0') return TRUE;
|
|
time->wSecond = strtolW( s, &end, 10 );
|
|
|
|
time->wMilliseconds = 0;
|
|
return TRUE;
|
|
}
|