Sweden-Number/dlls/winhttp/session.c

1275 lines
37 KiB
C
Raw Normal View History

/*
* 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"
#include "winhttp_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
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 )
{
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;
}
default:
FIXME("unimplemented option %u\n", option);
set_last_error( ERROR_INVALID_PARAMETER );
return FALSE;
}
}
2008-09-03 16:58:06 +02:00
static BOOL session_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
{
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;
}
2008-09-03 16:58:06 +02:00
policy = *(DWORD *)buffer;
2008-09-03 16:58:06 +02:00
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;
2008-09-03 16:58:06 +02:00
default:
FIXME("unimplemented option %u\n", option);
set_last_error( ERROR_INVALID_PARAMETER );
return FALSE;
2008-09-03 16:58:06 +02:00
}
}
static const object_vtbl_t session_vtbl =
{
session_destroy,
session_query_option,
2008-09-03 16:58:06 +02:00
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->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;
}
2008-08-15 14:42:28 +02:00
/***********************************************************************
* 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 const object_vtbl_t connect_vtbl =
{
connect_destroy,
NULL,
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;
}
2009-07-15 17:40:51 +02:00
/* 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;
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 );
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 );
if (!(connect->servername = strdupW( session->proxy_server )))
{
ret = FALSE;
goto end;
}
connect->serverport = INTERNET_DEFAULT_PORT;
}
}
}
else if (server)
{
if (!(connect->servername = strdupW( server )))
{
ret = FALSE;
goto end;
}
connect->serverport = port;
}
end:
return ret;
}
2008-08-15 14:42:28 +02:00
/***********************************************************************
* 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;
2008-08-15 14:42:28 +02:00
addref_object( &session->hdr );
connect->session = session;
list_add_head( &session->hdr.children, &connect->hdr.entry );
if (server && !(connect->hostname = strdupW( server ))) goto end;
connect->hostport = port;
2008-08-26 11:03:40 +02:00
if (!set_server_for_hostname( connect, server, port ))
goto end;
2008-08-15 14:42:28 +02:00
if (!(hconnect = alloc_handle( &connect->hdr ))) goto end;
connect->hdr.handle = hconnect;
send_callback( &session->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hconnect, sizeof(hconnect) );
2008-08-15 14:42:28 +02:00
end:
release_object( &connect->hdr );
TRACE("returning %p\n", hconnect);
return hconnect;
}
2008-08-15 14:42:41 +02:00
/***********************************************************************
* request_destroy (internal)
*/
static void request_destroy( object_header_t *hdr )
{
request_t *request = (request_t *)hdr;
2008-12-08 17:51:01 +01:00
DWORD i;
2008-08-15 14:42:41 +02:00
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 );
heap_free( request );
}
static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
{
switch (option)
{
case WINHTTP_OPTION_SECURITY_FLAGS:
{
DWORD flags;
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;
*(DWORD *)buffer = flags;
*buflen = sizeof(flags);
return TRUE;
}
case WINHTTP_OPTION_SERVER_CERT_CONTEXT:
{
const CERT_CONTEXT *cert;
request_t *request = (request_t *)hdr;
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_KEY_BITNESS:
{
if (!buffer || *buflen < sizeof(DWORD))
{
*buflen = sizeof(DWORD);
set_last_error( ERROR_INSUFFICIENT_BUFFER );
return FALSE;
}
*(DWORD *)buffer = 128; /* FIXME */
*buflen = sizeof(DWORD);
return TRUE;
}
default:
FIXME("unimplemented option %u\n", option);
set_last_error( ERROR_INVALID_PARAMETER );
return FALSE;
}
}
2008-09-03 16:58:06 +02:00
static BOOL request_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
{
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;
2008-09-03 16:58:06 +02:00
if (buflen != sizeof(DWORD))
{
set_last_error( ERROR_INSUFFICIENT_BUFFER );
return FALSE;
}
disable = *(DWORD *)buffer;
2008-09-03 16:58:06 +02:00
TRACE("0x%x\n", disable);
hdr->disable_flags |= disable;
2008-09-03 16:58:06 +02:00
return TRUE;
}
case WINHTTP_OPTION_AUTOLOGON_POLICY:
{
DWORD policy;
2008-09-03 16:58:06 +02:00
if (buflen != sizeof(DWORD))
{
set_last_error( ERROR_INSUFFICIENT_BUFFER );
return FALSE;
}
policy = *(DWORD *)buffer;
2008-09-03 16:58:06 +02:00
TRACE("0x%x\n", policy);
hdr->logon_policy = policy;
return TRUE;
}
case WINHTTP_OPTION_REDIRECT_POLICY:
{
DWORD policy;
2008-09-03 16:58:06 +02:00
if (buflen != sizeof(DWORD))
{
set_last_error( ERROR_INSUFFICIENT_BUFFER );
return FALSE;
}
policy = *(DWORD *)buffer;
2008-09-03 16:58:06 +02:00
TRACE("0x%x\n", policy);
hdr->redirect_policy = policy;
return TRUE;
}
default:
FIXME("unimplemented option %u\n", option);
set_last_error( ERROR_INVALID_PARAMETER );
2008-09-03 16:58:06 +02:00
return TRUE;
}
}
2008-08-15 14:42:41 +02:00
static const object_vtbl_t request_vtbl =
{
request_destroy,
request_query_option,
2008-09-03 16:58:06 +02:00
request_set_option
2008-08-15 14:42:41 +02:00
};
/***********************************************************************
* 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;
2008-08-15 14:42:41 +02:00
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;
2008-08-26 11:03:40 +02:00
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;
2008-08-15 14:42:41 +02:00
if (!(hrequest = alloc_handle( &request->hdr ))) goto end;
request->hdr.handle = hrequest;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hrequest, sizeof(hrequest) );
2008-08-15 14:42:41 +02:00
end:
release_object( &request->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 )
{
2008-09-03 16:58:06 +02:00
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;
}
/***********************************************************************
* WinHttpDetectAutoProxyConfigUrl (winhttp.@)
*/
BOOL WINAPI WinHttpDetectAutoProxyConfigUrl( DWORD flags, LPWSTR *url )
{
FIXME("0x%08x, %p\n", flags, url);
set_last_error( ERROR_WINHTTP_AUTODETECTION_FAILED );
return FALSE;
}
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 WINHTTPSETTINGS_MAGIC = 0x18;
static const DWORD WINHTTP_PROXY_TYPE_DIRECT = 1;
static const DWORD WINHTTP_PROXY_TYPE_PROXY = 2;
struct winhttp_settings_header
{
DWORD magic;
DWORD unknown; /* always zero? */
DWORD flags; /* one of WINHTTP_PROXY_TYPE_* */
};
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 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 winhttp_settings_header) + 2 * sizeof(DWORD))
{
BYTE *buf = heap_alloc( size );
if (buf)
{
struct winhttp_settings_header *hdr =
(struct winhttp_settings_header *)buf;
DWORD *len = (DWORD *)(hdr + 1);
l = RegQueryValueExW( key, WinHttpSettings, NULL, NULL, buf,
&size );
if (!l && hdr->magic == WINHTTPSETTINGS_MAGIC &&
hdr->unknown == 0)
{
if (hdr->flags & WINHTTP_PROXY_TYPE_PROXY)
{
BOOL sane = FALSE;
/* Sanity-check length of proxy string */
if ((BYTE *)len - buf + *len <= size)
{
sane = TRUE;
info->lpszProxy = GlobalAlloc( 0,
(*len + 1) * sizeof(WCHAR) );
if (info->lpszProxy)
copy_char_to_wchar_sz( (BYTE *)(len + 1),
*len, (LPWSTR)info->lpszProxy );
len = (DWORD *)((BYTE *)(len + 1) + *len);
}
if (sane)
{
/* Sanity-check length of proxy bypass string */
if ((BYTE *)len - buf + *len <= size)
{
info->lpszProxyBypass = GlobalAlloc( 0,
(*len + 1) * sizeof(WCHAR) );
if (info->lpszProxyBypass)
copy_char_to_wchar_sz( (BYTE *)(len + 1),
*len, (LPWSTR)info->lpszProxyBypass );
}
else
{
sane = FALSE;
GlobalFree( (LPWSTR)info->lpszProxy );
info->lpszProxy = NULL;
}
}
if (sane)
{
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 );
}
else if ((envproxy = getenv( "http_proxy" )))
{
WCHAR *envproxyW;
int len;
len = MultiByteToWideChar( CP_UNIXCP, 0, envproxy, -1, NULL, 0 );
if ((envproxyW = GlobalAlloc( 0, len * sizeof(WCHAR))))
{
MultiByteToWideChar( CP_UNIXCP, 0, envproxy, -1, envproxyW, len );
direct = FALSE;
info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
info->lpszProxy = envproxyW;
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 )
{
TRACE("%p\n", config);
if (!config)
{
set_last_error( ERROR_INVALID_PARAMETER );
return FALSE;
}
/* FIXME: read from HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings */
FIXME("returning no proxy used\n");
config->fAutoDetect = FALSE;
config->lpszAutoConfigUrl = NULL;
config->lpszProxy = NULL;
config->lpszProxyBypass = NULL;
return TRUE;
}
/***********************************************************************
* WinHttpGetProxyForUrl (winhttp.@)
*/
BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS *options,
WINHTTP_PROXY_INFO *info )
{
FIXME("%p, %s, %p, %p\n", hsession, debugstr_w(url), options, info);
set_last_error( ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR );
return FALSE;
}
/***********************************************************************
* 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 winhttp_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 winhttp_settings_header *hdr =
(struct winhttp_settings_header *)buf;
DWORD *len = (DWORD *)(hdr + 1);
hdr->magic = WINHTTPSETTINGS_MAGIC;
hdr->unknown = 0;
if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
{
BYTE *dst;
hdr->flags = WINHTTP_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 = WINHTTP_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 )
{
2009-07-07 10:14:11 +02:00
BOOL ret = TRUE;
request_t *request;
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;
}
FIXME("resolve and connect timeout not supported\n");
if (!(request = (request_t *)grab_object( handle )))
{
set_last_error( ERROR_INVALID_HANDLE );
return FALSE;
}
if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
{
release_object( &request->hdr );
set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
return FALSE;
}
if (send < 0) send = 0;
if (netconn_set_timeout( &request->netconn, TRUE, send )) ret = FALSE;
if (receive < 0) receive = 0;
if (netconn_set_timeout( &request->netconn, FALSE, receive )) ret = FALSE;
release_object( &request->hdr );
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 );
s = end;
time->wMilliseconds = 0;
return TRUE;
}