internet.c File Reference

#include "winsock2.h"
#include "ws2ipdef.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>
#include <wchar.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winuser.h"
#include "wininet.h"
#include "winnls.h"
#include "wine/debug.h"
#include "winerror.h"
#include "shlwapi.h"
#include "ws2tcpip.h"
#include "winternl.h"
#include "iphlpapi.h"
#include "dhcpcsdk.h"
#include "internet.h"
#include "resource.h"

Include dependency graph for internet.c:

Go to the source code of this file.

Classes
struct	WITHREADERROR
struct	proxyinfo_t
struct	connection_settings
struct	open_url_task_t

Macros
#define	NO_SHLWAPI_STREAM
#define	CONNECTION_SETTINGS_VERSION   0x46
#define	FE(x)   { x, #x }
#define	FE(x)   { x, #x }
#define	MAX_WORD_DIGITS   5
#define	URL_GET_COMP_LENGTH(url, component)
#define	URL_GET_COMP_LENGTHA(url, component)

Typedefs
typedef struct WITHREADERROR *	LPWITHREADERROR

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wininet)
static WCHAR *	get_proxy_autoconfig_url (void)
void *	alloc_object (object_header_t *parent, const object_vtbl_t *vtbl, size_t size)
object_header_t *	WININET_AddRef (object_header_t *info)
object_header_t *	get_handle_object (HINTERNET hinternet)
static void	invalidate_handle (object_header_t *info)
BOOL	WININET_Release (object_header_t *info)
BOOL WINAPI	DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
HRESULT WINAPI	DllInstall (BOOL bInstall, LPCWSTR cmdline)
static void	connection_settings_write (connection_settings *settings, DWORD *pos, DWORD size, const WCHAR *str)
static LONG	save_connection_settings (HKEY key, const WCHAR *connection, proxyinfo_t *lpwpi)
static LONG	INTERNET_SaveProxySettings (proxyinfo_t *lpwpi)
WCHAR *	INTERNET_FindProxyForProtocol (LPCWSTR szProxy, LPCWSTR proto)
BOOL WINAPI	InternetInitializeAutoProxyDll (DWORD dwReserved)
BOOL WINAPI	DetectAutoProxyUrl (LPSTR lpszAutoProxyUrl, DWORD dwAutoProxyUrlLength, DWORD dwDetectFlags)
static void	FreeProxyInfo (proxyinfo_t *lpwpi)
static void	free_global_proxy (void)
static BOOL	parse_proxy_url (proxyinfo_t *info, const WCHAR *url)
static WCHAR *	get_http_proxy (const WCHAR *proxy)
static LONG	connection_settings_read (const connection_settings *settings, DWORD *pos, DWORD size, WCHAR **str)
static LONG	load_connection_settings (HKEY key, const WCHAR *connection, proxyinfo_t *lpwpi)
static LONG	INTERNET_LoadProxySettings (proxyinfo_t *lpwpi)
static void	init_global_proxy (void)
static LONG	INTERNET_GetProxySettings (proxyinfo_t *lpwpi)
static BOOL	INTERNET_ConfigureProxy (appinfo_t *lpwai)
static void	dump_INTERNET_FLAGS (DWORD dwFlags)
static VOID	APPINFO_Destroy (object_header_t *hdr)
static WCHAR *	copy_optionW (WCHAR *value)
static char *	copy_optionA (WCHAR *value)
static DWORD	APPINFO_QueryOption (object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
static DWORD	APPINFO_SetOption (object_header_t *hdr, DWORD option, void *buf, DWORD size)
HINTERNET WINAPI	InternetOpenW (LPCWSTR lpszAgent, DWORD dwAccessType, LPCWSTR lpszProxy, LPCWSTR lpszProxyBypass, DWORD dwFlags)
HINTERNET WINAPI	InternetOpenA (LPCSTR lpszAgent, DWORD dwAccessType, LPCSTR lpszProxy, LPCSTR lpszProxyBypass, DWORD dwFlags)
BOOL WINAPI	InternetGetLastResponseInfoA (LPDWORD lpdwError, LPSTR lpszBuffer, LPDWORD lpdwBufferLength)
BOOL WINAPI	InternetGetLastResponseInfoW (LPDWORD lpdwError, LPWSTR lpszBuffer, LPDWORD lpdwBufferLength)
BOOL WINAPI	InternetGetConnectedState (LPDWORD lpdwStatus, DWORD dwReserved)
BOOL WINAPI	InternetGetConnectedStateExW (LPDWORD lpdwStatus, LPWSTR lpszConnectionName, DWORD dwNameLen, DWORD dwReserved)
BOOL WINAPI	InternetGetConnectedStateExA (LPDWORD lpdwStatus, LPSTR lpszConnectionName, DWORD dwNameLen, DWORD dwReserved)
HINTERNET WINAPI	InternetConnectW (HINTERNET hInternet, LPCWSTR lpszServerName, INTERNET_PORT nServerPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext)
HINTERNET WINAPI	InternetConnectA (HINTERNET hInternet, LPCSTR lpszServerName, INTERNET_PORT nServerPort, LPCSTR lpszUserName, LPCSTR lpszPassword, DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	InternetFindNextFileA (HINTERNET hFind, LPVOID lpvFindData)
BOOL WINAPI	InternetFindNextFileW (HINTERNET hFind, LPVOID lpvFindData)
BOOL WINAPI	InternetCloseHandle (HINTERNET hInternet)
static BOOL	set_url_component (WCHAR **component, DWORD *component_length, const WCHAR *value, DWORD len)
static BOOL	set_url_component_WtoA (const WCHAR *comp_w, DWORD length, const WCHAR *url_w, char **comp, DWORD *ret_length, const char *url_a)
static BOOL	set_url_component_AtoW (const char *comp_a, DWORD len_a, WCHAR **comp_w, DWORD *len_w, WCHAR **buf)
BOOL WINAPI	InternetCrackUrlA (const char *url, DWORD url_length, DWORD flags, URL_COMPONENTSA *ret_comp)
static INTERNET_SCHEME	GetInternetSchemeW (LPCWSTR lpszScheme, DWORD nMaxCmp)
BOOL WINAPI	InternetCrackUrlW (const WCHAR *lpszUrl, DWORD dwUrlLength, DWORD dwFlags, URL_COMPONENTSW *lpUC)
DWORD WINAPI	InternetAttemptConnect (DWORD dwReserved)
static DWORD	convert_url_canonicalization_flags (DWORD dwFlags)
BOOL WINAPI	InternetCanonicalizeUrlA (LPCSTR lpszUrl, LPSTR lpszBuffer, LPDWORD lpdwBufferLength, DWORD dwFlags)
BOOL WINAPI	InternetCanonicalizeUrlW (LPCWSTR lpszUrl, LPWSTR lpszBuffer, LPDWORD lpdwBufferLength, DWORD dwFlags)
static INTERNET_STATUS_CALLBACK	set_status_callback (object_header_t *lpwh, INTERNET_STATUS_CALLBACK callback, BOOL unicode)
INTERNET_STATUS_CALLBACK WINAPI	InternetSetStatusCallbackA (HINTERNET hInternet, INTERNET_STATUS_CALLBACK lpfnIntCB)
INTERNET_STATUS_CALLBACK WINAPI	InternetSetStatusCallbackW (HINTERNET hInternet, INTERNET_STATUS_CALLBACK lpfnIntCB)
DWORD WINAPI	InternetSetFilePointer (HINTERNET hFile, LONG lDistanceToMove, PVOID pReserved, DWORD dwMoveContext, DWORD_PTR dwContext)
BOOL WINAPI	InternetWriteFile (HINTERNET hFile, LPCVOID lpBuffer, DWORD dwNumOfBytesToWrite, LPDWORD lpdwNumOfBytesWritten)
BOOL WINAPI	InternetReadFile (HINTERNET hFile, LPVOID lpBuffer, DWORD dwNumOfBytesToRead, LPDWORD pdwNumOfBytesRead)
BOOL WINAPI	InternetReadFileExA (HINTERNET hFile, LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	InternetReadFileExW (HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffer, DWORD dwFlags, DWORD_PTR dwContext)
static IP_ADAPTER_ADDRESSES *	get_adapters (void)
static WCHAR *	detect_proxy_autoconfig_url_dhcp (void)
static char *	get_computer_name (COMPUTER_NAME_FORMAT format)
static BOOL	is_domain_suffix (const char *domain, const char *suffix)
static int	reverse_lookup (const struct addrinfo *ai, char *hostname, size_t len)
static WCHAR *	build_wpad_url (const char *hostname, const struct addrinfo *ai)
static WCHAR *	detect_proxy_autoconfig_url_dns (void)
static DWORD	query_global_option (DWORD option, void *buffer, DWORD *size, BOOL unicode)
DWORD	INET_QueryOption (object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
BOOL WINAPI	InternetQueryOptionW (HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, LPDWORD lpdwBufferLength)
BOOL WINAPI	InternetQueryOptionA (HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, LPDWORD lpdwBufferLength)
DWORD	INET_SetOption (object_header_t *hdr, DWORD option, void *buf, DWORD size)
static DWORD	set_global_option (DWORD option, void *buf, DWORD size)
BOOL WINAPI	InternetSetOptionW (HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength)
BOOL WINAPI	InternetSetOptionA (HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength)
BOOL WINAPI	InternetSetOptionExA (HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags)
BOOL WINAPI	InternetSetOptionExW (HINTERNET hInternet, DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags)
static BOOL	is_time_digit (const WCHAR c)
BOOL WINAPI	InternetTimeFromSystemTimeA (const SYSTEMTIME *time, DWORD format, LPSTR string, DWORD size)
BOOL WINAPI	InternetTimeFromSystemTimeW (const SYSTEMTIME *time, DWORD format, LPWSTR string, DWORD size)
BOOL WINAPI	InternetTimeToSystemTimeA (LPCSTR string, SYSTEMTIME *time, DWORD reserved)
BOOL WINAPI	InternetTimeToSystemTimeW (LPCWSTR string, SYSTEMTIME *time, DWORD reserved)
BOOL WINAPI	InternetCheckConnectionW (LPCWSTR lpszUrl, DWORD dwFlags, DWORD dwReserved)
BOOL WINAPI	InternetCheckConnectionA (LPCSTR lpszUrl, DWORD dwFlags, DWORD dwReserved)
static HINTERNET	INTERNET_InternetOpenUrlW (appinfo_t *hIC, LPCWSTR lpszUrl, LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
static void	AsyncInternetOpenUrlProc (task_header_t *hdr)
HINTERNET WINAPI	InternetOpenUrlW (HINTERNET hInternet, LPCWSTR lpszUrl, LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
HINTERNET WINAPI	InternetOpenUrlA (HINTERNET hInternet, LPCSTR lpszUrl, LPCSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
static LPWITHREADERROR	INTERNET_AllocThreadError (void)
void	INTERNET_SetLastError (DWORD dwError)
DWORD	INTERNET_GetLastError (void)
static DWORD CALLBACK	INTERNET_WorkerThreadFunc (LPVOID lpvParam)
void *	alloc_async_task (object_header_t *hdr, async_task_proc_t proc, size_t size)
DWORD	INTERNET_AsyncCall (task_header_t *task)
LPSTR	INTERNET_GetResponseBuffer (void)
BOOL WINAPI	InternetQueryDataAvailable (HINTERNET hFile, LPDWORD lpdwNumberOfBytesAvailable, DWORD dwFlags, DWORD_PTR dwContext)
DWORD	create_req_file (const WCHAR *file_name, req_file_t **ret)
void	req_file_release (req_file_t *req_file)
BOOL WINAPI	InternetLockRequestFile (HINTERNET hInternet, HANDLE *lphLockReqHandle)
BOOL WINAPI	InternetUnlockRequestFile (HANDLE hLockHandle)
BOOL WINAPI	InternetAutodial (DWORD dwFlags, HWND hwndParent)
BOOL WINAPI	InternetAutodialHangup (DWORD dwReserved)
BOOL WINAPI	InternetCombineUrlA (LPCSTR lpszBaseUrl, LPCSTR lpszRelativeUrl, LPSTR lpszBuffer, LPDWORD lpdwBufferLength, DWORD dwFlags)
BOOL WINAPI	InternetCombineUrlW (LPCWSTR lpszBaseUrl, LPCWSTR lpszRelativeUrl, LPWSTR lpszBuffer, LPDWORD lpdwBufferLength, DWORD dwFlags)
static BOOL	url_uses_default_port (INTERNET_SCHEME nScheme, INTERNET_PORT nPort)
static BOOL	scheme_is_opaque (INTERNET_SCHEME nScheme)
static LPCWSTR	INTERNET_GetSchemeString (INTERNET_SCHEME scheme)
static BOOL	calc_url_length (LPURL_COMPONENTSW lpUrlComponents, LPDWORD lpdwUrlLength)
static void	convert_urlcomp_atow (LPURL_COMPONENTSA lpUrlComponents, LPURL_COMPONENTSW urlCompW)
BOOL WINAPI	InternetCreateUrlA (LPURL_COMPONENTSA lpUrlComponents, DWORD dwFlags, LPSTR lpszUrl, LPDWORD lpdwUrlLength)
BOOL WINAPI	InternetCreateUrlW (LPURL_COMPONENTSW lpUrlComponents, DWORD dwFlags, LPWSTR lpszUrl, LPDWORD lpdwUrlLength)
DWORD WINAPI	InternetConfirmZoneCrossingA (HWND hWnd, LPSTR szUrlPrev, LPSTR szUrlNew, BOOL bPost)
DWORD WINAPI	InternetConfirmZoneCrossingW (HWND hWnd, LPWSTR szUrlPrev, LPWSTR szUrlNew, BOOL bPost)
DWORD WINAPI	PrivacySetZonePreferenceW (DWORD zone, DWORD type, DWORD template, LPCWSTR preference)
DWORD WINAPI	PrivacyGetZonePreferenceW (DWORD zone, DWORD type, LPDWORD template, LPWSTR preference, LPDWORD length)
BOOL WINAPI	InternetGetSecurityInfoByURLA (LPSTR lpszURL, PCCERT_CHAIN_CONTEXT *ppCertChain, DWORD *pdwSecureFlags)
BOOL WINAPI	InternetGetSecurityInfoByURLW (LPCWSTR lpszURL, PCCERT_CHAIN_CONTEXT *ppCertChain, DWORD *pdwSecureFlags)
DWORD WINAPI	InternetDialA (HWND hwndParent, LPSTR lpszConnectoid, DWORD dwFlags, DWORD_PTR *lpdwConnection, DWORD dwReserved)
DWORD WINAPI	InternetDialW (HWND hwndParent, LPWSTR lpszConnectoid, DWORD dwFlags, DWORD_PTR *lpdwConnection, DWORD dwReserved)
BOOL WINAPI	InternetGoOnlineA (LPSTR lpszURL, HWND hwndParent, DWORD dwReserved)
BOOL WINAPI	InternetGoOnlineW (LPWSTR lpszURL, HWND hwndParent, DWORD dwReserved)
DWORD WINAPI	InternetHangUp (DWORD_PTR dwConnection, DWORD dwReserved)
BOOL WINAPI	CreateMD5SSOHash (PWSTR pszChallengeInfo, PWSTR pwszRealm, PWSTR pwszTarget, PBYTE pbHexHash)
BOOL WINAPI	ResumeSuspendedDownload (HINTERNET hInternet, DWORD dwError)
BOOL WINAPI	InternetQueryFortezzaStatus (DWORD *a, DWORD_PTR b)
DWORD WINAPI	ShowClientAuthCerts (HWND parent)

Variables
static DWORD	g_dwTlsErrIndex = TLS_OUT_OF_INDEXES
HMODULE	WININET_hModule
static CRITICAL_SECTION	WININET_cs = { &WININET_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	WININET_cs_debug
static object_header_t **	handle_table
static UINT_PTR	next_handle
static UINT_PTR	handle_table_size
static ULONG	max_conns = 2
static ULONG	max_1_0_conns = 4
static ULONG	connect_timeout = 60000
static ULONG	send_timeout = 60000
static ULONG	receive_timeout = 60000
static ULONG	data_send_timeout = 60000
static ULONG	data_receive_timeout = 60000
static const WCHAR	szInternetSettings []
static proxyinfo_t	global_proxy
static const object_vtbl_t	APPINFOVtbl
static const WCHAR *	url_schemes []
static const WCHAR	WININET_wkday [7][4]
static const WCHAR	WININET_month [12][4]
static DWORD	zone_preference = 3

Macro Definition Documentation

CONNECTION_SETTINGS_VERSION

#define CONNECTION_SETTINGS_VERSION   0x46

Definition at line 96 of file internet.c.

FE [1/2]

#define FE

(

x

)

{ x, #x }

FE [2/2]

#define FE

(

x

)

{ x, #x }

MAX_WORD_DIGITS

#define MAX_WORD_DIGITS   5

Definition at line 4782 of file internet.c.

NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

Definition at line 51 of file internet.c.

URL_GET_COMP_LENGTH

#define URL_GET_COMP_LENGTH	(		url,
			component
	)

Value:

    ((url)->dw##component##Length ? \
    (url)->dw##component##Length : lstrlenW((url)->lpsz##component))

Definition at line 4784 of file internet.c.

URL_GET_COMP_LENGTHA

#define URL_GET_COMP_LENGTHA	(		url,
			component
	)

Value:

    ((url)->dw##component##Length ? \
    (url)->dw##component##Length : strlen((url)->lpsz##component))

Definition at line 4786 of file internet.c.

Typedef Documentation

LPWITHREADERROR

typedef struct WITHREADERROR * LPWITHREADERROR

Function Documentation

alloc_async_task()

void * alloc_async_task	(	object_header_t *	hdr,
		async_task_proc_t	proc,
		size_t	size
	)

Definition at line 4513 of file internet.c.

{
    task_header_t *task;
 
    task = malloc(size);
    if(!task)
        return NULL;
 
    task->hdr = WININET_AddRef(hdr);
    task->proc = proc;
    return task;
}

Referenced by async_read(), FtpCreateDirectoryW(), FtpDeleteFileW(), FTPFILE_QueryDataAvailable(), FtpFindFirstFileW(), FTPFINDNEXT_FindNextFileW(), FtpGetCurrentDirectoryW(), FtpGetFileW(), FtpOpenFileW(), FtpPutFileW(), FtpRemoveDirectoryW(), FtpRenameFileW(), FtpSetCurrentDirectoryW(), HttpEndRequestW(), HttpSendRequestExW(), HttpSendRequestW(), and InternetOpenUrlW().

alloc_object()

void * alloc_object	(	object_header_t *	parent,
		const object_vtbl_t *	vtbl,
		size_t	size
	)

Definition at line 124 of file internet.c.

{
    UINT_PTR handle = 0, num;
    object_header_t *ret;
    object_header_t **p;
    BOOL res = TRUE;
 
    ret = calloc(1, size);
    if(!ret)
        return NULL;
 
    list_init(&ret->children);
 
    EnterCriticalSection( &WININET_cs );
 
    if(!handle_table_size) {
        num = 16;
        p = calloc(num, sizeof(handle_table[0]));
        if(p) {
            handle_table = p;
            handle_table_size = num;
            next_handle = 1;
        }else {
            res = FALSE;
        }
    }else if(next_handle == handle_table_size) {
        num = handle_table_size * 2;
        p = realloc(handle_table, sizeof(handle_table[0]) * num);
        if(p) {
            memset(p + handle_table_size, 0, sizeof(handle_table[0]) * handle_table_size);
            handle_table = p;
            handle_table_size = num;
        }else {
            res = FALSE;
        }
    }
 
    if(res) {
        handle = next_handle;
        if(handle_table[handle])
            ERR("handle isn't free but should be\n");
        handle_table[handle] = ret;
        ret->valid_handle = TRUE;
 
        while(next_handle < handle_table_size && handle_table[next_handle])
            next_handle++;
    }
 
    LeaveCriticalSection( &WININET_cs );
 
    if(!res) {
        free(ret);
        return NULL;
    }
 
    ret->vtbl = vtbl;
    ret->refs = 1;
    ret->hInternet = (HINTERNET)handle;
 
    if(parent) {
        ret->lpfnStatusCB = parent->lpfnStatusCB;
        ret->dwInternalFlags = parent->dwInternalFlags & INET_CALLBACKW;
        ret->connect_timeout = parent->connect_timeout;
        ret->send_timeout = parent->send_timeout;
        ret->receive_timeout = parent->receive_timeout;
        ret->data_send_timeout = parent->data_send_timeout;
        ret->data_receive_timeout = parent->data_receive_timeout;
    } else {
        ret->connect_timeout = connect_timeout;
        ret->send_timeout = send_timeout;
        ret->receive_timeout = receive_timeout;
        ret->data_send_timeout = data_send_timeout;
        ret->data_receive_timeout = data_receive_timeout;
    }
 
    return ret;
}

Referenced by FTP_Connect(), FTP_FtpOpenFileW(), FTP_ReceiveFileList(), HTTP_Connect(), HTTP_HttpOpenRequestW(), and InternetOpenW().

APPINFO_Destroy()

static VOID APPINFO_Destroy ( object_header_t *  hdr )

static

Definition at line 998 of file internet.c.

{
    appinfo_t *lpwai = (appinfo_t*)hdr;
 
    TRACE("%p\n",lpwai);
 
    free(lpwai->agent);
    free(lpwai->proxy);
    free(lpwai->proxyBypass);
    free(lpwai->proxyUsername);
    free(lpwai->proxyPassword);
}

Referenced by query_global_option().

APPINFO_QueryOption()

static DWORD APPINFO_QueryOption ( object_header_t *  hdr, DWORD  option, void *  buffer, DWORD *  size, BOOL  unicode  )

static

Definition at line 1042 of file internet.c.

{
    appinfo_t *ai = (appinfo_t*)hdr;
 
    switch(option) {
    case INTERNET_OPTION_HANDLE_TYPE:
        TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *size = sizeof(DWORD);
        *(DWORD*)buffer = INTERNET_HANDLE_TYPE_INTERNET;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_USER_AGENT: {
        DWORD bufsize;
 
        TRACE("INTERNET_OPTION_USER_AGENT\n");
 
        bufsize = *size;
 
        if (unicode) {
            DWORD len = ai->agent ? lstrlenW(ai->agent) : 0;
 
            *size = (len + 1) * sizeof(WCHAR);
            if(!buffer || bufsize < *size)
                return ERROR_INSUFFICIENT_BUFFER;
 
            if (ai->agent)
                lstrcpyW(buffer, ai->agent);
            else
                *(WCHAR *)buffer = 0;
            /* If the buffer is copied, the returned length doesn't include
             * the NULL terminator.
             */
            *size = len;
        }else {
            if (ai->agent)
                *size = WideCharToMultiByte(CP_ACP, 0, ai->agent, -1, NULL, 0, NULL, NULL);
            else
                *size = 1;
            if(!buffer || bufsize < *size)
                return ERROR_INSUFFICIENT_BUFFER;
 
            if (ai->agent)
                WideCharToMultiByte(CP_ACP, 0, ai->agent, -1, buffer, *size, NULL, NULL);
            else
                *(char *)buffer = 0;
            /* If the buffer is copied, the returned length doesn't include
             * the NULL terminator.
             */
            *size -= 1;
        }
 
        return ERROR_SUCCESS;
    }
 
    case INTERNET_OPTION_PROXY:
        if(!size) return ERROR_INVALID_PARAMETER;
        if (unicode) {
            INTERNET_PROXY_INFOW *pi = (INTERNET_PROXY_INFOW *)buffer;
            DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
            LPWSTR proxy, proxy_bypass;
 
            if (ai->proxy)
                proxyBytesRequired = (lstrlenW(ai->proxy) + 1) * sizeof(WCHAR);
            if (ai->proxyBypass)
                proxyBypassBytesRequired = (lstrlenW(ai->proxyBypass) + 1) * sizeof(WCHAR);
            if (!pi || *size < sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired)
            {
                *size = sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired;
                return ERROR_INSUFFICIENT_BUFFER;
            }
            proxy = (LPWSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOW));
            proxy_bypass = (LPWSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired);
 
            pi->dwAccessType = ai->accessType;
            pi->lpszProxy = NULL;
            pi->lpszProxyBypass = NULL;
            if (ai->proxy) {
                lstrcpyW(proxy, ai->proxy);
                pi->lpszProxy = proxy;
            }
 
            if (ai->proxyBypass) {
                lstrcpyW(proxy_bypass, ai->proxyBypass);
                pi->lpszProxyBypass = proxy_bypass;
            }
 
            *size = sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired;
            return ERROR_SUCCESS;
        }else {
            INTERNET_PROXY_INFOA *pi = (INTERNET_PROXY_INFOA *)buffer;
            DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
            LPSTR proxy, proxy_bypass;
 
            if (ai->proxy)
                proxyBytesRequired = WideCharToMultiByte(CP_ACP, 0, ai->proxy, -1, NULL, 0, NULL, NULL);
            if (ai->proxyBypass)
                proxyBypassBytesRequired = WideCharToMultiByte(CP_ACP, 0, ai->proxyBypass, -1,
                        NULL, 0, NULL, NULL);
            if (!pi || *size < sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired)
            {
                *size = sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired;
                return ERROR_INSUFFICIENT_BUFFER;
            }
            proxy = (LPSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOA));
            proxy_bypass = (LPSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired);
 
            pi->dwAccessType = ai->accessType;
            pi->lpszProxy = NULL;
            pi->lpszProxyBypass = NULL;
            if (ai->proxy) {
                WideCharToMultiByte(CP_ACP, 0, ai->proxy, -1, proxy, proxyBytesRequired, NULL, NULL);
                pi->lpszProxy = proxy;
            }
 
            if (ai->proxyBypass) {
                WideCharToMultiByte(CP_ACP, 0, ai->proxyBypass, -1, proxy_bypass,
                        proxyBypassBytesRequired, NULL, NULL);
                pi->lpszProxyBypass = proxy_bypass;
            }
 
            *size = sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired;
            return ERROR_SUCCESS;
        }
 
    case INTERNET_OPTION_PER_CONNECTION_OPTION: {
        INTERNET_PER_CONN_OPTION_LISTW *con = buffer;
        INTERNET_PER_CONN_OPTION_LISTA *conA = buffer;
        LONG res = ERROR_SUCCESS;
        WCHAR *url = NULL;
        int i;
 
        if (*size < sizeof(INTERNET_PER_CONN_OPTION_LISTW))
            return ERROR_INSUFFICIENT_BUFFER;
 
        EnterCriticalSection(&WININET_cs);
 
        if (global_proxy.flags & PROXY_TYPE_AUTO_DETECT)
            url = get_proxy_autoconfig_url();
 
        for (i = 0; i < con->dwOptionCount; i++) {
            INTERNET_PER_CONN_OPTIONW *optionW = con->pOptions + i;
            INTERNET_PER_CONN_OPTIONA *optionA = conA->pOptions + i;
 
            switch (optionW->dwOption) {
            case INTERNET_PER_CONN_FLAGS:
                optionW->Value.dwValue = global_proxy.flags;
                break;
 
            case INTERNET_PER_CONN_PROXY_SERVER:
                if (unicode)
                    optionW->Value.pszValue = copy_optionW(global_proxy.proxy);
                else
                    optionA->Value.pszValue = copy_optionA(global_proxy.proxy);
                break;
 
            case INTERNET_PER_CONN_PROXY_BYPASS:
                if (unicode)
                    optionW->Value.pszValue = copy_optionW(global_proxy.proxyBypass);
                else
                    optionA->Value.pszValue = copy_optionA(global_proxy.proxyBypass);
                break;
 
            case INTERNET_PER_CONN_AUTOCONFIG_URL:
                if (unicode)
                    optionW->Value.pszValue = copy_optionW(global_proxy.autoconf_url);
                else
                    optionA->Value.pszValue = copy_optionA(global_proxy.autoconf_url);
                break;
 
            case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
                optionW->Value.dwValue = AUTO_PROXY_FLAG_ALWAYS_DETECT;
                break;
 
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
                if (unicode)
                    optionW->Value.pszValue = copy_optionW(url);
                else
                    optionA->Value.pszValue = copy_optionA(url);
                break;
 
            case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
            case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
                FIXME("Unhandled dwOption %ld\n", optionW->dwOption);
                memset(&optionW->Value, 0, sizeof(optionW->Value));
                break;
 
            default:
                FIXME("Unknown dwOption %ld\n", optionW->dwOption);
                res = ERROR_INVALID_PARAMETER;
                break;
            }
        }
 
        LeaveCriticalSection(&WININET_cs);
        return res;
    }
    }
 
    return INET_QueryOption(hdr, option, buffer, size, unicode);
}

Referenced by query_global_option().

APPINFO_SetOption()

static DWORD APPINFO_SetOption ( object_header_t *  hdr, DWORD  option, void *  buf, DWORD  size  )

static

Definition at line 1248 of file internet.c.

{
    appinfo_t *ai = (appinfo_t*)hdr;
 
    switch(option) {
    case INTERNET_OPTION_USER_AGENT:
        free(ai->agent);
        if (!(ai->agent = wcsdup(buf))) return ERROR_OUTOFMEMORY;
        return ERROR_SUCCESS;
    case INTERNET_OPTION_REFRESH:
        FIXME("INTERNET_OPTION_REFRESH\n");
        return ERROR_SUCCESS;
    case INTERNET_OPTION_PER_CONNECTION_OPTION: {
        INTERNET_PER_CONN_OPTION_LISTW *con = buf;
        unsigned int i;
 
        EnterCriticalSection( &WININET_cs );
        for (i = 0; i < con->dwOptionCount; i++) {
            INTERNET_PER_CONN_OPTIONW *option = con->pOptions + i;
 
            switch (option->dwOption) {
            case INTERNET_PER_CONN_PROXY_SERVER:
                free(global_proxy.proxy);
                global_proxy.proxy = wcsdup(option->Value.pszValue);
                break;
 
            case INTERNET_PER_CONN_FLAGS:
                if(option->Value.dwValue & ~(PROXY_TYPE_PROXY | PROXY_TYPE_DIRECT))
                    FIXME("Unhandled flags: 0x%lx\n", option->Value.dwValue);
                global_proxy.flags = option->Value.dwValue;
                break;
 
            case INTERNET_PER_CONN_PROXY_BYPASS:
                free(global_proxy.proxyBypass);
                global_proxy.proxyBypass = wcsdup(option->Value.pszValue);
                break;
 
            case INTERNET_PER_CONN_AUTOCONFIG_URL:
                free(global_proxy.autoconf_url);
                global_proxy.autoconf_url = wcsdup(option->Value.pszValue);
                break;
 
            case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
            case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
            case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
                FIXME("Unhandled dwOption %ld\n", option->dwOption);
                break;
 
            default:
                FIXME("Unknown dwOption %ld\n", option->dwOption);
                SetLastError(ERROR_INVALID_PARAMETER);
                break;
            }
        }
        LeaveCriticalSection( &WININET_cs );
        return ERROR_SUCCESS;
    }
    }
 
    return INET_SetOption(hdr, option, buf, size);
}

AsyncInternetOpenUrlProc()

static void AsyncInternetOpenUrlProc ( task_header_t *  hdr )

static

Definition at line 4329 of file internet.c.

{
    open_url_task_t *task = (open_url_task_t*)hdr;
 
    TRACE("%p\n", task->hdr.hdr);
 
    INTERNET_InternetOpenUrlW((appinfo_t*)task->hdr.hdr, task->url, task->headers,
            task->headers_len, task->flags, task->context);
    free(task->url);
    free(task->headers);
}

Referenced by InternetOpenUrlW().

build_wpad_url()

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

static

Definition at line 2849 of file internet.c.

{
    char name[NI_MAXHOST];
    WCHAR *ret, *p;
    int len;
 
    while (ai && ai->ai_family != AF_INET && ai->ai_family != AF_INET6) ai = ai->ai_next;
    if (!ai) return NULL;
 
    if (!reverse_lookup( ai, name, sizeof(name) )) hostname = name;
 
    len = lstrlenW( L"http://" ) + strlen( hostname ) + lstrlenW( L"/wpad.dat" );
    if (!(ret = p = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) return NULL;
    lstrcpyW( p, L"http://" );
    p += lstrlenW( L"http://" );
    while (*hostname) { *p++ = *hostname++; }
    lstrcpyW( p, L"/wpad.dat" );
    return ret;
}

Referenced by detect_proxy_autoconfig_url_dns().

calc_url_length()

static BOOL calc_url_length ( LPURL_COMPONENTSW  lpUrlComponents, LPDWORD  lpdwUrlLength  )

static

Definition at line 4835 of file internet.c.

{
    INTERNET_SCHEME nScheme;
 
    *lpdwUrlLength = 0;
 
    if (lpUrlComponents->lpszScheme)
    {
        DWORD dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Scheme);
        *lpdwUrlLength += dwLen;
        nScheme = GetInternetSchemeW(lpUrlComponents->lpszScheme, dwLen);
    }
    else
    {
        LPCWSTR scheme;
 
        if (lpUrlComponents->nScheme == INTERNET_SCHEME_UNKNOWN)
        {
            INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
 
        nScheme = lpUrlComponents->nScheme;
 
        if (nScheme == INTERNET_SCHEME_DEFAULT)
            nScheme = INTERNET_SCHEME_HTTP;
        scheme = INTERNET_GetSchemeString(nScheme);
        *lpdwUrlLength += lstrlenW(scheme);
    }
 
    (*lpdwUrlLength)++; /* ':' */
    if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName)
        *lpdwUrlLength += strlen("//");
 
    if (lpUrlComponents->lpszUserName)
    {
        *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UserName);
        *lpdwUrlLength += strlen("@");
    }
    else
    {
        if (lpUrlComponents->lpszPassword)
        {
            INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
    }
 
    if (lpUrlComponents->lpszPassword)
    {
        *lpdwUrlLength += strlen(":");
        *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, Password);
    }
 
    if (lpUrlComponents->lpszHostName)
    {
        *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, HostName);
 
        if (!url_uses_default_port(nScheme, lpUrlComponents->nPort))
        {
            WCHAR port[MAX_WORD_DIGITS + 1];
 
            _ltow(lpUrlComponents->nPort, port, 10);
            *lpdwUrlLength += lstrlenW(port);
            *lpdwUrlLength += strlen(":");
        }
 
        if (lpUrlComponents->lpszUrlPath && *lpUrlComponents->lpszUrlPath != '/')
            (*lpdwUrlLength)++; /* '/' */
    }
 
    if (lpUrlComponents->lpszUrlPath)
        *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
 
    if (lpUrlComponents->lpszExtraInfo)
        *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, ExtraInfo);
 
    return TRUE;
}

Referenced by InternetCreateUrlW().

connection_settings_read()

static LONG connection_settings_read ( const connection_settings *  settings, DWORD *  pos, DWORD  size, WCHAR **  str  )

static

Definition at line 668 of file internet.c.

{
    int len, wlen;
 
    *str = NULL;
    if (*pos + sizeof(int) >= size)
        return ERROR_SUCCESS;
    memcpy( &len, settings->data + *pos, sizeof(int) );
    *pos += sizeof(int);
 
    if (*pos + len >= size)
    {
        *pos = size;
        return ERROR_SUCCESS;
    }
    wlen = MultiByteToWideChar( CP_UTF8, 0, (const char *)settings->data + *pos, len, NULL, 0 );
    if (wlen)
    {
        *str = malloc( (wlen + 1) * sizeof(WCHAR) );
        if (!*str)
        {
            *pos = size;
            return ERROR_OUTOFMEMORY;
        }
        MultiByteToWideChar( CP_UTF8, 0, (const char *)settings->data + *pos, len, *str, wlen );
        (*str)[wlen] = 0;
        *pos += len;
    }
    return ERROR_SUCCESS;
}

Referenced by load_connection_settings().

connection_settings_write()

static void connection_settings_write ( connection_settings *  settings, DWORD *  pos, DWORD  size, const WCHAR *  str  )

static

Definition at line 356 of file internet.c.

{
    int len = 0;
 
    if (str)
    {
        len = wcslen( str );
        len = WideCharToMultiByte( CP_UTF8, 0, str, len, settings ? (char*)settings->data + *pos + sizeof(len) : NULL,
                settings ? size - *pos - sizeof(len) : 0, NULL, NULL );
    }
    if (settings)
        memcpy(settings->data + *pos, &len, sizeof(len));
    *pos += sizeof(len) + len;
}

Referenced by save_connection_settings().

convert_url_canonicalization_flags()

static DWORD convert_url_canonicalization_flags ( DWORD  dwFlags )

static

Definition at line 2386 of file internet.c.

{
    DWORD dwUrlFlags = URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE;
 
    if (dwFlags & ICU_BROWSER_MODE)        dwUrlFlags |= URL_BROWSER_MODE;
    if (dwFlags & ICU_DECODE)              dwUrlFlags |= URL_UNESCAPE;
    if (dwFlags & ICU_ENCODE_PERCENT)      dwUrlFlags |= URL_ESCAPE_PERCENT;
    if (dwFlags & ICU_ENCODE_SPACES_ONLY)  dwUrlFlags |= URL_ESCAPE_SPACES_ONLY;
    /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
    if (dwFlags & ICU_NO_ENCODE)           dwUrlFlags ^= URL_ESCAPE_UNSAFE;
    if (dwFlags & ICU_NO_META)             dwUrlFlags |= URL_NO_META;
 
    return dwUrlFlags;
}

Referenced by InternetCanonicalizeUrlA(), and InternetCanonicalizeUrlW().

convert_urlcomp_atow()

static void convert_urlcomp_atow ( LPURL_COMPONENTSA  lpUrlComponents, LPURL_COMPONENTSW  urlCompW  )

static

Definition at line 4916 of file internet.c.

{
    INT len;
 
    ZeroMemory(urlCompW, sizeof(URL_COMPONENTSW));
 
    urlCompW->dwStructSize = sizeof(URL_COMPONENTSW);
    urlCompW->dwSchemeLength = lpUrlComponents->dwSchemeLength;
    urlCompW->nScheme = lpUrlComponents->nScheme;
    urlCompW->dwHostNameLength = lpUrlComponents->dwHostNameLength;
    urlCompW->nPort = lpUrlComponents->nPort;
    urlCompW->dwUserNameLength = lpUrlComponents->dwUserNameLength;
    urlCompW->dwPasswordLength = lpUrlComponents->dwPasswordLength;
    urlCompW->dwUrlPathLength = lpUrlComponents->dwUrlPathLength;
    urlCompW->dwExtraInfoLength = lpUrlComponents->dwExtraInfoLength;
 
    if (lpUrlComponents->lpszScheme)
    {
        len = URL_GET_COMP_LENGTHA(lpUrlComponents, Scheme) + 1;
        urlCompW->lpszScheme = malloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszScheme,
                            -1, urlCompW->lpszScheme, len);
    }
 
    if (lpUrlComponents->lpszHostName)
    {
        len = URL_GET_COMP_LENGTHA(lpUrlComponents, HostName) + 1;
        urlCompW->lpszHostName = malloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszHostName,
                            -1, urlCompW->lpszHostName, len);
    }
 
    if (lpUrlComponents->lpszUserName)
    {
        len = URL_GET_COMP_LENGTHA(lpUrlComponents, UserName) + 1;
        urlCompW->lpszUserName = malloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszUserName,
                            -1, urlCompW->lpszUserName, len);
    }
 
    if (lpUrlComponents->lpszPassword)
    {
        len = URL_GET_COMP_LENGTHA(lpUrlComponents, Password) + 1;
        urlCompW->lpszPassword = malloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszPassword,
                            -1, urlCompW->lpszPassword, len);
    }
 
    if (lpUrlComponents->lpszUrlPath)
    {
        len = URL_GET_COMP_LENGTHA(lpUrlComponents, UrlPath) + 1;
        urlCompW->lpszUrlPath = malloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszUrlPath,
                            -1, urlCompW->lpszUrlPath, len);
    }
 
    if (lpUrlComponents->lpszExtraInfo)
    {
        len = URL_GET_COMP_LENGTHA(lpUrlComponents, ExtraInfo) + 1;
        urlCompW->lpszExtraInfo = malloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszExtraInfo,
                            -1, urlCompW->lpszExtraInfo, len);
    }
}

Referenced by InternetCreateUrlA().

copy_optionA()

static char * copy_optionA ( WCHAR *  value )

static

Definition at line 1026 of file internet.c.

{
    DWORD len;
    void *tmp;
 
    if (!value)
        return NULL;
 
    len = WideCharToMultiByte(CP_ACP, 0, value, -1, NULL, 0, NULL, NULL);
    if (!(tmp = GlobalAlloc(0, len)))
        return NULL;
 
    WideCharToMultiByte(CP_ACP, 0, value, -1, tmp, len, NULL, NULL);
    return tmp;
}

Referenced by APPINFO_QueryOption(), and query_global_option().

copy_optionW()

static WCHAR * copy_optionW ( WCHAR *  value )

static

Definition at line 1011 of file internet.c.

{
    DWORD len;
    void *tmp;
 
    if (!value)
        return NULL;
 
    len = (wcslen(value) + 1) * sizeof(WCHAR);
    if (!(tmp = GlobalAlloc(0, len)))
        return NULL;
 
    return memcpy(tmp, value, len);
}

Referenced by APPINFO_QueryOption(), and query_global_option().

create_req_file()

DWORD create_req_file	(	const WCHAR *	file_name,
		req_file_t **	ret
	)

Definition at line 4607 of file internet.c.

{
    req_file_t *req_file;
 
    req_file = calloc(1, sizeof(*req_file));
    if(!req_file)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    req_file->ref = 1;
 
    req_file->file_name = wcsdup(file_name);
    if(!req_file->file_name) {
        free(req_file);
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    req_file->file_handle = CreateFileW(req_file->file_name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
              NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if(req_file->file_handle == INVALID_HANDLE_VALUE) {
        req_file_release(req_file);
        return GetLastError();
    }
 
    *ret = req_file;
    return ERROR_SUCCESS;
}

Referenced by create_cache_entry().

CreateMD5SSOHash()

BOOL WINAPI CreateMD5SSOHash	(	PWSTR	pszChallengeInfo,
		PWSTR	pwszRealm,
		PWSTR	pwszTarget,
		PBYTE	pbHexHash
	)

Definition at line 5315 of file internet.c.

{
    FIXME("(%s, %s, %s, %p) stub\n", debugstr_w(pszChallengeInfo), debugstr_w(pwszRealm),
          debugstr_w(pwszTarget), pbHexHash);
    return FALSE;
}

detect_proxy_autoconfig_url_dhcp()

static WCHAR * detect_proxy_autoconfig_url_dhcp ( void  )

static

Definition at line 2762 of file internet.c.

{
    IP_ADAPTER_ADDRESSES *adapters, *ptr;
    DHCPCAPI_PARAMS_ARRAY send_params, recv_params;
    DHCPCAPI_PARAMS param;
    WCHAR name[MAX_ADAPTER_NAME_LENGTH + 1], *ret = NULL;
    DWORD err, size;
    BYTE *tmp, *buf = NULL;
 
    if (!(adapters = get_adapters())) return NULL;
 
    memset( &send_params, 0, sizeof(send_params) );
    memset( &param, 0, sizeof(param) );
    param.OptionId = OPTION_MSFT_IE_PROXY;
    recv_params.nParams = 1;
    recv_params.Params  = &param;
 
    for (ptr = adapters; ptr; ptr = ptr->Next)
    {
        MultiByteToWideChar( CP_ACP, 0, ptr->AdapterName, -1, name, ARRAY_SIZE(name) );
        TRACE( "adapter '%s' type %lu dhcpv4 enabled %d\n", wine_dbgstr_w(name), ptr->IfType, ptr->Dhcpv4Enabled );
 
        if (ptr->IfType == IF_TYPE_SOFTWARE_LOOPBACK) continue;
        /* FIXME: also skip adapters where DHCP is disabled */
 
        size = 256;
        if (!(buf = malloc( size ))) goto done;
        err = DhcpRequestParams( DHCPCAPI_REQUEST_SYNCHRONOUS, NULL, name, NULL, send_params, recv_params,
                                 buf, &size, NULL );
        while (err == ERROR_MORE_DATA)
        {
            if (!(tmp = realloc( buf, size ))) goto done;
            buf = tmp;
            err = DhcpRequestParams( DHCPCAPI_REQUEST_SYNCHRONOUS, NULL, name, NULL, send_params, recv_params,
                                     buf, &size, NULL );
        }
        if (err == ERROR_SUCCESS && param.nBytesData)
        {
            int len = MultiByteToWideChar( CP_ACP, 0, (const char *)param.Data, param.nBytesData, NULL, 0 );
            if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
            {
                MultiByteToWideChar( CP_ACP, 0,  (const char *)param.Data, param.nBytesData, ret, len );
                ret[len] = 0;
            }
            TRACE("returning %s\n", debugstr_w(ret));
            break;
        }
        free( buf );
        buf = NULL;
    }
 
done:
    free( buf );
    free( adapters );
    return ret;
}

Referenced by get_proxy_autoconfig_url().

detect_proxy_autoconfig_url_dns()

static WCHAR * detect_proxy_autoconfig_url_dns ( void  )

static

Definition at line 2869 of file internet.c.

{
    char *fqdn, *domain, *p;
    WCHAR *ret;
 
    if (!(fqdn = get_computer_name( ComputerNamePhysicalDnsFullyQualified ))) return NULL;
    if (!(domain = get_computer_name( ComputerNamePhysicalDnsDomain )))
    {
        free( fqdn );
        return NULL;
    }
    p = fqdn;
    while ((p = strchr( p, '.' )) && is_domain_suffix( p + 1, domain ))
    {
        char *name;
        struct addrinfo *ai, hints;
        int res;
 
        if (!(name = malloc( sizeof("wpad") + strlen(p) )))
        {
            free( fqdn );
            free( domain );
            return NULL;
        }
        strcpy( name, "wpad" );
        strcat( name, p );
        memset( &hints, 0, sizeof(hints) );
        hints.ai_flags  = AI_ALL | AI_DNS_ONLY;
        hints.ai_family = AF_UNSPEC;
        res = getaddrinfo( name, NULL, &hints, &ai );
        if (!res)
        {
            ret = build_wpad_url( name, ai );
            freeaddrinfo( ai );
            if (ret)
            {
                TRACE("returning %s\n", debugstr_w(ret));
                free( name );
                break;
            }
        }
       free( name );
       p++;
    }
    free( domain );
    free( fqdn );
    return ret;
}

Referenced by get_proxy_autoconfig_url().

DetectAutoProxyUrl()

BOOL WINAPI DetectAutoProxyUrl	(	LPSTR	lpszAutoProxyUrl,
		DWORD	dwAutoProxyUrlLength,
		DWORD	dwDetectFlags
	)

Definition at line 589 of file internet.c.

{
    FIXME("STUB\n");
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

Referenced by test_InternetQueryOptionA().

DllInstall()

HRESULT WINAPI DllInstall	(	BOOL	bInstall,
		LPCWSTR	cmdline
	)

Definition at line 350 of file internet.c.

{
    FIXME("(%x %s): stub\n", bInstall, debugstr_w(cmdline));
    return S_OK;
}

DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	hinstDLL,
		DWORD	fdwReason,
		LPVOID	lpvReserved
	)

Definition at line 299 of file internet.c.

{
    TRACE("%p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
 
    switch (fdwReason) {
        case DLL_PROCESS_ATTACH:
 
            g_dwTlsErrIndex = TlsAlloc();
 
            if (g_dwTlsErrIndex == TLS_OUT_OF_INDEXES)
                return FALSE;
 
            if(!init_urlcache())
            {
                TlsFree(g_dwTlsErrIndex);
                return FALSE;
            }
 
            WININET_hModule = hinstDLL;
            break;
 
        case DLL_THREAD_ATTACH:
            break;
 
        case DLL_THREAD_DETACH:
            if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
            {
                free(TlsGetValue(g_dwTlsErrIndex));
            }
            break;
 
        case DLL_PROCESS_DETACH:
            if (lpvReserved) break;
            collect_connections(COLLECT_CLEANUP);
            NETCON_unload();
            free_urlcache();
            free_cookie();
 
            if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
            {
                free(TlsGetValue(g_dwTlsErrIndex));
                TlsFree(g_dwTlsErrIndex);
            }
            break;
    }
    return TRUE;
}

dump_INTERNET_FLAGS()

static void dump_INTERNET_FLAGS ( DWORD  dwFlags )

static

Definition at line 944 of file internet.c.

{
#define FE(x) { x, #x }
    static const wininet_flag_info flag[] = {
        FE(INTERNET_FLAG_RELOAD),
        FE(INTERNET_FLAG_RAW_DATA),
        FE(INTERNET_FLAG_EXISTING_CONNECT),
        FE(INTERNET_FLAG_ASYNC),
        FE(INTERNET_FLAG_PASSIVE),
        FE(INTERNET_FLAG_NO_CACHE_WRITE),
        FE(INTERNET_FLAG_MAKE_PERSISTENT),
        FE(INTERNET_FLAG_FROM_CACHE),
        FE(INTERNET_FLAG_SECURE),
        FE(INTERNET_FLAG_KEEP_CONNECTION),
        FE(INTERNET_FLAG_NO_AUTO_REDIRECT),
        FE(INTERNET_FLAG_READ_PREFETCH),
        FE(INTERNET_FLAG_NO_COOKIES),
        FE(INTERNET_FLAG_NO_AUTH),
        FE(INTERNET_FLAG_CACHE_IF_NET_FAIL),
        FE(INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP),
        FE(INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS),
        FE(INTERNET_FLAG_IGNORE_CERT_DATE_INVALID),
        FE(INTERNET_FLAG_IGNORE_CERT_CN_INVALID),
        FE(INTERNET_FLAG_RESYNCHRONIZE),
        FE(INTERNET_FLAG_HYPERLINK),
        FE(INTERNET_FLAG_NO_UI),
        FE(INTERNET_FLAG_PRAGMA_NOCACHE),
        FE(INTERNET_FLAG_CACHE_ASYNC),
        FE(INTERNET_FLAG_FORMS_SUBMIT),
        FE(INTERNET_FLAG_NEED_FILE),
        FE(INTERNET_FLAG_TRANSFER_ASCII),
        FE(INTERNET_FLAG_TRANSFER_BINARY)
    };
#undef FE
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(flag); i++) {
    if (flag[i].val & dwFlags) {
        TRACE(" %s", flag[i].name);
        dwFlags &= ~flag[i].val;
    }
    }   
    if (dwFlags)
        TRACE(" Unknown flags (%08lx)\n", dwFlags);
    else
        TRACE("\n");
}

Referenced by InternetOpenUrlW(), and InternetOpenW().

free_global_proxy()

static void free_global_proxy ( void  )

static

Definition at line 608 of file internet.c.

{
    EnterCriticalSection( &WININET_cs );
    FreeProxyInfo( &global_proxy );
    memset( &global_proxy, 0, sizeof(global_proxy) );
    LeaveCriticalSection( &WININET_cs );
}

Referenced by InternetSetOptionW().

FreeProxyInfo()

static void FreeProxyInfo ( proxyinfo_t *  lpwpi )

static

Definition at line 597 of file internet.c.

{
    free(lpwpi->proxy);
    free(lpwpi->proxyBypass);
    free(lpwpi->proxyUsername);
    free(lpwpi->proxyPassword);
    free(lpwpi->autoconf_url);
}

Referenced by free_global_proxy(), INTERNET_ConfigureProxy(), INTERNET_LoadProxySettings(), InternetSetOptionW(), load_connection_settings(), and query_global_option().

get_adapters()

static IP_ADAPTER_ADDRESSES * get_adapters ( void  )

static

Definition at line 2743 of file internet.c.

{
    ULONG err, size = 1024, flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
                                    GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME;
    IP_ADAPTER_ADDRESSES *tmp, *ret;
 
    if (!(ret = malloc( size ))) return NULL;
    err = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size );
    while (err == ERROR_BUFFER_OVERFLOW)
    {
        if (!(tmp = realloc( ret, size ))) break;
        ret = tmp;
        err = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size );
    }
    if (err == ERROR_SUCCESS) return ret;
    free( ret );
    return NULL;
}

Referenced by detect_proxy_autoconfig_url_dhcp().

get_computer_name()

static char * get_computer_name ( COMPUTER_NAME_FORMAT  format )

static

Definition at line 2819 of file internet.c.

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

Referenced by detect_proxy_autoconfig_url_dns().

get_handle_object()

object_header_t * get_handle_object

(

HINTERNET

hinternet

)

Definition at line 209 of file internet.c.

{
    object_header_t *info = NULL;
    UINT_PTR handle = (UINT_PTR) hinternet;
 
    EnterCriticalSection( &WININET_cs );
 
    if(handle > 0 && handle < handle_table_size && handle_table[handle] && handle_table[handle]->valid_handle)
        info = WININET_AddRef(handle_table[handle]);
 
    LeaveCriticalSection( &WININET_cs );
 
    TRACE("handle %Id -> %p\n", handle, info);
 
    return info;
}

Referenced by FtpCommandW(), FtpCreateDirectoryW(), FtpDeleteFileW(), FtpFindFirstFileW(), FtpGetCurrentDirectoryW(), FtpGetFileW(), FtpOpenFileW(), FtpPutFileW(), FtpRemoveDirectoryW(), FtpRenameFileW(), FtpSetCurrentDirectoryW(), HttpAddRequestHeadersW(), HttpEndRequestW(), HttpOpenRequestW(), HttpQueryInfoW(), HttpSendRequestExW(), HttpSendRequestW(), InternetCloseHandle(), InternetConnectW(), InternetErrorDlg(), InternetFindNextFileW(), InternetLockRequestFile(), InternetOpenUrlW(), InternetQueryDataAvailable(), InternetQueryOptionA(), InternetQueryOptionW(), InternetReadFile(), InternetReadFileExA(), InternetReadFileExW(), InternetSetFilePointer(), InternetSetOptionW(), InternetSetStatusCallbackA(), InternetSetStatusCallbackW(), and InternetWriteFile().

get_http_proxy()

static WCHAR * get_http_proxy ( const WCHAR *  proxy )

static

Definition at line 651 of file internet.c.

{
    const WCHAR *p, *end;
    WCHAR *ret;
 
    p = wcsstr( proxy, L"http=" );
    if (p) p += 5;
    else p = proxy;
    end = wcschr( p, ';' );
    if (!end) end = p + wcslen( p );
 
    ret = malloc( (end - p + 1) * sizeof(WCHAR) );
    memcpy(ret, p, (end - p) * sizeof(WCHAR) );
    ret[end - p] = 0;
    return ret;
}

Referenced by INTERNET_ConfigureProxy().

get_proxy_autoconfig_url()

static WCHAR * get_proxy_autoconfig_url ( void  )

static

Definition at line 2918 of file internet.c.

{
    WCHAR *ret = detect_proxy_autoconfig_url_dhcp();
    if (!ret) ret = detect_proxy_autoconfig_url_dns();
    return ret;
}

Referenced by APPINFO_QueryOption(), and query_global_option().

GetInternetSchemeW()

static INTERNET_SCHEME GetInternetSchemeW ( LPCWSTR  lpszScheme, DWORD  nMaxCmp  )

static

Definition at line 2027 of file internet.c.

{
    int i;
 
    TRACE("%s %ld\n",debugstr_wn(lpszScheme, nMaxCmp), nMaxCmp);
 
    if(lpszScheme==NULL)
        return INTERNET_SCHEME_UNKNOWN;
 
    for (i = 0; i < ARRAY_SIZE(url_schemes); i++)
        if (!wcsnicmp(lpszScheme, url_schemes[i], nMaxCmp))
            return INTERNET_SCHEME_FIRST + i;
 
    return INTERNET_SCHEME_UNKNOWN;
}

Referenced by calc_url_length(), InternetCrackUrlW(), and InternetCreateUrlW().

INET_QueryOption()

DWORD INET_QueryOption	(	object_header_t *	hdr,
		DWORD	option,
		void *	buffer,
		DWORD *	size,
		BOOL	unicode
	)

Definition at line 3159 of file internet.c.

{
    switch(option) {
    case INTERNET_OPTION_CONTEXT_VALUE:
        if (!size)
            return ERROR_INVALID_PARAMETER;
 
        if (*size < sizeof(DWORD_PTR)) {
            *size = sizeof(DWORD_PTR);
            return ERROR_INSUFFICIENT_BUFFER;
        }
        if (!buffer)
            return ERROR_INVALID_PARAMETER;
 
        *(DWORD_PTR *)buffer = hdr->dwContext;
        *size = sizeof(DWORD_PTR);
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_REQUEST_FLAGS:
        WARN("INTERNET_OPTION_REQUEST_FLAGS\n");
        *size = sizeof(DWORD);
        return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
 
    case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
    case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
        WARN("Called on global option %lu\n", option);
        return ERROR_INTERNET_INVALID_OPERATION;
 
    case INTERNET_OPTION_CONNECT_TIMEOUT:
        TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *(ULONG*)buffer = hdr->connect_timeout;
        *size = sizeof(ULONG);
 
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_SEND_TIMEOUT:
        TRACE("INTERNET_OPTION_SEND_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *size = sizeof(ULONG);
        *(ULONG *)buffer = hdr->send_timeout;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_RECEIVE_TIMEOUT:
        TRACE("INTERNET_OPTION_RECEIVE_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *size = sizeof(ULONG);
        *(ULONG *)buffer = hdr->receive_timeout;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_DATA_SEND_TIMEOUT:
        TRACE("INTERNET_OPTION_DATA_SEND_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *size = sizeof(ULONG);
        *(ULONG *)buffer = hdr->data_send_timeout;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
        TRACE("INTERNET_OPTION_DATA_RECEIVE_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *size = sizeof(ULONG);
        *(ULONG *)buffer = hdr->data_receive_timeout;
        return ERROR_SUCCESS;
    }
 
    /* FIXME: we shouldn't call it here */
    return query_global_option(option, buffer, size, unicode);
}

Referenced by APPINFO_QueryOption(), FTPFILE_QueryOption(), FTPFINDNEXT_QueryOption(), FTPSESSION_QueryOption(), and HTTPSESSION_QueryOption().

INET_SetOption()

DWORD INET_SetOption	(	object_header_t *	hdr,
		DWORD	option,
		void *	buf,
		DWORD	size
	)

Definition at line 3309 of file internet.c.

{
    switch(option) {
    case INTERNET_OPTION_SETTINGS_CHANGED:
        FIXME("INTERNETOPTION_SETTINGS_CHANGED semi-stub\n");
        collect_connections(COLLECT_CONNECTIONS);
        return ERROR_SUCCESS;
    case INTERNET_OPTION_CALLBACK:
        WARN("Not settable option %lu\n", option);
        return ERROR_INTERNET_OPTION_NOT_SETTABLE;
    case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
    case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
        WARN("Called on global option %lu\n", option);
        return ERROR_INTERNET_INVALID_OPERATION;
    case INTERNET_OPTION_REFRESH:
        return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
    case INTERNET_OPTION_CONNECT_TIMEOUT:
        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
        hdr->connect_timeout = *(ULONG *)buf;
        return ERROR_SUCCESS;
    case INTERNET_OPTION_SEND_TIMEOUT:
        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
        hdr->send_timeout = *(ULONG *)buf;
        return ERROR_SUCCESS;
    case INTERNET_OPTION_RECEIVE_TIMEOUT:
        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
        hdr->receive_timeout = *(ULONG *)buf;
        return ERROR_SUCCESS;
    case INTERNET_OPTION_DATA_SEND_TIMEOUT:
        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
        hdr->data_send_timeout = *(ULONG *)buf;
        return ERROR_SUCCESS;
    case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
        hdr->data_receive_timeout = *(ULONG *)buf;
        return ERROR_SUCCESS;
    }
 
    return ERROR_INTERNET_INVALID_OPTION;
}

Referenced by APPINFO_SetOption(), HTTPREQ_SetOption(), HTTPSESSION_SetOption(), and set_global_option().

init_global_proxy()

static void init_global_proxy ( void  )

static

Definition at line 860 of file internet.c.

{
    const WCHAR *envproxy;
 
    EnterCriticalSection( &WININET_cs );
    if (global_proxy.flags) goto done;
 
    INTERNET_LoadProxySettings( &global_proxy );
    if (global_proxy.flags & PROXY_TYPE_PROXY || !(envproxy = _wgetenv( L"http_proxy" )))
        goto done;
 
    if (parse_proxy_url( &global_proxy, envproxy ))
    {
        global_proxy.flags |= PROXY_TYPE_PROXY;
        global_proxy.proxyBypass = wcsdup(_wgetenv( L"no_proxy" ));
        TRACE("http proxy (from environment) = %s\n", debugstr_w(global_proxy.proxy));
        TRACE("http proxy bypass (from environment) = %s\n", debugstr_w(global_proxy.proxyBypass));
    }
    else
    {
        WARN("failed to parse http_proxy value %s\n", debugstr_w(envproxy));
    }
 
done:
    LeaveCriticalSection( &WININET_cs );
}

Referenced by INTERNET_GetProxySettings().

INTERNET_AllocThreadError()

static LPWITHREADERROR INTERNET_AllocThreadError ( void  )

static

Definition at line 4429 of file internet.c.

{
    WITHREADERROR *lpwite = malloc(sizeof(*lpwite));
 
    if (lpwite)
    {
        lpwite->dwError = 0;
        lpwite->response[0] = '\0';
    }
 
    if (!TlsSetValue(g_dwTlsErrIndex, lpwite))
    {
        free(lpwite);
        return NULL;
    }
    return lpwite;
}

Referenced by INTERNET_GetResponseBuffer(), and INTERNET_SetLastError().

INTERNET_AsyncCall()

DWORD INTERNET_AsyncCall

(

task_header_t *

task

)

Definition at line 4534 of file internet.c.

{
    BOOL bSuccess;
 
    TRACE("\n");
 
    bSuccess = QueueUserWorkItem(INTERNET_WorkerThreadFunc, task, WT_EXECUTELONGFUNCTION);
    if (!bSuccess)
    {
        free(task);
        return ERROR_INTERNET_ASYNC_THREAD_FAILED;
    }
    return ERROR_SUCCESS;
}

Referenced by async_read(), FtpCreateDirectoryW(), FtpDeleteFileW(), FTPFILE_QueryDataAvailable(), FtpFindFirstFileW(), FTPFINDNEXT_FindNextFileW(), FtpGetCurrentDirectoryW(), FtpGetFileW(), FtpOpenFileW(), FtpPutFileW(), FtpRemoveDirectoryW(), FtpRenameFileW(), FtpSetCurrentDirectoryW(), HttpEndRequestW(), HttpSendRequestExW(), HttpSendRequestW(), and InternetOpenUrlW().

INTERNET_ConfigureProxy()

static BOOL INTERNET_ConfigureProxy ( appinfo_t *  lpwai )

static

Definition at line 910 of file internet.c.

{
    proxyinfo_t wpi;
 
    if (INTERNET_GetProxySettings( &wpi ))
        return FALSE;
 
    if (wpi.flags & PROXY_TYPE_PROXY)
    {
        TRACE("http proxy = %s bypass = %s\n", debugstr_w(wpi.proxy), debugstr_w(wpi.proxyBypass));
 
        lpwai->accessType    = INTERNET_OPEN_TYPE_PROXY;
        lpwai->proxy         = get_http_proxy( wpi.proxy );
        lpwai->proxyBypass   = wpi.proxyBypass;
        lpwai->proxyUsername = wpi.proxyUsername;
        lpwai->proxyPassword = wpi.proxyPassword;
        free( wpi.proxy );
        return TRUE;
    }
 
    lpwai->accessType = INTERNET_OPEN_TYPE_DIRECT;
    FreeProxyInfo(&wpi);
    return FALSE;
}

Referenced by InternetOpenW(), and query_global_option().

INTERNET_FindProxyForProtocol()

WCHAR * INTERNET_FindProxyForProtocol	(	LPCWSTR	szProxy,
		LPCWSTR	proto
	)

Definition at line 511 of file internet.c.

{
    WCHAR *ret = NULL;
    const WCHAR *ptr;
 
    TRACE("(%s, %s)\n", debugstr_w(szProxy), debugstr_w(proto));
 
    /* First, look for the specified protocol (proto=scheme://host:port) */
    for (ptr = szProxy; ptr && *ptr; )
    {
        LPCWSTR end, equal;
 
        if (!(end = wcschr(ptr, ' ')))
            end = ptr + lstrlenW(ptr);
        if ((equal = wcschr(ptr, '=')) && equal < end &&
             equal - ptr == lstrlenW(proto) &&
             !wcsnicmp(proto, ptr, lstrlenW(proto)))
        {
            ret = strndupW(equal + 1, end - equal - 1);
            TRACE("found proxy for %s: %s\n", debugstr_w(proto), debugstr_w(ret));
            return ret;
        }
        if (*end == ' ')
            ptr = end + 1;
        else
            ptr = end;
    }
 
    /* It wasn't found: look for no protocol */
    for (ptr = szProxy; ptr && *ptr; )
    {
        LPCWSTR end;
 
        if (!(end = wcschr(ptr, ' ')))
            end = ptr + lstrlenW(ptr);
        if (!wcschr(ptr, '='))
        {
            ret = strndupW(ptr, end - ptr);
            TRACE("found proxy for %s: %s\n", debugstr_w(proto), debugstr_w(ret));
            return ret;
        }
        if (*end == ' ')
            ptr = end + 1;
        else
            ptr = end;
    }
 
    return NULL;
}

Referenced by HTTP_DealWithProxy().

INTERNET_GetLastError()

DWORD INTERNET_GetLastError

(

void

)

Definition at line 4477 of file internet.c.

{
    LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
    if (!lpwite) return 0;
    /* TlsGetValue clears last error, so set it again here */
    SetLastError(lpwite->dwError);
    return lpwite->dwError;
}

Referenced by FTP_FtpCreateDirectoryW(), FTP_FtpDeleteFileW(), FTP_FtpFindFirstFileW(), FTP_FtpGetFileW(), FTP_FtpOpenFileW(), FTP_FtpPutFileW(), FTP_FtpRemoveDirectoryW(), FTP_FtpRenameFileW(), FTP_ReceiveRequestData(), HTTP_HandleRedirect(), and InternetConnectW().

INTERNET_GetProxySettings()

static LONG INTERNET_GetProxySettings ( proxyinfo_t *  lpwpi )

static

Definition at line 892 of file internet.c.

{
    init_global_proxy();
 
    memset(lpwpi, 0, sizeof(*lpwpi));
    EnterCriticalSection( &WININET_cs );
    lpwpi->flags = global_proxy.flags;
    lpwpi->proxy = wcsdup( global_proxy.proxy );
    lpwpi->proxyBypass = wcsdup( global_proxy.proxyBypass );
    lpwpi->proxyUsername = wcsdup( global_proxy.proxyUsername );
    lpwpi->proxyPassword = wcsdup( global_proxy.proxyPassword );
    LeaveCriticalSection( &WININET_cs );
    return ERROR_SUCCESS;
}

Referenced by INTERNET_ConfigureProxy().

INTERNET_GetResponseBuffer()

LPSTR INTERNET_GetResponseBuffer

(

void

)

Definition at line 4556 of file internet.c.

{
    LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
    if (!lpwite)
        lpwite = INTERNET_AllocThreadError();
    TRACE("\n");
    return lpwite->response;
}

Referenced by FTP_DoPassive(), FTP_FtpGetCurrentDirectoryW(), FTP_GetNextLine(), and FTP_ReceiveResponse().

INTERNET_GetSchemeString()

static LPCWSTR INTERNET_GetSchemeString ( INTERNET_SCHEME  scheme )

static

Definition at line 4821 of file internet.c.

{
    int index;
    if (scheme < INTERNET_SCHEME_FIRST)
        return NULL;
    index = scheme - INTERNET_SCHEME_FIRST;
    if (index >= ARRAY_SIZE(url_schemes))
        return NULL;
    return url_schemes[index];
}

Referenced by calc_url_length(), and InternetCreateUrlW().

INTERNET_InternetOpenUrlW()

static HINTERNET INTERNET_InternetOpenUrlW ( appinfo_t *  hIC, LPCWSTR  lpszUrl, LPCWSTR  lpszHeaders, DWORD  dwHeadersLength, DWORD  dwFlags, DWORD_PTR  dwContext  )

static

Definition at line 4222 of file internet.c.

{
    URL_COMPONENTSW urlComponents = { sizeof(urlComponents) };
    WCHAR *host, *user = NULL, *pass = NULL, *path;
    HINTERNET client = NULL, client1 = NULL;
    DWORD res;
    
    TRACE("(%p, %s, %s, %08lx, %08lx, %08Ix)\n", hIC, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
      dwHeadersLength, dwFlags, dwContext);
    
    urlComponents.dwHostNameLength = 1;
    urlComponents.dwUserNameLength = 1;
    urlComponents.dwPasswordLength = 1;
    urlComponents.dwUrlPathLength = 1;
    urlComponents.dwExtraInfoLength = 1;
    if(!InternetCrackUrlW(lpszUrl, lstrlenW(lpszUrl), 0, &urlComponents))
    return NULL;
 
    if ((urlComponents.nScheme == INTERNET_SCHEME_HTTP || urlComponents.nScheme == INTERNET_SCHEME_HTTPS) &&
        urlComponents.dwExtraInfoLength)
    {
        assert(urlComponents.lpszUrlPath + urlComponents.dwUrlPathLength == urlComponents.lpszExtraInfo);
        urlComponents.dwUrlPathLength += urlComponents.dwExtraInfoLength;
    }
 
    host = strndupW(urlComponents.lpszHostName, urlComponents.dwHostNameLength);
    path = strndupW(urlComponents.lpszUrlPath, urlComponents.dwUrlPathLength);
    if(urlComponents.dwUserNameLength)
        user = strndupW(urlComponents.lpszUserName, urlComponents.dwUserNameLength);
    if(urlComponents.dwPasswordLength)
        pass = strndupW(urlComponents.lpszPassword, urlComponents.dwPasswordLength);
 
    switch(urlComponents.nScheme) {
    case INTERNET_SCHEME_FTP:
    client = FTP_Connect(hIC, host, urlComponents.nPort,
                 user, pass, dwFlags, dwContext, INET_OPENURL);
    if(client == NULL)
        break;
    client1 = FtpOpenFileW(client, path, GENERIC_READ, dwFlags, dwContext);
    if(client1 == NULL) {
        InternetCloseHandle(client);
        break;
    }
    break;
    
    case INTERNET_SCHEME_HTTP:
    case INTERNET_SCHEME_HTTPS: {
        LPCWSTR accept[2] = { L"*/*", NULL };
 
        if (urlComponents.nScheme == INTERNET_SCHEME_HTTPS) dwFlags |= INTERNET_FLAG_SECURE;
 
        /* FIXME: should use pointers, not handles, as handles are not thread-safe */
    res = HTTP_Connect(hIC, host, urlComponents.nPort,
                           user, pass, dwFlags, dwContext, INET_OPENURL, &client);
        if(res != ERROR_SUCCESS) {
            INTERNET_SetLastError(res);
        break;
        }
 
        client1 = HttpOpenRequestW(client, NULL, path, NULL, NULL, accept, dwFlags, dwContext);
    if(client1 == NULL) {
        InternetCloseHandle(client);
        break;
    }
    HttpAddRequestHeadersW(client1, lpszHeaders, dwHeadersLength, HTTP_ADDREQ_FLAG_ADD);
    if (!HttpSendRequestW(client1, NULL, 0, NULL, 0) &&
            GetLastError() != ERROR_IO_PENDING) {
        InternetCloseHandle(client1);
        client1 = NULL;
        break;
    }
    }
    case INTERNET_SCHEME_GOPHER:
    /* gopher doesn't seem to be implemented in wine, but it's supposed
     * to be supported by InternetOpenUrlA. */
    default:
        SetLastError(ERROR_INTERNET_UNRECOGNIZED_SCHEME);
    break;
    }
 
    TRACE(" %p <--\n", client1);
 
    free(host);
    free(path);
    free(user);
    free(pass);
    return client1;
}

Referenced by AsyncInternetOpenUrlProc(), and InternetOpenUrlW().

INTERNET_LoadProxySettings()

static LONG INTERNET_LoadProxySettings ( proxyinfo_t *  lpwpi )

static

Definition at line 753 of file internet.c.

{
    DWORD type, len, val;
    HKEY key, con;
    LONG ret;
 
    memset( lpwpi, 0, sizeof(*lpwpi) );
 
    if ((ret = RegOpenKeyW( HKEY_CURRENT_USER, szInternetSettings, &key )))
        return ret;
 
    if (!(ret = RegOpenKeyW( key, L"Connections", &con )))
    {
        load_connection_settings( con, L"DefaultConnectionSettings", lpwpi );
        RegCloseKey( con );
    }
 
    len = sizeof(DWORD);
    if (RegQueryValueExW( key, L"ProxyEnable", NULL, &type, (BYTE *)&val, &len ) || type != REG_DWORD)
    {
        val = !!(lpwpi->flags & PROXY_TYPE_PROXY);
        if((ret = RegSetValueExW( key, L"ProxyEnable", 0, REG_DWORD, (BYTE *)&val, sizeof(DWORD) )))
        {
            RegCloseKey( key );
            FreeProxyInfo( lpwpi );
            return ret;
        }
    }
    else if (val)
    {
        lpwpi->flags |= PROXY_TYPE_PROXY;
    }
    else
    {
        lpwpi->flags &= ~PROXY_TYPE_PROXY;
    }
 
    /* figure out how much memory the proxy setting takes */
    if (!RegQueryValueExW( key, L"ProxyServer", NULL, &type, NULL, &len ) && len && (type == REG_SZ))
    {
        LPWSTR szProxy;
 
        if (!(szProxy = malloc( len )))
        {
            RegCloseKey( key );
            FreeProxyInfo( lpwpi );
            return ERROR_OUTOFMEMORY;
        }
        RegQueryValueExW( key, L"ProxyServer", NULL, &type, (BYTE*)szProxy, &len );
 
        free( lpwpi->proxy );
        lpwpi->proxy = szProxy;
    }
 
    if (lpwpi->proxy)
    {
        TRACE("proxy (from registry%s) = %s\n", lpwpi->flags & PROXY_TYPE_PROXY ? "" : ", disabled",
                debugstr_w(lpwpi->proxy));
    }
    else
    {
        TRACE("No proxy server settings in registry.\n");
    }
 
    if (!RegQueryValueExW( key, L"ProxyOverride", NULL, &type, NULL, &len ) && len && (type == REG_SZ))
    {
        LPWSTR szProxy;
 
        if (!(szProxy = malloc( len )))
        {
            RegCloseKey( key );
            FreeProxyInfo( lpwpi );
            return ERROR_OUTOFMEMORY;
        }
        RegQueryValueExW( key, L"ProxyOverride", NULL, &type, (BYTE*)szProxy, &len );
 
        free( lpwpi->proxyBypass );
        lpwpi->proxyBypass = szProxy;
        TRACE("http proxy bypass (from registry) = %s\n", debugstr_w(lpwpi->proxyBypass));
    }
    else
    {
        TRACE("No proxy bypass server settings in registry.\n");
    }
 
    if (!RegQueryValueExW( key, L"AutoConfigURL", NULL, &type, NULL, &len ) && len && (type == REG_SZ))
    {
        LPWSTR autoconf_url;
 
        if (!(autoconf_url = malloc( len )))
        {
            RegCloseKey( key );
            FreeProxyInfo( lpwpi );
            return ERROR_OUTOFMEMORY;
        }
        RegQueryValueExW( key, L"AutoConfigURL", NULL, &type, (BYTE*)autoconf_url, &len );
 
        lpwpi->flags |= PROXY_TYPE_AUTO_PROXY_URL;
        free( lpwpi->autoconf_url );
        lpwpi->autoconf_url = autoconf_url;
        TRACE("AutoConfigURL = %s\n", debugstr_w(lpwpi->autoconf_url));
    }
 
    RegCloseKey( key );
    return ERROR_SUCCESS;
}

Referenced by init_global_proxy(), InternetSetOptionW(), and query_global_option().

INTERNET_SaveProxySettings()

static LONG INTERNET_SaveProxySettings ( proxyinfo_t *  lpwpi )

static

Definition at line 406 of file internet.c.

{
    HKEY key, con;
    DWORD val;
    LONG ret;
 
    if ((ret = RegOpenKeyW( HKEY_CURRENT_USER, szInternetSettings, &key )))
        return ret;
 
    if ((ret = RegCreateKeyExW( key, L"Connections", 0, NULL, 0, KEY_WRITE, NULL, &con, NULL )))
    {
        RegCloseKey( key );
        return ret;
    }
    ret = save_connection_settings( con, L"DefaultConnectionSettings", lpwpi );
    RegCloseKey( con );
    if (ret)
    {
        RegCloseKey( key );
        return ret;
    }
 
    val = !!(lpwpi->flags & PROXY_TYPE_PROXY);
    if ((ret = RegSetValueExW( key, L"ProxyEnable", 0, REG_DWORD, (BYTE*)&val, sizeof(DWORD))))
    {
        RegCloseKey( key );
        return ret;
    }
 
    if (lpwpi->proxy)
    {
        if ((ret = RegSetValueExW( key, L"ProxyServer", 0, REG_SZ, (BYTE*)lpwpi->proxy,
                        sizeof(WCHAR) * (lstrlenW(lpwpi->proxy) + 1))))
        {
            RegCloseKey( key );
            return ret;
        }
    }
    else
    {
        if ((ret = RegDeleteValueW( key, L"ProxyServer" )) && ret != ERROR_FILE_NOT_FOUND)
        {
            RegCloseKey( key );
            return ret;
        }
    }
 
    if (lpwpi->proxyBypass)
    {
        if ((ret = RegSetValueExW( key, L"ProxyOverride", 0, REG_SZ, (BYTE*)lpwpi->proxyBypass,
                        sizeof(WCHAR) * (lstrlenW(lpwpi->proxyBypass) + 1))))
        {
            RegCloseKey( key );
            return ret;
        }
    }
    else
    {
        if ((ret = RegDeleteValueW( key, L"ProxyOverride" )) && ret != ERROR_FILE_NOT_FOUND)
        {
            RegCloseKey( key );
            return ret;
        }
    }
 
    if (lpwpi->autoconf_url && lpwpi->flags & PROXY_TYPE_AUTO_PROXY_URL)
    {
        if ((ret = RegSetValueExW( key, L"AutoConfigURL", 0, REG_SZ, (BYTE*)lpwpi->autoconf_url,
                        sizeof(WCHAR) * (lstrlenW(lpwpi->autoconf_url) + 1))))
        {
            RegCloseKey( key );
            return ret;
        }
    }
    else
    {
        if ((ret = RegDeleteValueW( key, L"AutoConfigURL" )) && ret != ERROR_FILE_NOT_FOUND)
        {
            RegCloseKey( key );
            return ret;
        }
    }
 
    RegCloseKey(key);
    return ERROR_SUCCESS;
}

Referenced by InternetSetOptionW().

INTERNET_SetLastError()

void INTERNET_SetLastError

(

DWORD

dwError

)

Definition at line 4456 of file internet.c.

{
    LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
 
    if (!lpwite)
        lpwite = INTERNET_AllocThreadError();
 
    SetLastError(dwError);
    if(lpwite)
        lpwite->dwError = dwError;
}

Referenced by calc_url_length(), FTP_Connect(), FTP_FtpCreateDirectoryW(), FTP_FtpDeleteFileW(), FTP_FtpFindFirstFileW(), FTP_FtpGetCurrentDirectoryW(), FTP_FtpGetFileW(), FTP_FtpOpenFileW(), FTP_FtpPutFileW(), FTP_FtpRemoveDirectoryW(), FTP_FtpRenameFileW(), FTP_FtpSetCurrentDirectoryW(), FTP_GetNextLine(), FTP_ParseDirectory(), FTP_RetrieveFileData(), FTP_SendCommandA(), FTP_SetResponseError(), FtpCommandA(), FtpCommandW(), FtpCreateDirectoryW(), FtpDeleteFileW(), FtpFindFirstFileW(), FtpGetCurrentDirectoryA(), FtpGetCurrentDirectoryW(), FtpGetFileW(), FtpOpenFileW(), FtpPutFileW(), FtpRemoveDirectoryW(), FtpRenameFileW(), FtpSetCurrentDirectoryW(), GetUrlCacheConfigInfoA(), GetUrlCacheConfigInfoW(), INTERNET_InternetOpenUrlW(), InternetCheckConnectionW(), InternetCreateUrlW(), InternetOpenW(), InternetReadFile(), InternetReadFileExA(), InternetReadFileExW(), and res_to_le().

INTERNET_WorkerThreadFunc()

static DWORD CALLBACK INTERNET_WorkerThreadFunc ( LPVOID  lpvParam )

static

Definition at line 4495 of file internet.c.

{
    task_header_t *task = lpvParam;
 
    TRACE("\n");
 
    task->proc(task);
    WININET_Release(task->hdr);
    free(task);
 
    if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
    {
        free(TlsGetValue(g_dwTlsErrIndex));
        TlsSetValue(g_dwTlsErrIndex, NULL);
    }
    return TRUE;
}

Referenced by INTERNET_AsyncCall().

InternetAttemptConnect()

DWORD WINAPI InternetAttemptConnect

(

DWORD

dwReserved

)

Definition at line 2368 of file internet.c.

{
    FIXME("Stub\n");
    return ERROR_SUCCESS;
}

InternetAutodial()

BOOL WINAPI InternetAutodial	(	DWORD	dwFlags,
		HWND	hwndParent
	)

Definition at line 4701 of file internet.c.

{
    FIXME("STUB\n");
 
    /* Tell that we are connected to the internet. */
    return TRUE;
}

InternetAutodialHangup()

BOOL WINAPI InternetAutodialHangup

(

DWORD

dwReserved

)

Definition at line 4721 of file internet.c.

{
    FIXME("STUB\n");
 
    /* we didn't dial, we don't disconnect */
    return TRUE;
}

InternetCanonicalizeUrlA()

BOOL WINAPI InternetCanonicalizeUrlA	(	LPCSTR	lpszUrl,
		LPSTR	lpszBuffer,
		LPDWORD	lpdwBufferLength,
		DWORD	dwFlags
	)

Definition at line 2411 of file internet.c.

{
    HRESULT hr;
 
    TRACE("(%s, %p, %p, 0x%08lx) buffer length: %ld\n", debugstr_a(lpszUrl), lpszBuffer,
        lpdwBufferLength, dwFlags, lpdwBufferLength ? *lpdwBufferLength : -1);
 
    dwFlags = convert_url_canonicalization_flags(dwFlags);
    hr = UrlCanonicalizeA(lpszUrl, lpszBuffer, lpdwBufferLength, dwFlags);
    if (hr == E_POINTER) SetLastError(ERROR_INSUFFICIENT_BUFFER);
    if (hr == E_INVALIDARG) SetLastError(ERROR_INVALID_PARAMETER);
 
    return hr == S_OK;
}

Referenced by InternetCanonicalizeUrl_test(), InternetOpenUrlA_test(), and test_InternetCanonicalizeUrlA().

InternetCanonicalizeUrlW()

BOOL WINAPI InternetCanonicalizeUrlW	(	LPCWSTR	lpszUrl,
		LPWSTR	lpszBuffer,
		LPDWORD	lpdwBufferLength,
		DWORD	dwFlags
	)

Definition at line 2437 of file internet.c.

{
    HRESULT hr;
 
    TRACE("(%s, %p, %p, 0x%08lx) buffer length: %ld\n", debugstr_w(lpszUrl), lpszBuffer,
          lpdwBufferLength, dwFlags, lpdwBufferLength ? *lpdwBufferLength : -1);
 
    dwFlags = convert_url_canonicalization_flags(dwFlags);
    hr = UrlCanonicalizeW(lpszUrl, lpszBuffer, lpdwBufferLength, dwFlags);
    if (hr == E_POINTER) SetLastError(ERROR_INSUFFICIENT_BUFFER);
    if (hr == E_INVALIDARG) SetLastError(ERROR_INVALID_PARAMETER);
 
    return hr == S_OK;
}

Referenced by InternetCrackUrlW(), and SetFriendlyUrl().

InternetCheckConnectionA()

BOOL WINAPI InternetCheckConnectionA	(	LPCSTR	lpszUrl,
		DWORD	dwFlags,
		DWORD	dwReserved
	)

Definition at line 4196 of file internet.c.

{
    WCHAR *url = NULL;
    BOOL rc;
 
    if(lpszUrl) {
        url = strdupAtoW(lpszUrl);
        if(!url)
            return FALSE;
    }
 
    rc = InternetCheckConnectionW(url, dwFlags, dwReserved);
 
    free(url);
    return rc;
}

InternetCheckConnectionW()

BOOL WINAPI InternetCheckConnectionW	(	LPCWSTR	lpszUrl,
		DWORD	dwFlags,
		DWORD	dwReserved
	)

Definition at line 4080 of file internet.c.

{
/*
 * this is a kludge which runs the resident ping program and reads the output.
 *
 * Anyone have a better idea?
 */
 
  BOOL   rc = FALSE;
  static const CHAR ping[] = "ping -c 1 ";
  static const CHAR redirect[] = " >/dev/null 2>/dev/null";
  WCHAR *host;
  DWORD len, host_len;
  INTERNET_PORT port;
  int status = -1;
 
  FIXME("(%s %lx %lx)\n", debugstr_w(lpszUrl), dwFlags, dwReserved);
 
  /*
   * Crack or set the Address
   */
  if (lpszUrl == NULL)
  {
     /*
      * According to the doc we are supposed to use the ip for the next
      * server in the WnInet internal server database. I have
      * no idea what that is or how to get it.
      *
      * So someone needs to implement this.
      */
     FIXME("Unimplemented with URL of NULL\n");
     return TRUE;
  }
  else
  {
     URL_COMPONENTSW components = {sizeof(components)};
 
     components.dwHostNameLength = 1;
 
     if (!InternetCrackUrlW(lpszUrl,0,0,&components))
       goto End;
 
     host = components.lpszHostName;
     host_len = components.dwHostNameLength;
     port = components.nPort;
     TRACE("host name: %s port: %d\n",debugstr_wn(host, host_len), port);
  }
 
  if (dwFlags & FLAG_ICC_FORCE_CONNECTION)
  {
      struct sockaddr_storage saddr;
      int sa_len = sizeof(saddr);
      WCHAR *host_z;
      int fd;
      BOOL b;
 
      host_z = strndupW(host, host_len);
      if (!host_z)
          return FALSE;
 
      b = GetAddress(host_z, port, (struct sockaddr *)&saddr, &sa_len, NULL);
      free(host_z);
      if(!b)
          goto End;
      init_winsock();
      fd = socket(saddr.ss_family, SOCK_STREAM, 0);
      if (fd != -1)
      {
          if (connect(fd, (struct sockaddr *)&saddr, sa_len) == 0)
              rc = TRUE;
          closesocket(fd);
      }
  }
  else
  {
      /*
       * Build our ping command
       */
      char *command;
 
      len = WideCharToMultiByte(CP_UNIXCP, 0, host, host_len, NULL, 0, NULL, NULL);
      command = malloc(strlen(ping) + len + strlen(redirect) + 1);
      strcpy(command, ping);
      WideCharToMultiByte(CP_UNIXCP, 0, host, host_len, command+sizeof(ping)-1, len, NULL, NULL);
      strcpy(command+sizeof(ping)-1+len, redirect);
 
      TRACE("Ping command is : %s\n",command);
 
      status = system(command);
      free(command);
 
      TRACE("Ping returned a code of %i\n",status);
 
      /* Ping return code of 0 indicates success */
      if (status == 0)
         rc = TRUE;
  }
 
End:
  if (rc == FALSE)
    INTERNET_SetLastError(ERROR_NOT_CONNECTED);
 
  return rc;
}

Referenced by InternetCheckConnectionA().

InternetCloseHandle()

BOOL WINAPI InternetCloseHandle

(

HINTERNET

hInternet

)

Definition at line 1841 of file internet.c.

{
    object_header_t *obj;
    
    TRACE("%p\n", hInternet);
 
    obj = get_handle_object( hInternet );
    if (!obj) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    invalidate_handle(obj);
    WININET_Release(obj);
 
    return TRUE;
}

Referenced by _close_request(), AsyncInetCancel(), AsyncInetCleanUp(), AsyncInetFree(), can_do_https(), close_async_handle(), CRYPT_Connect(), get_internet_session(), HTTP_RetrieveEncodedObjectW(), HttpHeaders_test(), HttpSendRequestEx_test(), INTERNET_InternetOpenUrlW(), InternetLockRequestFile_test(), InternetOpenRequest_test(), InternetOpenUrlA_test(), InternetReadFile_chunked_test(), InternetSetFilePointer_test(), CDownloadManager::PerformDownloadAndInstall(), process_detach(), protocol_close_connection(), rpcrt4_ncacn_http_close(), START_TEST(), test_accept_encoding(), test_async_HttpSendRequestEx(), test_basic_auth_credentials_cached_manual(), test_basic_auth_credentials_different(), test_basic_auth_credentials_end_session(), test_basic_auth_credentials_manual(), test_basic_auth_credentials_reuse(), test_basic_authentication(), test_bogus_accept_types_array(), test_cache_control_verb(), test_cache_read_gzipped(), test_cert_string(), test_concurrent_header_access(), test_connect(), test_connection_header(), test_cookie_header(), test_default_service_port(), test_find_first_file(), test_header_handling_order(), test_header_override(), test_http_cache(), test_HttpSendRequestW(), test_InternetCloseHandle(), test_InternetErrorDlg(), test_InternetQueryOptionA(), test_InternetSetOption(), test_large_header(), test_no_cache(), test_not_modified(), test_null(), test_open_url_async(), test_openfile(), test_Option_PerConnectionOption(), test_Option_PerConnectionOptionA(), test_options(), test_proxy_direct(), test_secure_connection(), test_status_callbacks(), test_user_agent_header(), verify_cert_revocation_with_ocsp(), and CWebServiceWinInet::~CWebServiceWinInet().

InternetCombineUrlA()

BOOL WINAPI InternetCombineUrlA	(	LPCSTR	lpszBaseUrl,
		LPCSTR	lpszRelativeUrl,
		LPSTR	lpszBuffer,
		LPDWORD	lpdwBufferLength,
		DWORD	dwFlags
	)

Definition at line 4740 of file internet.c.

{
    HRESULT hr=S_OK;
 
    TRACE("(%s, %s, %p, %p, 0x%08lx)\n", debugstr_a(lpszBaseUrl), debugstr_a(lpszRelativeUrl), lpszBuffer, lpdwBufferLength, dwFlags);
 
    /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
    dwFlags ^= ICU_NO_ENCODE;
    hr=UrlCombineA(lpszBaseUrl,lpszRelativeUrl,lpszBuffer,lpdwBufferLength,dwFlags);
 
    return (hr==S_OK);
}

InternetCombineUrlW()

BOOL WINAPI InternetCombineUrlW	(	LPCWSTR	lpszBaseUrl,
		LPCWSTR	lpszRelativeUrl,
		LPWSTR	lpszBuffer,
		LPDWORD	lpdwBufferLength,
		DWORD	dwFlags
	)

Definition at line 4766 of file internet.c.

{
    HRESULT hr=S_OK;
 
    TRACE("(%s, %s, %p, %p, 0x%08lx)\n", debugstr_w(lpszBaseUrl), debugstr_w(lpszRelativeUrl), lpszBuffer, lpdwBufferLength, dwFlags);
 
    /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
    dwFlags ^= ICU_NO_ENCODE;
    hr=UrlCombineW(lpszBaseUrl,lpszRelativeUrl,lpszBuffer,lpdwBufferLength,dwFlags);
 
    return (hr==S_OK);
}

Referenced by get_redirect_url().

InternetConfirmZoneCrossingA()

DWORD WINAPI InternetConfirmZoneCrossingA	(	HWND	hWnd,
		LPSTR	szUrlPrev,
		LPSTR	szUrlNew,
		BOOL	bPost
	)

Definition at line 5177 of file internet.c.

{
    FIXME("(%p, %s, %s, %x) stub\n", hWnd, debugstr_a(szUrlPrev), debugstr_a(szUrlNew), bPost);
    return ERROR_SUCCESS;
}

InternetConfirmZoneCrossingW()

DWORD WINAPI InternetConfirmZoneCrossingW	(	HWND	hWnd,
		LPWSTR	szUrlPrev,
		LPWSTR	szUrlNew,
		BOOL	bPost
	)

Definition at line 5187 of file internet.c.

{
    FIXME("(%p, %s, %s, %x) stub\n", hWnd, debugstr_w(szUrlPrev), debugstr_w(szUrlNew), bPost);
    return ERROR_SUCCESS;
}

InternetConnectA()

HINTERNET WINAPI InternetConnectA	(	HINTERNET	hInternet,
		LPCSTR	lpszServerName,
		INTERNET_PORT	nServerPort,
		LPCSTR	lpszUserName,
		LPCSTR	lpszPassword,
		DWORD	dwService,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 1748 of file internet.c.

{
    HINTERNET rc = NULL;
    LPWSTR szServerName;
    LPWSTR szUserName;
    LPWSTR szPassword;
 
    szServerName = strdupAtoW(lpszServerName);
    szUserName = strdupAtoW(lpszUserName);
    szPassword = strdupAtoW(lpszPassword);
 
    rc = InternetConnectW(hInternet, szServerName, nServerPort,
        szUserName, szPassword, dwService, dwFlags, dwContext);
 
    free(szServerName);
    free(szUserName);
    free(szPassword);
    return rc;
}

Referenced by _open_simple_request(), can_do_https(), CWebServiceWinInet::DoRequest(), HttpHeaders_test(), HttpSendRequestEx_test(), InternetOpenRequest_test(), InternetReadFile_chunked_test(), InternetReadFile_test(), InternetReadFileExA_test(), InternetSetFilePointer_test(), open_socket_request(), START_TEST(), test_accept_encoding(), test_async_HttpSendRequestEx(), test_async_read(), test_basic_auth_credentials_cached_manual(), test_basic_auth_credentials_different(), test_basic_auth_credentials_end_session(), test_basic_auth_credentials_manual(), test_basic_auth_credentials_reuse(), test_basic_authentication(), test_bogus_accept_types_array(), test_cache_control_verb(), test_cache_read(), test_cache_read_gzipped(), test_cert_string(), test_concurrent_header_access(), test_conn_close(), test_connect(), test_connection_closing(), test_connection_header(), test_cookie_header(), test_default_service_port(), test_header_handling_order(), test_header_override(), test_http_cache(), test_HttpSendRequestW(), test_InternetCloseHandle(), test_InternetErrorDlg(), test_InternetQueryOptionA(), test_InternetSetOption(), test_large_header(), test_no_cache(), test_no_content(), test_not_modified(), test_options(), test_proxy_direct(), test_secure_connection(), test_security_flags(), test_status_callbacks(), test_successive_HttpSendRequest(), and test_user_agent_header().

InternetConnectW()

HINTERNET WINAPI InternetConnectW	(	HINTERNET	hInternet,
		LPCWSTR	lpszServerName,
		INTERNET_PORT	nServerPort,
		LPCWSTR	lpszUserName,
		LPCWSTR	lpszPassword,
		DWORD	dwService,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 1685 of file internet.c.

{
    appinfo_t *hIC;
    HINTERNET rc = NULL;
    DWORD res = ERROR_SUCCESS;
 
    TRACE("(%p, %s, %u, %s, %p, %lu, %lx, %Ix)\n", hInternet, debugstr_w(lpszServerName),
          nServerPort, debugstr_w(lpszUserName), lpszPassword, dwService, dwFlags, dwContext);
 
    if (!lpszServerName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    hIC = (appinfo_t*)get_handle_object( hInternet );
    if ( (hIC == NULL) || (hIC->hdr.htype != WH_HINIT) )
    {
        res = ERROR_INVALID_HANDLE;
        goto lend;
    }
 
    switch (dwService)
    {
        case INTERNET_SERVICE_FTP:
            rc = FTP_Connect(hIC, lpszServerName, nServerPort,
            lpszUserName, lpszPassword, dwFlags, dwContext, 0);
            if(!rc)
                res = INTERNET_GetLastError();
            break;
 
        case INTERNET_SERVICE_HTTP:
        res = HTTP_Connect(hIC, lpszServerName, nServerPort,
                    lpszUserName, lpszPassword, dwFlags, dwContext, 0, &rc);
            break;
 
        case INTERNET_SERVICE_GOPHER:
        default:
            break;
    }
lend:
    if( hIC )
        WININET_Release( &hIC->hdr );
 
    TRACE("returning %p\n", rc);
    SetLastError(res);
    return rc;
}

Referenced by CRYPT_Connect(), HttpProtocol_open_request(), InternetConnectA(), rpcrt4_http_internet_connect(), test_null(), test_secure_connection(), and verify_cert_revocation_with_ocsp().

InternetCrackUrlA()

BOOL WINAPI InternetCrackUrlA	(	const char *	url,
		DWORD	url_length,
		DWORD	flags,
		URL_COMPONENTSA *	ret_comp
	)

Definition at line 1933 of file internet.c.

{
    WCHAR *host = NULL, *user = NULL, *pass = NULL, *path = NULL, *scheme = NULL, *extra = NULL;
    URL_COMPONENTSW comp;
    WCHAR *url_w = NULL;
    BOOL ret;
 
    TRACE("(%s %lu %lx %p)\n", url_length ? debugstr_an(url, url_length) : debugstr_a(url), url_length, flags, ret_comp);
 
    if (!url || !*url || !ret_comp || ret_comp->dwStructSize != sizeof(URL_COMPONENTSA)) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    comp.dwStructSize = sizeof(comp);
 
    ret = set_url_component_AtoW(ret_comp->lpszHostName, ret_comp->dwHostNameLength,
                                 &comp.lpszHostName, &comp.dwHostNameLength, &host)
        && set_url_component_AtoW(ret_comp->lpszUserName, ret_comp->dwUserNameLength,
                                  &comp.lpszUserName, &comp.dwUserNameLength, &user)
        && set_url_component_AtoW(ret_comp->lpszPassword, ret_comp->dwPasswordLength,
                                  &comp.lpszPassword, &comp.dwPasswordLength, &pass)
        && set_url_component_AtoW(ret_comp->lpszUrlPath, ret_comp->dwUrlPathLength,
                                  &comp.lpszUrlPath, &comp.dwUrlPathLength, &path)
        && set_url_component_AtoW(ret_comp->lpszScheme, ret_comp->dwSchemeLength,
                                  &comp.lpszScheme, &comp.dwSchemeLength, &scheme)
        && set_url_component_AtoW(ret_comp->lpszExtraInfo, ret_comp->dwExtraInfoLength,
                                  &comp.lpszExtraInfo, &comp.dwExtraInfoLength, &extra);
 
    if(ret && !(url_w = strndupAtoW(url, url_length ? url_length : -1, &url_length))) {
        SetLastError(ERROR_OUTOFMEMORY);
        ret = FALSE;
    }
 
    if (ret && (ret = InternetCrackUrlW(url_w, url_length, flags, &comp))) {
        ret_comp->nScheme = comp.nScheme;
        ret_comp->nPort = comp.nPort;
 
        ret = set_url_component_WtoA(comp.lpszHostName, comp.dwHostNameLength, url_w,
                                     &ret_comp->lpszHostName, &ret_comp->dwHostNameLength, url)
            && set_url_component_WtoA(comp.lpszUserName, comp.dwUserNameLength, url_w,
                                      &ret_comp->lpszUserName, &ret_comp->dwUserNameLength, url)
            && set_url_component_WtoA(comp.lpszPassword, comp.dwPasswordLength, url_w,
                                      &ret_comp->lpszPassword, &ret_comp->dwPasswordLength, url)
            && set_url_component_WtoA(comp.lpszUrlPath, comp.dwUrlPathLength, url_w,
                                      &ret_comp->lpszUrlPath, &ret_comp->dwUrlPathLength, url)
            && set_url_component_WtoA(comp.lpszScheme, comp.dwSchemeLength, url_w,
                                      &ret_comp->lpszScheme, &ret_comp->dwSchemeLength, url)
            && set_url_component_WtoA(comp.lpszExtraInfo, comp.dwExtraInfoLength, url_w,
                                      &ret_comp->lpszExtraInfo, &ret_comp->dwExtraInfoLength, url);
 
        if(ret)
            TRACE("%s: scheme(%s) host(%s) path(%s) extra(%s)\n", debugstr_a(url),
                  debugstr_an(ret_comp->lpszScheme, ret_comp->dwSchemeLength),
                  debugstr_an(ret_comp->lpszHostName, ret_comp->dwHostNameLength),
                  debugstr_an(ret_comp->lpszUrlPath, ret_comp->dwUrlPathLength),
                  debugstr_an(ret_comp->lpszExtraInfo, ret_comp->dwExtraInfoLength));
    }
 
    free(host);
    free(user);
    free(pass);
    free(path);
    free(scheme);
    free(extra);
    free(url_w);
    return ret;
}

Referenced by InternetCrackUrl_test(), test_crack_url(), test_long_url(), urlcache_decode_url(), and urlcache_entry_create().

InternetCrackUrlW()

BOOL WINAPI InternetCrackUrlW	(	const WCHAR *	lpszUrl,
		DWORD	dwUrlLength,
		DWORD	dwFlags,
		URL_COMPONENTSW *	lpUC
	)

Definition at line 2052 of file internet.c.

{
  /*
   * RFC 1808
   * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
   *
   */
    LPCWSTR lpszParam    = NULL;
    BOOL  found_colon = FALSE;
    LPCWSTR lpszap;
    LPCWSTR lpszcp = NULL, lpszNetLoc;
 
    TRACE("(%s %lu %lx %p)\n",
          lpszUrl ? debugstr_wn(lpszUrl, dwUrlLength ? dwUrlLength : lstrlenW(lpszUrl)) : "(null)",
          dwUrlLength, dwFlags, lpUC);
 
    if (!lpszUrl || !*lpszUrl || !lpUC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (!dwUrlLength)
        dwUrlLength = lstrlenW(lpszUrl);
    else {
        /* Windows stops at a null, regardless of what dwUrlLength says. */
        dwUrlLength = wcsnlen(lpszUrl, dwUrlLength);
    }
 
    if (dwFlags & ICU_DECODE)
    {
        WCHAR *url_tmp, *buffer;
        DWORD len = dwUrlLength + 1;
        BOOL ret;
 
        if (!(url_tmp = strndupW(lpszUrl, dwUrlLength)))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
 
        buffer = url_tmp;
        ret = InternetCanonicalizeUrlW(url_tmp, buffer, &len, ICU_DECODE | ICU_NO_ENCODE);
        if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
        {
            buffer = malloc(len * sizeof(WCHAR));
            if (!buffer)
            {
                SetLastError(ERROR_OUTOFMEMORY);
                free(url_tmp);
                return FALSE;
            }
            ret = InternetCanonicalizeUrlW(url_tmp, buffer, &len, ICU_DECODE | ICU_NO_ENCODE);
        }
        if (ret)
            ret = InternetCrackUrlW(buffer, len, dwFlags & ~ICU_DECODE, lpUC);
 
        if (buffer != url_tmp) free(buffer);
        free(url_tmp);
        return ret;
    }
    lpszap = lpszUrl;
    
    /* Determine if the URI is absolute. */
    while (lpszap - lpszUrl < dwUrlLength)
    {
        if (iswalnum(*lpszap) || *lpszap == '+' || *lpszap == '.' || *lpszap == '-')
        {
            lpszap++;
            continue;
        }
        if (*lpszap == ':')
        {
            found_colon = TRUE;
            lpszcp = lpszap;
        }
        else
        {
            lpszcp = lpszUrl; /* Relative url */
        }
 
        break;
    }
 
    if(!found_colon){
        SetLastError(ERROR_INTERNET_UNRECOGNIZED_SCHEME);
        return FALSE;
    }
 
    lpUC->nScheme = INTERNET_SCHEME_UNKNOWN;
    lpUC->nPort = INTERNET_INVALID_PORT_NUMBER;
 
    /* Parse <params> */
    lpszParam = wmemchr(lpszap, '?', dwUrlLength - (lpszap - lpszUrl));
    if(!lpszParam)
        lpszParam = wmemchr(lpszap, '#', dwUrlLength - (lpszap - lpszUrl));
 
    if(!set_url_component(&lpUC->lpszExtraInfo, &lpUC->dwExtraInfoLength,
                          lpszParam, lpszParam ? dwUrlLength-(lpszParam-lpszUrl) : 0))
        return FALSE;
 
 
    /* Get scheme first. */
    lpUC->nScheme = GetInternetSchemeW(lpszUrl, lpszcp - lpszUrl);
    if(!set_url_component(&lpUC->lpszScheme, &lpUC->dwSchemeLength, lpszUrl, lpszcp - lpszUrl))
        return FALSE;
 
    /* Eat ':' in protocol. */
    lpszcp++;
 
    /* double slash indicates the net_loc portion is present */
    if ((lpszcp[0] == '/') && (lpszcp[1] == '/'))
    {
        lpszcp += 2;
 
        lpszNetLoc = wmemchr(lpszcp, '/', dwUrlLength - (lpszcp - lpszUrl));
        if (lpszParam)
        {
            if (lpszNetLoc)
                lpszNetLoc = min(lpszNetLoc, lpszParam);
            else
                lpszNetLoc = lpszParam;
        }
        else if (!lpszNetLoc)
            lpszNetLoc = lpszcp + dwUrlLength-(lpszcp-lpszUrl);
 
        /* Parse net-loc */
        if (lpszNetLoc)
        {
            LPCWSTR lpszHost;
            LPCWSTR lpszPort;
 
            /* [<user>[<:password>]@]<host>[:<port>] */
            /* First find the user and password if they exist */
 
            lpszHost = wmemchr(lpszcp, '@', dwUrlLength - (lpszcp - lpszUrl));
            if (lpszHost == NULL || lpszHost > lpszNetLoc)
            {
                /* username and password not specified. */
                set_url_component(&lpUC->lpszUserName, &lpUC->dwUserNameLength, NULL, 0);
                set_url_component(&lpUC->lpszPassword, &lpUC->dwPasswordLength, NULL, 0);
            }
            else /* Parse out username and password */
            {
                LPCWSTR lpszUser = lpszcp;
                LPCWSTR lpszPasswd = lpszHost;
 
                while (lpszcp < lpszHost)
                {
                    if (*lpszcp == ':')
                        lpszPasswd = lpszcp;
 
                    lpszcp++;
                }
 
                if(!set_url_component(&lpUC->lpszUserName, &lpUC->dwUserNameLength, lpszUser, lpszPasswd - lpszUser))
                    return FALSE;
 
                if (lpszPasswd != lpszHost)
                    lpszPasswd++;
                if(!set_url_component(&lpUC->lpszPassword, &lpUC->dwPasswordLength,
                                      lpszPasswd == lpszHost ? NULL : lpszPasswd, lpszHost - lpszPasswd))
                    return FALSE;
 
                lpszcp++; /* Advance to beginning of host */
            }
 
            /* Parse <host><:port> */
 
            lpszHost = lpszcp;
            lpszPort = lpszNetLoc;
 
            /* special case for res:// URLs: there is no port here, so the host is the
               entire string up to the first '/' */
            if(lpUC->nScheme==INTERNET_SCHEME_RES)
            {
                if(!set_url_component(&lpUC->lpszHostName, &lpUC->dwHostNameLength, lpszHost, lpszPort - lpszHost))
                    return FALSE;
                lpszcp=lpszNetLoc;
            }
            else
            {
                while (lpszcp < lpszNetLoc)
                {
                    if (*lpszcp == ':')
                        lpszPort = lpszcp;
 
                    lpszcp++;
                }
 
                /* If the scheme is "file" and the host is just one letter, it's not a host */
                if(lpUC->nScheme==INTERNET_SCHEME_FILE && lpszPort <= lpszHost+1)
                {
                    lpszcp=lpszHost;
                    set_url_component(&lpUC->lpszHostName, &lpUC->dwHostNameLength, NULL, 0);
                }
                else
                {
                    if(!set_url_component(&lpUC->lpszHostName, &lpUC->dwHostNameLength, lpszHost, lpszPort - lpszHost))
                        return FALSE;
                    if (lpszPort != lpszNetLoc)
                        lpUC->nPort = wcstol(++lpszPort, NULL, 10);
                    else switch (lpUC->nScheme)
                    {
                    case INTERNET_SCHEME_HTTP:
                        lpUC->nPort = INTERNET_DEFAULT_HTTP_PORT;
                        break;
                    case INTERNET_SCHEME_HTTPS:
                        lpUC->nPort = INTERNET_DEFAULT_HTTPS_PORT;
                        break;
                    case INTERNET_SCHEME_FTP:
                        lpUC->nPort = INTERNET_DEFAULT_FTP_PORT;
                        break;
                    default:
                        break;
                    }
                }
            }
        }
    }
    else
    {
        set_url_component(&lpUC->lpszUserName, &lpUC->dwUserNameLength, NULL, 0);
        set_url_component(&lpUC->lpszPassword, &lpUC->dwPasswordLength, NULL, 0);
        set_url_component(&lpUC->lpszHostName, &lpUC->dwHostNameLength, NULL, 0);
    }
 
    /* Here lpszcp points to:
     *
     * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
     *                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     */
    if (lpszcp != 0 && lpszcp - lpszUrl < dwUrlLength && (!lpszParam || lpszcp <= lpszParam))
    {
        DWORD len;
 
        /* Only truncate the parameter list if it's already been saved
         * in lpUC->lpszExtraInfo.
         */
        if (lpszParam && lpUC->dwExtraInfoLength && lpUC->lpszExtraInfo)
            len = lpszParam - lpszcp;
        else
        {
            /* Leave the parameter list in lpszUrlPath.  Strip off any trailing
             * newlines if necessary.
             */
            LPWSTR lpsznewline = wmemchr(lpszcp, '\n', dwUrlLength - (lpszcp - lpszUrl));
            if (lpsznewline != NULL)
                len = lpsznewline - lpszcp;
            else
                len = dwUrlLength-(lpszcp-lpszUrl);
        }
        if (lpUC->dwUrlPathLength && lpUC->lpszUrlPath &&
                lpUC->nScheme == INTERNET_SCHEME_FILE)
        {
            WCHAR tmppath[MAX_PATH];
            if (*lpszcp == '/')
            {
                len = MAX_PATH;
                PathCreateFromUrlW(lpszUrl, tmppath, &len, 0);
            }
            else
            {
                WCHAR *iter;
                memcpy(tmppath, lpszcp, len * sizeof(WCHAR));
                tmppath[len] = '\0';
 
                iter = tmppath;
                while (*iter) {
                    if (*iter == '/')
                        *iter = '\\';
                    ++iter;
                }
            }
            /* if ends in \. or \.. append a backslash */
            if (tmppath[len - 1] == '.' &&
                    (tmppath[len - 2] == '\\' ||
                     (tmppath[len - 2] == '.' && tmppath[len - 3] == '\\')))
            {
                if (len < MAX_PATH - 1)
                {
                    tmppath[len] = '\\';
                    tmppath[len+1] = '\0';
                    ++len;
                }
            }
            if(!set_url_component(&lpUC->lpszUrlPath, &lpUC->dwUrlPathLength, tmppath, len))
                return FALSE;
        }
        else if(!set_url_component(&lpUC->lpszUrlPath, &lpUC->dwUrlPathLength, lpszcp, len))
            return FALSE;
    }
    else
    {
        set_url_component(&lpUC->lpszUrlPath, &lpUC->dwUrlPathLength, lpszcp, 0);
    }
 
    TRACE("%s: scheme(%s) host(%s) path(%s) extra(%s)\n", debugstr_wn(lpszUrl,dwUrlLength),
             debugstr_wn(lpUC->lpszScheme,lpUC->dwSchemeLength),
             debugstr_wn(lpUC->lpszHostName,lpUC->dwHostNameLength),
             debugstr_wn(lpUC->lpszUrlPath,lpUC->dwUrlPathLength),
             debugstr_wn(lpUC->lpszExtraInfo,lpUC->dwExtraInfoLength));
 
    return TRUE;
}

Referenced by cookie_parse_url(), CRYPT_CrackUrl(), CRYPT_GetRetrieveFunction(), File_RetrieveEncodedObjectW(), get_redirect_url(), get_url_components(), HTTP_DealWithProxy(), HTTP_HandleRedirect(), INTERNET_InternetOpenUrlW(), InternetCheckConnectionW(), InternetCrackUrlA(), InternetCrackUrlW(), InternetCrackUrlW_test(), InternetGetSecurityInfoByURLW(), IsUrlValid(), parse_proxy_url(), CDownloadManager::PerformDownloadAndInstall(), test_crack_url(), urlcache_encode_url(), and verify_cert_revocation_with_ocsp().

InternetCreateUrlA()

BOOL WINAPI InternetCreateUrlA	(	LPURL_COMPONENTSA	lpUrlComponents,
		DWORD	dwFlags,
		LPSTR	lpszUrl,
		LPDWORD	lpdwUrlLength
	)

Definition at line 4986 of file internet.c.

{
    BOOL ret;
    LPWSTR urlW = NULL;
    URL_COMPONENTSW urlCompW;
 
    TRACE("(%p,%ld,%p,%p)\n", lpUrlComponents, dwFlags, lpszUrl, lpdwUrlLength);
 
    if (!lpUrlComponents || lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    convert_urlcomp_atow(lpUrlComponents, &urlCompW);
 
    if (lpszUrl)
        urlW = malloc(*lpdwUrlLength * sizeof(WCHAR));
 
    ret = InternetCreateUrlW(&urlCompW, dwFlags, urlW, lpdwUrlLength);
 
    if (!ret && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
        *lpdwUrlLength /= sizeof(WCHAR);
 
    /* on success, lpdwUrlLength points to the size of urlW in WCHARS
    * minus one, so add one to leave room for NULL terminator
    */
    if (ret)
        WideCharToMultiByte(CP_ACP, 0, urlW, -1, lpszUrl, *lpdwUrlLength + 1, NULL, NULL);
 
    free(urlCompW.lpszScheme);
    free(urlCompW.lpszHostName);
    free(urlCompW.lpszUserName);
    free(urlCompW.lpszPassword);
    free(urlCompW.lpszUrlPath);
    free(urlCompW.lpszExtraInfo);
    free(urlW);
    return ret;
}

Referenced by InternetCreateUrlA_test().

InternetCreateUrlW()

BOOL WINAPI InternetCreateUrlW	(	LPURL_COMPONENTSW	lpUrlComponents,
		DWORD	dwFlags,
		LPWSTR	lpszUrl,
		LPDWORD	lpdwUrlLength
	)

Definition at line 5050 of file internet.c.

{
    DWORD dwLen;
    INTERNET_SCHEME nScheme;
 
    static const WCHAR slashSlashW[] = {'/','/'};
 
    TRACE("(%p,%ld,%p,%p)\n", lpUrlComponents, dwFlags, lpszUrl, lpdwUrlLength);
 
    if (!lpUrlComponents || lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (!calc_url_length(lpUrlComponents, &dwLen))
        return FALSE;
 
    if (!lpszUrl || *lpdwUrlLength < dwLen)
    {
        *lpdwUrlLength = (dwLen + 1) * sizeof(WCHAR);
        INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    *lpdwUrlLength = dwLen;
    lpszUrl[0] = 0x00;
 
    dwLen = 0;
 
    if (lpUrlComponents->lpszScheme)
    {
        dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Scheme);
        memcpy(lpszUrl, lpUrlComponents->lpszScheme, dwLen * sizeof(WCHAR));
        lpszUrl += dwLen;
 
        nScheme = GetInternetSchemeW(lpUrlComponents->lpszScheme, dwLen);
    }
    else
    {
        LPCWSTR scheme;
        nScheme = lpUrlComponents->nScheme;
 
        if (nScheme == INTERNET_SCHEME_DEFAULT)
            nScheme = INTERNET_SCHEME_HTTP;
 
        scheme = INTERNET_GetSchemeString(nScheme);
        dwLen = lstrlenW(scheme);
        memcpy(lpszUrl, scheme, dwLen * sizeof(WCHAR));
        lpszUrl += dwLen;
    }
 
    /* all schemes are followed by at least a colon */
    *lpszUrl = ':';
    lpszUrl++;
 
    if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName)
    {
        memcpy(lpszUrl, slashSlashW, sizeof(slashSlashW));
        lpszUrl += ARRAY_SIZE(slashSlashW);
    }
 
    if (lpUrlComponents->lpszUserName)
    {
        dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UserName);
        memcpy(lpszUrl, lpUrlComponents->lpszUserName, dwLen * sizeof(WCHAR));
        lpszUrl += dwLen;
 
        if (lpUrlComponents->lpszPassword)
        {
            *lpszUrl = ':';
            lpszUrl++;
 
            dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Password);
            memcpy(lpszUrl, lpUrlComponents->lpszPassword, dwLen * sizeof(WCHAR));
            lpszUrl += dwLen;
        }
 
        *lpszUrl = '@';
        lpszUrl++;
    }
 
    if (lpUrlComponents->lpszHostName)
    {
        dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, HostName);
        memcpy(lpszUrl, lpUrlComponents->lpszHostName, dwLen * sizeof(WCHAR));
        lpszUrl += dwLen;
 
        if (!url_uses_default_port(nScheme, lpUrlComponents->nPort))
        {
            *lpszUrl++ = ':';
            _ltow(lpUrlComponents->nPort, lpszUrl, 10);
            lpszUrl += lstrlenW(lpszUrl);
        }
 
        /* add slash between hostname and path if necessary */
        if (lpUrlComponents->lpszUrlPath && *lpUrlComponents->lpszUrlPath != '/')
        {
            *lpszUrl = '/';
            lpszUrl++;
        }
    }
 
    if (lpUrlComponents->lpszUrlPath)
    {
        dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
        memcpy(lpszUrl, lpUrlComponents->lpszUrlPath, dwLen * sizeof(WCHAR));
        lpszUrl += dwLen;
    }
 
    if (lpUrlComponents->lpszExtraInfo)
    {
        dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, ExtraInfo);
        memcpy(lpszUrl, lpUrlComponents->lpszExtraInfo, dwLen * sizeof(WCHAR));
        lpszUrl += dwLen;
    }
 
    *lpszUrl = '\0';
 
    return TRUE;
}

Referenced by FTP_FtpOpenFileW(), get_redirect_url(), HTMLLocation_get_href(), InternetCreateUrlA(), and set_auth_cookie().

InternetDialA()

DWORD WINAPI InternetDialA	(	HWND	hwndParent,
		LPSTR	lpszConnectoid,
		DWORD	dwFlags,
		DWORD_PTR *	lpdwConnection,
		DWORD	dwReserved
	)

Definition at line 5281 of file internet.c.

{
    FIXME("(%p, %p, 0x%08lx, %p, 0x%08lx) stub\n", hwndParent, lpszConnectoid, dwFlags,
          lpdwConnection, dwReserved);
    return ERROR_SUCCESS;
}

InternetDialW()

DWORD WINAPI InternetDialW	(	HWND	hwndParent,
		LPWSTR	lpszConnectoid,
		DWORD	dwFlags,
		DWORD_PTR *	lpdwConnection,
		DWORD	dwReserved
	)

Definition at line 5289 of file internet.c.

{
    FIXME("(%p, %p, 0x%08lx, %p, 0x%08lx) stub\n", hwndParent, lpszConnectoid, dwFlags,
          lpdwConnection, dwReserved);
    return ERROR_SUCCESS;
}

InternetFindNextFileA()

BOOL WINAPI InternetFindNextFileA	(	HINTERNET	hFind,
		LPVOID	lpvFindData
	)

Definition at line 1782 of file internet.c.

{
    BOOL ret;
    WIN32_FIND_DATAW fd;
    
    ret = InternetFindNextFileW(hFind, lpvFindData?&fd:NULL);
    if(lpvFindData)
        WININET_find_data_WtoA(&fd, (LPWIN32_FIND_DATAA)lpvFindData);
    return ret;
}

InternetFindNextFileW()

BOOL WINAPI InternetFindNextFileW	(	HINTERNET	hFind,
		LPVOID	lpvFindData
	)

Definition at line 1803 of file internet.c.

{
    object_header_t *hdr;
    DWORD res;
 
    TRACE("\n");
 
    hdr = get_handle_object(hFind);
    if(!hdr) {
        WARN("Invalid handle\n");
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if(hdr->vtbl->FindNextFileW) {
        res = hdr->vtbl->FindNextFileW(hdr, lpvFindData);
    }else {
        WARN("Handle doesn't support NextFile\n");
        res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
    }
 
    WININET_Release(hdr);
 
    if(res != ERROR_SUCCESS)
        SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by InternetFindNextFileA().

InternetGetConnectedState()

BOOL WINAPI InternetGetConnectedState	(	LPDWORD	lpdwStatus,
		DWORD	dwReserved
	)

Definition at line 1534 of file internet.c.

{
    TRACE("(%p, 0x%08lx)\n", lpdwStatus, dwReserved);
 
    return InternetGetConnectedStateExW(lpdwStatus, NULL, 0, dwReserved);
}

InternetGetConnectedStateExA()

BOOL WINAPI InternetGetConnectedStateExA	(	LPDWORD	lpdwStatus,
		LPSTR	lpszConnectionName,
		DWORD	dwNameLen,
		DWORD	dwReserved
	)

Definition at line 1649 of file internet.c.

{
    LPWSTR lpwszConnectionName = NULL;
    BOOL rc;
 
    TRACE("(%p, %p, %ld, 0x%08lx)\n", lpdwStatus, lpszConnectionName, dwNameLen, dwReserved);
 
    if (lpszConnectionName && dwNameLen > 0)
        lpwszConnectionName = malloc(dwNameLen * sizeof(WCHAR));
 
    rc = InternetGetConnectedStateExW(lpdwStatus,lpwszConnectionName, dwNameLen,
                                      dwReserved);
    if (rc && lpwszConnectionName)
    {
        WideCharToMultiByte(CP_ACP,0,lpwszConnectionName,-1,lpszConnectionName,
                            dwNameLen, NULL, NULL);
        /* Yes, blindly truncate double-byte characters */
        lpszConnectionName[dwNameLen - 1] = '\0';
    }
 
    free(lpwszConnectionName);
    return rc;
}

InternetGetConnectedStateExW()

BOOL WINAPI InternetGetConnectedStateExW	(	LPDWORD	lpdwStatus,
		LPWSTR	lpszConnectionName,
		DWORD	dwNameLen,
		DWORD	dwReserved
	)

Definition at line 1569 of file internet.c.

{
    IP_ADAPTER_ADDRESSES *buf = NULL, *aa;
    ULONG size = 0;
    DWORD status;
 
    TRACE("(%p, %p, %ld, 0x%08lx)\n", lpdwStatus, lpszConnectionName, dwNameLen, dwReserved);
 
    /* Must be zero */
    if(dwReserved)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    for (;;)
    {
        ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER |
                      GAA_FLAG_SKIP_FRIENDLY_NAME | GAA_FLAG_INCLUDE_GATEWAYS;
        ULONG errcode = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, buf, &size);
 
        if (errcode == ERROR_SUCCESS)
            break;
        free(buf);
        if (errcode == ERROR_BUFFER_OVERFLOW && !(buf = malloc(size)))
            errcode = ERROR_NOT_ENOUGH_MEMORY;
        if (errcode != ERROR_BUFFER_OVERFLOW)
        {
            if (errcode != ERROR_NO_DATA)
            {
                SetLastError(errcode);
                return FALSE;
            }
            buf = NULL;
            break;
        }
    }
 
    status = INTERNET_RAS_INSTALLED;
    for (aa = buf; aa; aa = aa->Next)
    {
        /* Connected, but not necessarily to internet */
        if (aa->FirstUnicastAddress)
            status |= INTERNET_CONNECTION_OFFLINE;
 
        /* Connected to internet */
        if (aa->FirstGatewayAddress)
        {
            WARN("always returning LAN connection.\n");
            status &= ~INTERNET_CONNECTION_OFFLINE;
            status |= INTERNET_CONNECTION_LAN;
            break;
        }
    }
    free(buf);
 
    if (lpdwStatus) *lpdwStatus = status;
 
    /* When the buffer size is zero LoadStringW fills the buffer with a pointer to
     * the resource, avoid it as we must not change the buffer in this case */
    if (lpszConnectionName && dwNameLen)
    {
        *lpszConnectionName = '\0';
        if (status & INTERNET_CONNECTION_LAN)
            LoadStringW(WININET_hModule, IDS_LANCONNECTION, lpszConnectionName, dwNameLen);
    }
 
    if (!(status & (INTERNET_CONNECTION_LAN | INTERNET_CONNECTION_MODEM | INTERNET_CONNECTION_PROXY)))
    {
        SetLastError(ERROR_SUCCESS);
        return FALSE;
    }
    return TRUE;
}

Referenced by InternetGetConnectedState(), and InternetGetConnectedStateExA().

InternetGetLastResponseInfoA()

BOOL WINAPI InternetGetLastResponseInfoA	(	LPDWORD	lpdwError,
		LPSTR	lpszBuffer,
		LPDWORD	lpdwBufferLength
	)

Definition at line 1442 of file internet.c.

{
    LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
 
    TRACE("(%p, %p, %p)\n", lpdwError, lpszBuffer, lpdwBufferLength);
 
    if (!lpdwError || !lpdwBufferLength)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (lpwite)
    {
        if (lpszBuffer == NULL || *lpdwBufferLength < strlen(lpwite->response))
        {
            *lpdwBufferLength = strlen(lpwite->response);
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return FALSE;
        }
        *lpdwError = lpwite->dwError;
        if (*lpdwBufferLength)
        {
            memcpy(lpszBuffer, lpwite->response, *lpdwBufferLength);
            lpszBuffer[*lpdwBufferLength - 1] = 0;
            *lpdwBufferLength = strlen(lpszBuffer);
        }
    }
    else
    {
        *lpdwError = 0;
        *lpdwBufferLength = 0;
    }
 
    return TRUE;
}

Referenced by test_command(), and trace_extended_error().

InternetGetLastResponseInfoW()

BOOL WINAPI InternetGetLastResponseInfoW	(	LPDWORD	lpdwError,
		LPWSTR	lpszBuffer,
		LPDWORD	lpdwBufferLength
	)

Definition at line 1489 of file internet.c.

{
    LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
 
    TRACE("(%p, %p, %p)\n", lpdwError, lpszBuffer, lpdwBufferLength);
 
    if (!lpdwError || !lpdwBufferLength)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (lpwite)
    {
        int required_size = MultiByteToWideChar(CP_ACP, 0, lpwite->response, -1, NULL, 0) - 1;
        if (lpszBuffer == NULL || *lpdwBufferLength < required_size)
        {
            *lpdwBufferLength = required_size;
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return FALSE;
        }
        *lpdwError = lpwite->dwError;
        if (*lpdwBufferLength)
            *lpdwBufferLength = MultiByteToWideChar(CP_ACP, 0, lpwite->response, -1, lpszBuffer, *lpdwBufferLength);
    }
    else
    {
        *lpdwError = 0;
        *lpdwBufferLength = 0;
    }
 
    return TRUE;
}

InternetGetSecurityInfoByURLA()

BOOL WINAPI InternetGetSecurityInfoByURLA	(	LPSTR	lpszURL,
		PCCERT_CHAIN_CONTEXT *	ppCertChain,
		DWORD *	pdwSecureFlags
	)

Definition at line 5221 of file internet.c.

{
    WCHAR *url;
    BOOL res;
 
    TRACE("(%s %p %p)\n", debugstr_a(lpszURL), ppCertChain, pdwSecureFlags);
 
    url = strdupAtoW(lpszURL);
    if(!url)
        return FALSE;
 
    res = InternetGetSecurityInfoByURLW(url, ppCertChain, pdwSecureFlags);
    free(url);
    return res;
}

InternetGetSecurityInfoByURLW()

BOOL WINAPI InternetGetSecurityInfoByURLW	(	LPCWSTR	lpszURL,
		PCCERT_CHAIN_CONTEXT *	ppCertChain,
		DWORD *	pdwSecureFlags
	)

Definition at line 5240 of file internet.c.

{
    URL_COMPONENTSW url = {sizeof(url)};
    server_t *server;
    BOOL res;
 
    TRACE("(%s %p %p)\n", debugstr_w(lpszURL), ppCertChain, pdwSecureFlags);
 
    if (!ppCertChain && !pdwSecureFlags) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    url.dwHostNameLength = 1;
    res = InternetCrackUrlW(lpszURL, 0, 0, &url);
    if(!res || url.nScheme != INTERNET_SCHEME_HTTPS) {
        SetLastError(ERROR_INTERNET_ITEM_NOT_FOUND);
        return FALSE;
    }
 
    server = get_server(substr(url.lpszHostName, url.dwHostNameLength), url.nPort, TRUE, FALSE);
    if(!server) {
        SetLastError(ERROR_INTERNET_ITEM_NOT_FOUND);
        return FALSE;
    }
 
    if(server->cert_chain) {
        if(pdwSecureFlags)
            *pdwSecureFlags = server->security_flags & _SECURITY_ERROR_FLAGS_MASK;
 
        if(ppCertChain && !(*ppCertChain = CertDuplicateCertificateChain(server->cert_chain)))
            res = FALSE;
    }else {
        SetLastError(ERROR_INTERNET_ITEM_NOT_FOUND);
        res = FALSE;
    }
 
    server_release(server);
    return res;
}

Referenced by InternetGetSecurityInfoByURLA().

InternetGoOnlineA()

BOOL WINAPI InternetGoOnlineA	(	LPSTR	lpszURL,
		HWND	hwndParent,
		DWORD	dwReserved
	)

Definition at line 5297 of file internet.c.

{
    FIXME("(%s, %p, 0x%08lx) stub\n", debugstr_a(lpszURL), hwndParent, dwReserved);
    return TRUE;
}

InternetGoOnlineW()

BOOL WINAPI InternetGoOnlineW	(	LPWSTR	lpszURL,
		HWND	hwndParent,
		DWORD	dwReserved
	)

Definition at line 5303 of file internet.c.

{
    FIXME("(%s, %p, 0x%08lx) stub\n", debugstr_w(lpszURL), hwndParent, dwReserved);
    return TRUE;
}

InternetHangUp()

DWORD WINAPI InternetHangUp	(	DWORD_PTR	dwConnection,
		DWORD	dwReserved
	)

Definition at line 5309 of file internet.c.

{
    FIXME("(0x%08Ix, 0x%08lx) stub\n", dwConnection, dwReserved);
    return ERROR_SUCCESS;
}

InternetInitializeAutoProxyDll()

BOOL WINAPI InternetInitializeAutoProxyDll

(

DWORD

dwReserved

)

Definition at line 573 of file internet.c.

{
    FIXME("STUB\n");
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

InternetLockRequestFile()

BOOL WINAPI InternetLockRequestFile	(	HINTERNET	hInternet,
		HANDLE *	lphLockReqHandle
	)

Definition at line 4651 of file internet.c.

{
    req_file_t *req_file = NULL;
    object_header_t *hdr;
    DWORD res;
 
    TRACE("(%p %p)\n", hInternet, lphLockReqHandle);
 
    hdr = get_handle_object(hInternet);
    if (!hdr) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if(hdr->vtbl->LockRequestFile) {
        res = hdr->vtbl->LockRequestFile(hdr, &req_file);
    }else {
        WARN("wrong handle\n");
        res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
    }
 
    WININET_Release(hdr);
 
    *lphLockReqHandle = req_file;
    if(res != ERROR_SUCCESS)
        SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by InternetLockRequestFile_test(), and protocol_lock_request().

InternetOpenA()

HINTERNET WINAPI InternetOpenA	(	LPCSTR	lpszAgent,
		DWORD	dwAccessType,
		LPCSTR	lpszProxy,
		LPCSTR	lpszProxyBypass,
		DWORD	dwFlags
	)

Definition at line 1411 of file internet.c.

{
    WCHAR *szAgent, *szProxy, *szBypass;
    HINTERNET rc;
 
    TRACE("(%s, 0x%08lx, %s, %s, 0x%08lx)\n", debugstr_a(lpszAgent),
       dwAccessType, debugstr_a(lpszProxy), debugstr_a(lpszProxyBypass), dwFlags);
 
    szAgent = strdupAtoW(lpszAgent);
    szProxy = strdupAtoW(lpszProxy);
    szBypass = strdupAtoW(lpszProxyBypass);
 
    rc = InternetOpenW(szAgent, dwAccessType, szProxy, szBypass, dwFlags);
 
    free(szAgent);
    free(szProxy);
    free(szBypass);
    return rc;
}

Referenced by _open_simple_request(), can_do_https(), HttpHeaders_test(), HttpSendRequestEx_test(), InternetOpenRequest_test(), InternetOpenUrlA_test(), InternetReadFile_chunked_test(), InternetReadFile_test(), InternetReadFileExA_test(), InternetSetFilePointer_test(), open_socket_request(), START_TEST(), test_accept_encoding(), test_async_HttpSendRequestEx(), test_async_read(), test_basic_auth_credentials_cached_manual(), test_basic_auth_credentials_different(), test_basic_auth_credentials_end_session(), test_basic_auth_credentials_manual(), test_basic_auth_credentials_reuse(), test_basic_authentication(), test_bogus_accept_types_array(), test_cache_control_verb(), test_cache_read(), test_cache_read_gzipped(), test_cert_string(), test_concurrent_header_access(), test_conn_close(), test_connection_closing(), test_connection_header(), test_cookie_header(), test_default_service_port(), test_header_handling_order(), test_header_override(), test_http_cache(), test_HttpSendRequestW(), test_InternetCloseHandle(), test_InternetErrorDlg(), test_InternetQueryOptionA(), test_InternetSetOption(), test_large_header(), test_no_cache(), test_no_content(), test_not_modified(), test_open_url_async(), test_Option_PerConnectionOption(), test_Option_PerConnectionOptionA(), test_options(), test_proxy_direct(), test_secure_connection(), test_security_flags(), test_successive_HttpSendRequest(), and test_user_agent_header().

InternetOpenUrlA()

HINTERNET WINAPI InternetOpenUrlA	(	HINTERNET	hInternet,
		LPCSTR	lpszUrl,
		LPCSTR	lpszHeaders,
		DWORD	dwHeadersLength,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 4398 of file internet.c.

{
    HINTERNET rc = NULL;
    LPWSTR szUrl = NULL;
    WCHAR *headers = NULL;
 
    TRACE("\n");
 
    if(lpszUrl) {
        szUrl = strdupAtoW(lpszUrl);
        if(!szUrl)
            return NULL;
    }
 
    if(lpszHeaders) {
        headers = strndupAtoW(lpszHeaders, dwHeadersLength, &dwHeadersLength);
        if(!headers) {
            free(szUrl);
            return NULL;
        }
    }
    
    rc = InternetOpenUrlW(hInternet, szUrl, headers, dwHeadersLength, dwFlags, dwContext);
 
    free(szUrl);
    free(headers);
    return rc;
}

Referenced by InternetOpenUrlA_test(), and test_open_url_async().

InternetOpenUrlW()

HINTERNET WINAPI InternetOpenUrlW	(	HINTERNET	hInternet,
		LPCWSTR	lpszUrl,
		LPCWSTR	lpszHeaders,
		DWORD	dwHeadersLength,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 4341 of file internet.c.

{
    HINTERNET ret = NULL;
    appinfo_t *hIC = NULL;
 
    if (TRACE_ON(wininet)) {
    TRACE("(%p, %s, %s, %08lx, %08lx, %08Ix)\n", hInternet, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
          dwHeadersLength, dwFlags, dwContext);
    TRACE("  flags :");
    dump_INTERNET_FLAGS(dwFlags);
    }
 
    if (!lpszUrl)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    hIC = (appinfo_t*)get_handle_object( hInternet );
    if (NULL == hIC ||  hIC->hdr.htype != WH_HINIT) {
    SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
    goto lend;
    }
    
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC) {
    open_url_task_t *task;
 
        task = alloc_async_task(&hIC->hdr, AsyncInternetOpenUrlProc, sizeof(*task));
        task->url = wcsdup(lpszUrl);
        task->headers = wcsdup(lpszHeaders);
        task->headers_len = dwHeadersLength;
        task->flags = dwFlags;
        task->context = dwContext;
    
        INTERNET_AsyncCall(&task->hdr);
        SetLastError(ERROR_IO_PENDING);
    } else {
    ret = INTERNET_InternetOpenUrlW(hIC, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext);
    }
    
  lend:
    if( hIC )
        WININET_Release( &hIC->hdr );
    TRACE(" %p <--\n", ret);
    
    return ret;
}

Referenced by AsyncInetDownload(), FtpProtocol_open_request(), GopherProtocol_open_request(), InternetOpenUrlA(), CDownloadManager::PerformDownloadAndInstall(), and test_null().

InternetOpenW()

HINTERNET WINAPI InternetOpenW	(	LPCWSTR	lpszAgent,
		DWORD	dwAccessType,
		LPCWSTR	lpszProxy,
		LPCWSTR	lpszProxyBypass,
		DWORD	dwFlags
	)

Definition at line 1334 of file internet.c.

{
    appinfo_t *lpwai = NULL;
 
#ifdef __REACTOS__
    init_winsock();
#endif
    if (TRACE_ON(wininet)) {
#define FE(x) { x, #x }
    static const wininet_flag_info access_type[] = {
        FE(INTERNET_OPEN_TYPE_PRECONFIG),
        FE(INTERNET_OPEN_TYPE_DIRECT),
        FE(INTERNET_OPEN_TYPE_PROXY),
        FE(INTERNET_OPEN_TYPE_PRECONFIG_WITH_NO_AUTOPROXY)
    };
#undef FE
    DWORD i;
    const char *access_type_str = "Unknown";
    
    TRACE("(%s, %li, %s, %s, %li)\n", debugstr_w(lpszAgent), dwAccessType,
          debugstr_w(lpszProxy), debugstr_w(lpszProxyBypass), dwFlags);
        for (i = 0; i < ARRAY_SIZE(access_type); i++) {
        if (access_type[i].val == dwAccessType) {
        access_type_str = access_type[i].name;
        break;
        }
    }
    TRACE("  access type : %s\n", access_type_str);
    TRACE("  flags       :");
    dump_INTERNET_FLAGS(dwFlags);
    }
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    if((dwAccessType == INTERNET_OPEN_TYPE_PROXY) && !lpszProxy) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    lpwai = alloc_object(NULL, &APPINFOVtbl, sizeof(appinfo_t));
    if (!lpwai) {
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
 
    lpwai->hdr.htype = WH_HINIT;
    lpwai->hdr.dwFlags = dwFlags;
    lpwai->accessType = dwAccessType;
    lpwai->proxyUsername = NULL;
    lpwai->proxyPassword = NULL;
 
    lpwai->agent = wcsdup(lpszAgent);
    if(dwAccessType == INTERNET_OPEN_TYPE_PRECONFIG)
        INTERNET_ConfigureProxy( lpwai );
    else if(dwAccessType == INTERNET_OPEN_TYPE_PROXY) {
        lpwai->proxy = wcsdup(lpszProxy);
        lpwai->proxyBypass = wcsdup(lpszProxyBypass);
    }
 
    TRACE("returning %p\n", lpwai);
 
    return lpwai->hdr.hInternet;
}

Referenced by AsyncInetDownload(), create_internet_session(), CRYPT_Connect(), CWebServiceWinInet::CWebServiceWinInet(), InternetOpenA(), CDownloadManager::PerformDownloadAndInstall(), rpcrt4_http_internet_connect(), test_null(), test_proxy_direct(), test_secure_connection(), and verify_cert_revocation_with_ocsp().

InternetQueryDataAvailable()

BOOL WINAPI InternetQueryDataAvailable	(	HINTERNET	hFile,
		LPDWORD	lpdwNumberOfBytesAvailable,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 4578 of file internet.c.

{
    object_header_t *hdr;
    DWORD res;
 
    TRACE("(%p %p %lx %Ix)\n", hFile, lpdwNumberOfBytesAvailable, dwFlags, dwContext);
 
    hdr = get_handle_object( hFile );
    if (!hdr) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if(hdr->vtbl->QueryDataAvailable) {
        res = hdr->vtbl->QueryDataAvailable(hdr, lpdwNumberOfBytesAvailable, dwFlags, dwContext);
    }else {
        WARN("wrong handle\n");
        res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
    }
 
    WININET_Release(hdr);
 
    if(res != ERROR_SUCCESS)
        SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by _async_query_data_available(), _expect_data_available(), CRYPT_DownloadObject(), CWebServiceWinInet::DoRequest(), InternetReadFile_chunked_test(), InternetReadFile_test(), protocol_continue(), protocol_read(), protocol_syncbinding(), rpcrt4_ncacn_http_wait_for_incoming_data(), test_cache_read(), test_conn_close(), and test_not_modified().

InternetQueryFortezzaStatus()

BOOL WINAPI InternetQueryFortezzaStatus	(	DWORD *	a,
		DWORD_PTR	b
	)

Definition at line 5329 of file internet.c.

{
    FIXME("(%p, %08Ix) stub\n", a, b);
    return FALSE;
}

InternetQueryOptionA()

BOOL WINAPI InternetQueryOptionA	(	HINTERNET	hInternet,
		DWORD	dwOption,
		LPVOID	lpBuffer,
		LPDWORD	lpdwBufferLength
	)

Definition at line 3286 of file internet.c.

{
    object_header_t *hdr;
    DWORD res = ERROR_INVALID_HANDLE;
 
    TRACE("%p %ld %p %p\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
 
    if(hInternet) {
        hdr = get_handle_object(hInternet);
        if (hdr) {
            res = hdr->vtbl->QueryOption(hdr, dwOption, lpBuffer, lpdwBufferLength, FALSE);
            WININET_Release(hdr);
        }
    }else {
        res = query_global_option(dwOption, lpBuffer, lpdwBufferLength, FALSE);
    }
 
    if(res != ERROR_SUCCESS)
        SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by _test_request_url(), cb(), closetest_callback(), InternetLockRequestFile_test(), InternetReadFile_test(), test_basic_auth_credentials_different(), test_basic_auth_credentials_end_session(), test_basic_auth_credentials_reuse(), test_cert_string(), test_cert_struct(), test_cert_struct_string(), test_http_cache(), test_InternetCloseHandle(), test_InternetQueryOptionA(), test_long_url(), test_max_conns(), test_null(), test_open_url_async(), test_Option_PerConnectionOptionA(), test_options(), test_proxy_direct(), test_secure_connection(), and test_version().

InternetQueryOptionW()

BOOL WINAPI InternetQueryOptionW	(	HINTERNET	hInternet,
		DWORD	dwOption,
		LPVOID	lpBuffer,
		LPDWORD	lpdwBufferLength
	)

Definition at line 3253 of file internet.c.

{
    object_header_t *hdr;
    DWORD res = ERROR_INVALID_HANDLE;
 
    TRACE("%p %ld %p %p\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
 
    if(hInternet) {
        hdr = get_handle_object(hInternet);
        if (hdr) {
            res = hdr->vtbl->QueryOption(hdr, dwOption, lpBuffer, lpdwBufferLength, TRUE);
            WININET_Release(hdr);
        }
    }else {
        res = query_global_option(dwOption, lpBuffer, lpdwBufferLength, TRUE);
    }
 
    if(res != ERROR_SUCCESS)
        SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by _test_http_version(), _test_request_flags(), _test_secflags_option(), HttpInfo_QueryOption(), start_downloading(), test_InternetSetOption(), test_Option_PerConnectionOption(), test_pac(), test_proxy_direct(), test_secure_connection(), test_security_flags(), and WININET_InvalidCertificateDialog().

InternetReadFile()

BOOL WINAPI InternetReadFile	(	HINTERNET	hFile,
		LPVOID	lpBuffer,
		DWORD	dwNumOfBytesToRead,
		LPDWORD	pdwNumOfBytesRead
	)

Definition at line 2609 of file internet.c.

{
    object_header_t *hdr;
    DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
 
    TRACE("%p %p %ld %p\n", hFile, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead);
 
    if (!lpBuffer || !pdwNumOfBytesRead)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        if (pdwNumOfBytesRead) *pdwNumOfBytesRead = 0;
        return FALSE;
    }
 
    hdr = get_handle_object(hFile);
    if (!hdr) {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if(hdr->vtbl->ReadFile) {
        res = hdr->vtbl->ReadFile(hdr, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead, 0, 0);
        if(res == ERROR_IO_PENDING)
            *pdwNumOfBytesRead = 0;
    }
 
    WININET_Release(hdr);
 
    TRACE("-- %s (%lu) (bytes read: %ld)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE", res,
          pdwNumOfBytesRead ? *pdwNumOfBytesRead : -1);
 
    SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by _read_expect_sync_data_len(), _receive_simple_request(), AsyncInetReadFileLoop(), CWebServiceWinInet::DoRequest(), HttpSendRequestEx_test(), InternetOpenUrlA_test(), InternetReadFile_chunked_test(), InternetReadFile_test(), InternetSetFilePointer_test(), CDownloadManager::PerformDownloadAndInstall(), protocol_read(), read_expect_async(), test_async_read(), test_basic_request(), test_cache_read(), test_cache_read_gzipped(), test_conn_close(), test_head_request(), test_http_cache(), test_no_cache(), test_response_without_headers(), test_security_flags(), and verify_cert_revocation_with_ocsp().

InternetReadFileExA()

BOOL WINAPI InternetReadFileExA	(	HINTERNET	hFile,
		LPINTERNET_BUFFERSA	lpBuffersOut,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 2672 of file internet.c.

{
    object_header_t *hdr;
    DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
 
    TRACE("(%p %p 0x%lx 0x%Ix)\n", hFile, lpBuffersOut, dwFlags, dwContext);
 
    if (lpBuffersOut->dwStructSize != sizeof(*lpBuffersOut)) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    hdr = get_handle_object(hFile);
    if (!hdr) {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if(hdr->vtbl->ReadFile)
        res = hdr->vtbl->ReadFile(hdr, lpBuffersOut->lpvBuffer, lpBuffersOut->dwBufferLength,
                &lpBuffersOut->dwBufferLength, dwFlags, dwContext);
 
    WININET_Release(hdr);
 
    TRACE("-- %s (%lu, bytes read: %ld)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE",
          res, lpBuffersOut->dwBufferLength);
 
    if(res != ERROR_SUCCESS)
        SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by CRYPT_DownloadObject(), InternetReadFileExA_test(), and test_async_read().

InternetReadFileExW()

BOOL WINAPI InternetReadFileExW	(	HINTERNET	hFile,
		LPINTERNET_BUFFERSW	lpBuffer,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 2710 of file internet.c.

{
    object_header_t *hdr;
    DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
 
    TRACE("(%p %p 0x%lx 0x%Ix)\n", hFile, lpBuffer, dwFlags, dwContext);
 
    if (!lpBuffer || lpBuffer->dwStructSize != sizeof(*lpBuffer)) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    hdr = get_handle_object(hFile);
    if (!hdr) {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if(hdr->vtbl->ReadFile)
        res = hdr->vtbl->ReadFile(hdr, lpBuffer->lpvBuffer, lpBuffer->dwBufferLength, &lpBuffer->dwBufferLength,
                dwFlags, dwContext);
 
    WININET_Release(hdr);
 
    TRACE("-- %s (%lu, bytes read: %ld)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE",
          res, lpBuffer->dwBufferLength);
 
    if(res != ERROR_SUCCESS)
        SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by _readex_expect_async(), _readex_expect_sync_data_len(), InternetReadFileExA_test(), and rpcrt4_http_async_read().

InternetSetFilePointer()

DWORD WINAPI InternetSetFilePointer	(	HINTERNET	hFile,
		LONG	lDistanceToMove,
		PVOID	pReserved,
		DWORD	dwMoveContext,
		DWORD_PTR	dwContext
	)

Definition at line 2534 of file internet.c.

{
    object_header_t *hdr;
    DWORD res;
 
    TRACE("(%p %ld %p %ld %Ix)\n", hFile, lDistanceToMove, pReserved, dwMoveContext, dwContext);
 
    hdr = get_handle_object(hFile);
    if(!hdr) {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_SET_FILE_POINTER;
    }
 
    if(hdr->vtbl->SetFilePointer) {
        res = hdr->vtbl->SetFilePointer(hdr, lDistanceToMove, dwMoveContext);
    }else {
        SetLastError(ERROR_INVALID_HANDLE);
        res = INVALID_SET_FILE_POINTER;
    }
 
    WININET_Release(hdr);
    return res;
}

Referenced by InternetReadFile_test(), InternetSetFilePointer_test(), and test_file_pointer().

InternetSetOptionA()

BOOL WINAPI InternetSetOptionA	(	HINTERNET	hInternet,
		DWORD	dwOption,
		LPVOID	lpBuffer,
		DWORD	dwBufferLength
	)

Definition at line 3727 of file internet.c.

{
    LPVOID wbuffer;
    DWORD wlen;
    BOOL r;
 
    switch( dwOption )
    {
    case INTERNET_OPTION_PROXY:
        {
        LPINTERNET_PROXY_INFOA pi = (LPINTERNET_PROXY_INFOA) lpBuffer;
        LPINTERNET_PROXY_INFOW piw;
        DWORD proxlen, prbylen;
        LPWSTR prox, prby;
 
        proxlen = MultiByteToWideChar( CP_ACP, 0, pi->lpszProxy, -1, NULL, 0);
        prbylen= MultiByteToWideChar( CP_ACP, 0, pi->lpszProxyBypass, -1, NULL, 0);
        wlen = sizeof(*piw) + proxlen + prbylen;
        wbuffer = malloc( wlen * sizeof(WCHAR) );
        piw = (LPINTERNET_PROXY_INFOW) wbuffer;
        piw->dwAccessType = pi->dwAccessType;
        prox = (LPWSTR) &piw[1];
        prby = &prox[proxlen+1];
        MultiByteToWideChar( CP_ACP, 0, pi->lpszProxy, -1, prox, proxlen);
        MultiByteToWideChar( CP_ACP, 0, pi->lpszProxyBypass, -1, prby, prbylen);
        piw->lpszProxy = prox;
        piw->lpszProxyBypass = prby;
        }
        break;
    case INTERNET_OPTION_USER_AGENT:
    case INTERNET_OPTION_USERNAME:
    case INTERNET_OPTION_PASSWORD:
    case INTERNET_OPTION_PROXY_USERNAME:
    case INTERNET_OPTION_PROXY_PASSWORD:
        wlen = MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, NULL, 0 );
        if (!(wbuffer = malloc( wlen * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
        MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, wbuffer, wlen );
        break;
    case INTERNET_OPTION_PER_CONNECTION_OPTION: {
        unsigned int i;
        INTERNET_PER_CONN_OPTION_LISTW *listW;
        INTERNET_PER_CONN_OPTION_LISTA *listA = lpBuffer;
        wlen = sizeof(INTERNET_PER_CONN_OPTION_LISTW);
        wbuffer = malloc( wlen );
        listW = wbuffer;
 
        listW->dwSize = sizeof(INTERNET_PER_CONN_OPTION_LISTW);
        if (listA->pszConnection)
        {
            wlen = MultiByteToWideChar( CP_ACP, 0, listA->pszConnection, -1, NULL, 0 );
            listW->pszConnection = malloc( wlen * sizeof(WCHAR) );
            MultiByteToWideChar( CP_ACP, 0, listA->pszConnection, -1, listW->pszConnection, wlen );
        }
        else
            listW->pszConnection = NULL;
        listW->dwOptionCount = listA->dwOptionCount;
        listW->dwOptionError = listA->dwOptionError;
        listW->pOptions = malloc( sizeof(INTERNET_PER_CONN_OPTIONW) * listA->dwOptionCount );
 
        for (i = 0; i < listA->dwOptionCount; ++i) {
            INTERNET_PER_CONN_OPTIONA *optA = listA->pOptions + i;
            INTERNET_PER_CONN_OPTIONW *optW = listW->pOptions + i;
 
            optW->dwOption = optA->dwOption;
 
            switch (optA->dwOption) {
            case INTERNET_PER_CONN_AUTOCONFIG_URL:
            case INTERNET_PER_CONN_PROXY_BYPASS:
            case INTERNET_PER_CONN_PROXY_SERVER:
            case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
                if (optA->Value.pszValue)
                {
                    wlen = MultiByteToWideChar( CP_ACP, 0, optA->Value.pszValue, -1, NULL, 0 );
                    optW->Value.pszValue = malloc( wlen * sizeof(WCHAR) );
                    MultiByteToWideChar( CP_ACP, 0, optA->Value.pszValue, -1, optW->Value.pszValue, wlen );
                }
                else
                    optW->Value.pszValue = NULL;
                break;
            case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
            case INTERNET_PER_CONN_FLAGS:
            case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
                optW->Value.dwValue = optA->Value.dwValue;
                break;
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
                optW->Value.ftValue = optA->Value.ftValue;
                break;
            default:
                WARN("Unknown PER_CONN dwOption: %ld, guessing at conversion to Wide\n", optA->dwOption);
                optW->Value.dwValue = optA->Value.dwValue;
                break;
            }
        }
        }
        break;
    default:
        wbuffer = lpBuffer;
        wlen = dwBufferLength;
    }
 
    r = InternetSetOptionW(hInternet,dwOption, wbuffer, wlen);
 
    if( lpBuffer != wbuffer )
    {
        if (dwOption == INTERNET_OPTION_PER_CONNECTION_OPTION)
        {
            INTERNET_PER_CONN_OPTION_LISTW *list = wbuffer;
            unsigned int i;
            for (i = 0; i < list->dwOptionCount; ++i) {
                INTERNET_PER_CONN_OPTIONW *opt = list->pOptions + i;
                switch (opt->dwOption) {
                case INTERNET_PER_CONN_AUTOCONFIG_URL:
                case INTERNET_PER_CONN_PROXY_BYPASS:
                case INTERNET_PER_CONN_PROXY_SERVER:
                case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
                case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
                    free( opt->Value.pszValue );
                    break;
                default:
                    break;
                }
            }
            free( list->pOptions );
        }
        free( wbuffer );
    }
 
    return r;
}

Referenced by InternetReadFile_test(), InternetSetOptionExA(), test_async_HttpSendRequestEx(), test_basic_auth_credentials_cached_manual(), test_basic_auth_credentials_end_session(), test_basic_auth_credentials_manual(), test_cache_read_gzipped(), test_end_browser_session(), test_InternetCanonicalizeUrlA(), test_InternetQueryOptionA(), test_InternetSetOption(), test_max_conns(), test_open_url_async(), test_Option_PerConnectionOptionA(), test_options(), test_proxy_direct(), test_security_flags(), and test_user_agent_header().

InternetSetOptionExA()

BOOL WINAPI InternetSetOptionExA	(	HINTERNET	hInternet,
		DWORD	dwOption,
		LPVOID	lpBuffer,
		DWORD	dwBufferLength,
		DWORD	dwFlags
	)

Definition at line 3863 of file internet.c.

{
    FIXME("Flags %08lx ignored\n", dwFlags);
    return InternetSetOptionA( hInternet, dwOption, lpBuffer, dwBufferLength );
}

InternetSetOptionExW()

BOOL WINAPI InternetSetOptionExW	(	HINTERNET	hInternet,
		DWORD	dwOption,
		LPVOID	lpBuffer,
		DWORD	dwBufferLength,
		DWORD	dwFlags
	)

Definition at line 3873 of file internet.c.

{
    FIXME("Flags %08lx ignored\n", dwFlags);
    if( dwFlags & ~ISO_VALID_FLAGS )
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    return InternetSetOptionW( hInternet, dwOption, lpBuffer, dwBufferLength );
}

InternetSetOptionW()

BOOL WINAPI InternetSetOptionW	(	HINTERNET	hInternet,
		DWORD	dwOption,
		LPVOID	lpBuffer,
		DWORD	dwBufferLength
	)

Definition at line 3457 of file internet.c.

{
    object_header_t *lpwhh;
    BOOL ret = TRUE;
    DWORD res;
 
    TRACE("(%p %ld %p %ld)\n", hInternet, dwOption, lpBuffer, dwBufferLength);
 
    lpwhh = (object_header_t*) get_handle_object( hInternet );
    if(lpwhh)
        res = lpwhh->vtbl->SetOption(lpwhh, dwOption, lpBuffer, dwBufferLength);
    else
        res = set_global_option(dwOption, lpBuffer, dwBufferLength);
 
    if(res != ERROR_INTERNET_INVALID_OPTION) {
        if(lpwhh)
            WININET_Release(lpwhh);
 
        if(res != ERROR_SUCCESS)
            SetLastError(res);
 
        return res == ERROR_SUCCESS;
    }
 
    switch (dwOption)
    {
    case INTERNET_OPTION_HTTP_VERSION:
      {
        HTTP_VERSION_INFO* pVersion=(HTTP_VERSION_INFO*)lpBuffer;
        FIXME("Option INTERNET_OPTION_HTTP_VERSION(%ld,%ld): STUB\n",pVersion->dwMajorVersion,pVersion->dwMinorVersion);
      }
      break;
    case INTERNET_OPTION_ERROR_MASK:
      {
        if(!lpwhh) {
            SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
            return FALSE;
        } else if(*(ULONG*)lpBuffer & (~(INTERNET_ERROR_MASK_INSERT_CDROM|
                        INTERNET_ERROR_MASK_COMBINED_SEC_CERT|
                        INTERNET_ERROR_MASK_LOGIN_FAILURE_DISPLAY_ENTITY_BODY))) {
            SetLastError(ERROR_INVALID_PARAMETER);
            ret = FALSE;
        } else if(dwBufferLength != sizeof(ULONG)) {
            SetLastError(ERROR_INTERNET_BAD_OPTION_LENGTH);
            ret = FALSE;
        } else {
            TRACE("INTERNET_OPTION_ERROR_MASK: %lx\n", *(ULONG*)lpBuffer);
            lpwhh->ErrorMask = *(ULONG*)lpBuffer;
        }
      }
      break;
    case INTERNET_OPTION_PROXY:
    {
        INTERNET_PROXY_INFOW *info = lpBuffer;
 
        if (!lpBuffer || dwBufferLength < sizeof(INTERNET_PROXY_INFOW))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        if (!hInternet)
        {
            EnterCriticalSection( &WININET_cs );
            free_global_proxy();
            if (info->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
            {
                global_proxy.flags = PROXY_TYPE_PROXY;
                global_proxy.proxy = wcsdup(info->lpszProxy);
                global_proxy.proxyBypass = wcsdup(info->lpszProxyBypass);
            }
            else
            {
                global_proxy.flags = PROXY_TYPE_DIRECT;
                global_proxy.proxy = global_proxy.proxyBypass = NULL;
            }
            LeaveCriticalSection( &WININET_cs );
        }
        else
        {
            /* In general, each type of object should handle
             * INTERNET_OPTION_PROXY directly.  This FIXME ensures it doesn't
             * get silently dropped.
             */
            FIXME("INTERNET_OPTION_PROXY unimplemented\n");
            SetLastError(ERROR_INTERNET_INVALID_OPTION);
            ret = FALSE;
        }
        break;
    }
    case INTERNET_OPTION_CODEPAGE:
      {
        ULONG codepage = *(ULONG *)lpBuffer;
        FIXME("Option INTERNET_OPTION_CODEPAGE (%ld): STUB\n", codepage);
      }
      break;
    case INTERNET_OPTION_REQUEST_PRIORITY:
      {
        ULONG priority = *(ULONG *)lpBuffer;
        FIXME("Option INTERNET_OPTION_REQUEST_PRIORITY (%ld): STUB\n", priority);
      }
      break;
    case INTERNET_OPTION_RESET_URLCACHE_SESSION:
        FIXME("Option INTERNET_OPTION_RESET_URLCACHE_SESSION: STUB\n");
        break;
    case INTERNET_OPTION_END_BROWSER_SESSION:
        FIXME("Option INTERNET_OPTION_END_BROWSER_SESSION: semi-stub\n");
        free_cookie();
        free_authorization_cache();
        break;
    case INTERNET_OPTION_CONNECTED_STATE:
        FIXME("Option INTERNET_OPTION_CONNECTED_STATE: STUB\n");
        break;
    case INTERNET_OPTION_DISABLE_PASSPORT_AUTH:
    TRACE("Option INTERNET_OPTION_DISABLE_PASSPORT_AUTH: harmless stub, since not enabled\n");
    break;
    case INTERNET_OPTION_IGNORE_OFFLINE:
        FIXME("Option INTERNET_OPTION_IGNORE_OFFLINE: STUB\n");
        break;
    case INTERNET_OPTION_CONNECT_RETRIES:
    {
        ULONG retries = *(ULONG *)lpBuffer;
        FIXME("INTERNET_OPTION_CONNECT_RETRIES %ld\n", retries);
        break;
    }
    case INTERNET_OPTION_CONTEXT_VALUE:
    {
        if (!lpwhh)
        {
            SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
            return FALSE;
        }
        if (!lpBuffer || dwBufferLength != sizeof(DWORD_PTR))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            ret = FALSE;
        }
        else
            lpwhh->dwContext = *(DWORD_PTR *)lpBuffer;
        break;
    }
    case INTERNET_OPTION_SECURITY_FLAGS:
     FIXME("Option INTERNET_OPTION_SECURITY_FLAGS; STUB\n");
     break;
    case INTERNET_OPTION_DISABLE_AUTODIAL:
     FIXME("Option INTERNET_OPTION_DISABLE_AUTODIAL; STUB\n");
     break;
    case INTERNET_OPTION_HTTP_DECODING:
        if (!lpwhh)
        {
            SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
            return FALSE;
        }
        if (!lpBuffer || dwBufferLength != sizeof(BOOL))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            ret = FALSE;
        }
        else
            lpwhh->decoding = *(BOOL *)lpBuffer;
        break;
    case INTERNET_OPTION_COOKIES_3RD_PARTY:
        FIXME("INTERNET_OPTION_COOKIES_3RD_PARTY; STUB\n");
        SetLastError(ERROR_INTERNET_INVALID_OPTION);
        ret = FALSE;
        break;
    case INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY:
        FIXME("INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY; STUB\n");
        SetLastError(ERROR_INTERNET_INVALID_OPTION);
        ret = FALSE;
        break;
    case INTERNET_OPTION_CODEPAGE_PATH:
        FIXME("INTERNET_OPTION_CODEPAGE_PATH; STUB\n");
        SetLastError(ERROR_INTERNET_INVALID_OPTION);
        ret = FALSE;
        break;
    case INTERNET_OPTION_CODEPAGE_EXTRA:
        FIXME("INTERNET_OPTION_CODEPAGE_EXTRA; STUB\n");
        SetLastError(ERROR_INTERNET_INVALID_OPTION);
        ret = FALSE;
        break;
    case INTERNET_OPTION_IDN:
        FIXME("INTERNET_OPTION_IDN; STUB\n");
        SetLastError(ERROR_INTERNET_INVALID_OPTION);
        ret = FALSE;
        break;
    case INTERNET_OPTION_POLICY:
        SetLastError(ERROR_INVALID_PARAMETER);
        ret = FALSE;
        break;
    case INTERNET_OPTION_PER_CONNECTION_OPTION: {
        INTERNET_PER_CONN_OPTION_LISTW *con = lpBuffer;
        LONG res;
        unsigned int i;
        proxyinfo_t pi;
 
        if (INTERNET_LoadProxySettings(&pi)) return FALSE;
 
        for (i = 0; i < con->dwOptionCount; i++) {
            INTERNET_PER_CONN_OPTIONW *option = con->pOptions + i;
 
            switch (option->dwOption) {
            case INTERNET_PER_CONN_PROXY_SERVER:
                free(pi.proxy);
                pi.proxy = wcsdup(option->Value.pszValue);
                break;
 
            case INTERNET_PER_CONN_FLAGS:
                if(option->Value.dwValue & ~(PROXY_TYPE_PROXY | PROXY_TYPE_DIRECT))
                    FIXME("Unhandled flags: 0x%lx\n", option->Value.dwValue);
                pi.flags = option->Value.dwValue;
                break;
 
            case INTERNET_PER_CONN_PROXY_BYPASS:
                free(pi.proxyBypass);
                pi.proxyBypass = wcsdup(option->Value.pszValue);
                break;
 
            case INTERNET_PER_CONN_AUTOCONFIG_URL:
                free(pi.autoconf_url);
                pi.autoconf_url = wcsdup(option->Value.pszValue);
                break;
 
            case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
            case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
            case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
                FIXME("Unhandled dwOption %ld\n", option->dwOption);
                break;
 
            default:
                FIXME("Unknown dwOption %ld\n", option->dwOption);
                SetLastError(ERROR_INVALID_PARAMETER);
                break;
            }
        }
 
        if ((res = INTERNET_SaveProxySettings(&pi)))
            SetLastError(res);
 
        FreeProxyInfo(&pi);
 
        ret = (res == ERROR_SUCCESS);
        break;
        }
    default:
        FIXME("Option %ld STUB\n",dwOption);
        SetLastError(ERROR_INTERNET_INVALID_OPTION);
        ret = FALSE;
        break;
    }
 
    if(lpwhh)
        WININET_Release( lpwhh );
 
    return ret;
}

Referenced by _set_secflags(), HTTP_RetrieveEncodedObjectW(), HttpProtocol_open_request(), InternetSetOptionA(), InternetSetOptionExW(), set_security_flag(), test_InternetSetOption(), test_Option_PerConnectionOption(), test_pac(), test_security_flags(), and update_user_agent().

InternetSetStatusCallbackA()

INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackA	(	HINTERNET	hInternet,
		INTERNET_STATUS_CALLBACK	lpfnIntCB
	)

Definition at line 2480 of file internet.c.

{
    INTERNET_STATUS_CALLBACK retVal;
    object_header_t *lpwh;
 
    TRACE("%p\n", hInternet);
 
    if (!(lpwh = get_handle_object(hInternet)))
        return INTERNET_INVALID_STATUS_CALLBACK;
 
    retVal = set_status_callback(lpwh, lpfnIntCB, FALSE);
 
    WININET_Release( lpwh );
    return retVal;
}

InternetSetStatusCallbackW()

INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackW	(	HINTERNET	hInternet,
		INTERNET_STATUS_CALLBACK	lpfnIntCB
	)

Definition at line 2508 of file internet.c.

{
    INTERNET_STATUS_CALLBACK retVal;
    object_header_t *lpwh;
 
    TRACE("%p\n", hInternet);
 
    if (!(lpwh = get_handle_object(hInternet)))
        return INTERNET_INVALID_STATUS_CALLBACK;
 
    retVal = set_status_callback(lpwh, lpfnIntCB, TRUE);
 
    WININET_Release( lpwh );
    return retVal;
}

Referenced by AsyncInetDownload(), create_internet_session(), CRYPT_Connect(), and rpcrt4_http_internet_connect().

InternetTimeFromSystemTimeA()

BOOL WINAPI InternetTimeFromSystemTimeA	(	const SYSTEMTIME *	time,
		DWORD	format,
		LPSTR	string,
		DWORD	size
	)

Definition at line 3901 of file internet.c.

{
    BOOL ret;
    WCHAR stringW[INTERNET_RFC1123_BUFSIZE];
 
    TRACE( "%p 0x%08lx %p 0x%08lx\n", time, format, string, size );
 
    if (!time || !string || format != INTERNET_RFC1123_FORMAT)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (size < INTERNET_RFC1123_BUFSIZE * sizeof(*string))
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    ret = InternetTimeFromSystemTimeW( time, format, stringW, sizeof(stringW) );
    if (ret) WideCharToMultiByte( CP_ACP, 0, stringW, -1, string, size, NULL, NULL );
 
    return ret;
}

InternetTimeFromSystemTimeW()

BOOL WINAPI InternetTimeFromSystemTimeW	(	const SYSTEMTIME *	time,
		DWORD	format,
		LPWSTR	string,
		DWORD	size
	)

Definition at line 3929 of file internet.c.

{
    TRACE( "%p 0x%08lx %p 0x%08lx\n", time, format, string, size );
 
    if (!time || !string || format != INTERNET_RFC1123_FORMAT)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (size < INTERNET_RFC1123_BUFSIZE * sizeof(*string))
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    swprintf( string, size, L"%s, %02d %s %4d %02d:%02d:%02d GMT",
              WININET_wkday[time->wDayOfWeek],
              time->wDay,
              WININET_month[time->wMonth - 1],
              time->wYear,
              time->wHour,
              time->wMinute,
              time->wSecond );
 
    return TRUE;
}

Referenced by InternetTimeFromSystemTimeA().

InternetTimeToSystemTimeA()

BOOL WINAPI InternetTimeToSystemTimeA	(	LPCSTR	string,
		SYSTEMTIME *	time,
		DWORD	reserved
	)

Definition at line 3960 of file internet.c.

{
    BOOL ret = FALSE;
    WCHAR *stringW;
 
    TRACE( "%s %p 0x%08lx\n", debugstr_a(string), time, reserved );
 
    stringW = strdupAtoW( string );
    if (stringW)
    {
        ret = InternetTimeToSystemTimeW( stringW, time, reserved );
        free( stringW );
    }
    return ret;
}

InternetTimeToSystemTimeW()

BOOL WINAPI InternetTimeToSystemTimeW	(	LPCWSTR	string,
		SYSTEMTIME *	time,
		DWORD	reserved
	)

Definition at line 3979 of file internet.c.

{
    unsigned int i;
    const WCHAR *s = string;
    WCHAR       *end;
 
    TRACE( "%s %p 0x%08lx\n", debugstr_w(string), time, reserved );
 
    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 && !iswalpha(*s) && !is_time_digit(*s)) s++;
    if (*s == '\0') return TRUE;
    time->wDayOfWeek = 7;
 
    if (iswalpha(*s))
    {
        if (s[1] == '\0' || s[2] == '\0') return TRUE;
        for (i = 0; i < 7; i++)
        {
            if (!wcsnicmp(WININET_wkday[i], s, 3))
            {
                time->wDayOfWeek = i;
                break;
            }
        }
    }
    else if (is_time_digit(*s))
    {
        time->wDayOfWeek = wcstol(s, &end, 10);
        s = end;
    }
    if (time->wDayOfWeek > 6) return TRUE;
 
    while (*s && !is_time_digit(*s)) s++;
    time->wDay = wcstol( s, &end, 10 );
    s = end;
 
    while (*s && !iswalpha(*s) && !is_time_digit(*s)) s++;
    if (*s == '\0') return TRUE;
    time->wMonth = 0;
 
    if (iswalpha(*s))
    {
        if (s[1] == '\0' || s[2] == '\0') return TRUE;
        for (i = 0; i < 12; i++)
        {
            if (!wcsnicmp(WININET_month[i], s, 3))
            {
                time->wMonth = i + 1;
                break;
            }
        }
    }
    else if (is_time_digit(*s))
    {
        time->wMonth = wcstol(s, &end, 10);
        s = end;
    }
    if (time->wMonth == 0) return TRUE;
 
    while (*s && !is_time_digit(*s)) s++;
    if (*s == '\0') return TRUE;
    time->wYear = wcstol( s, &end, 10 );
    s = end;
 
    while (*s && !is_time_digit(*s)) s++;
    if (*s == '\0') return TRUE;
    time->wHour = wcstol( s, &end, 10 );
    s = end;
 
    while (*s && !is_time_digit(*s)) s++;
    if (*s == '\0') return TRUE;
    time->wMinute = wcstol( s, &end, 10 );
    s = end;
 
    while (*s && !is_time_digit(*s)) s++;
    if (*s == '\0') return TRUE;
    time->wSecond = wcstol( s, &end, 10 );
    s = end;
 
    time->wMilliseconds = 0;
    return TRUE;
}

Referenced by HTTP_HttpQueryInfoW(), InternetTimeToSystemTimeA(), and set_cookie().

InternetUnlockRequestFile()

BOOL WINAPI InternetUnlockRequestFile

(

HANDLE

hLockHandle

)

Definition at line 4680 of file internet.c.

{
    TRACE("(%p)\n", hLockHandle);
 
    req_file_release(hLockHandle);
    return TRUE;
}

Referenced by InternetLockRequestFile_test(), and protocol_unlock_request().

InternetWriteFile()

BOOL WINAPI InternetWriteFile	(	HINTERNET	hFile,
		LPCVOID	lpBuffer,
		DWORD	dwNumOfBytesToWrite,
		LPDWORD	lpdwNumOfBytesWritten
	)

Definition at line 2569 of file internet.c.

{
    object_header_t *lpwh;
    BOOL res;
 
    TRACE("(%p %p %ld %p)\n", hFile, lpBuffer, dwNumOfBytesToWrite, lpdwNumOfBytesWritten);
 
    lpwh = get_handle_object( hFile );
    if (!lpwh) {
        WARN("Invalid handle\n");
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if(lpwh->vtbl->WriteFile) {
        res = lpwh->vtbl->WriteFile(lpwh, lpBuffer, dwNumOfBytesToWrite, lpdwNumOfBytesWritten);
    }else {
        WARN("No Writefile method.\n");
        res = ERROR_INVALID_HANDLE;
    }
 
    WININET_Release( lpwh );
 
    if(res != ERROR_SUCCESS)
        SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by HttpSendRequestEx_test(), rpcrt4_http_keep_connection_active_timer_proc(), rpcrt4_http_prepare_in_pipe(), rpcrt4_ncacn_http_receive_fragment(), rpcrt4_ncacn_http_write(), test_async_HttpSendRequestEx(), and write_post_stream().

invalidate_handle()

static void invalidate_handle ( object_header_t *  info )

static

Definition at line 226 of file internet.c.

{
    object_header_t *child, *next;
 
    if(!info->valid_handle)
        return;
    info->valid_handle = FALSE;
 
    /* Free all children as native does */
    LIST_FOR_EACH_ENTRY_SAFE( child, next, &info->children, object_header_t, entry )
    {
        TRACE("invalidating child handle %p for parent %p\n", child->hInternet, info);
        invalidate_handle( child );
    }
 
    WININET_Release(info);
}

Referenced by InternetCloseHandle(), invalidate_handle(), and WININET_Release().

is_domain_suffix()

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

static

Definition at line 2835 of file internet.c.

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

Referenced by detect_proxy_autoconfig_url_dns().

is_time_digit()

static BOOL is_time_digit ( const WCHAR  c )

inlinestatic

Definition at line 3893 of file internet.c.

{
    return c >= '0' && c <= '9';
}

Referenced by InternetTimeToSystemTimeW().

load_connection_settings()

static LONG load_connection_settings ( HKEY  key, const WCHAR *  connection, proxyinfo_t *  lpwpi  )

static

Definition at line 699 of file internet.c.

{
    connection_settings *settings = NULL;
    DWORD type, pos, size = 0;
    LONG res;
 
    while ((res = RegQueryValueExW( key, connection, NULL, &type, (BYTE*)settings, &size )) == ERROR_MORE_DATA ||
            (!res && !settings))
    {
        connection_settings *new_settings = realloc(settings, size);
        if(!new_settings)
        {
            free( settings );
            return ERROR_OUTOFMEMORY;
        }
        settings = new_settings;
    }
 
    memset(lpwpi, 0, sizeof(*lpwpi));
    if (res || type != REG_BINARY || size < FIELD_OFFSET( connection_settings, data ))
    {
        lpwpi->flags |= PROXY_TYPE_DIRECT | PROXY_TYPE_AUTO_DETECT;
        free( settings );
        return ERROR_SUCCESS;
    }
 
    lpwpi->flags = settings->flags;
    size -= FIELD_OFFSET( connection_settings, data );
    pos = 0;
    res = connection_settings_read( settings, &pos, size, &lpwpi->proxy );
    if (!res)
        res = connection_settings_read( settings, &pos, size, &lpwpi->proxyBypass );
    if (!res)
        res = connection_settings_read( settings, &pos, size, &lpwpi->autoconf_url );
    free( settings );
    if (res)
    {
        FreeProxyInfo( lpwpi );
        return res;
    }
    return ERROR_SUCCESS;
}

Referenced by INTERNET_LoadProxySettings().

parse_proxy_url()

static BOOL parse_proxy_url ( proxyinfo_t *  info, const WCHAR *  url  )

static

Definition at line 616 of file internet.c.

{
    URL_COMPONENTSW uc = {sizeof(uc)};
 
    uc.dwHostNameLength = 1;
    uc.dwUserNameLength = 1;
    uc.dwPasswordLength = 1;
 
    if (!InternetCrackUrlW( url, 0, 0, &uc )) return FALSE;
    if (!uc.dwHostNameLength)
    {
        if (!(info->proxy = wcsdup( url ))) return FALSE;
        info->proxyUsername = NULL;
        info->proxyPassword = NULL;
        return TRUE;
    }
    if (!(info->proxy = malloc( (uc.dwHostNameLength + 12) * sizeof(WCHAR) ))) return FALSE;
    swprintf( info->proxy, uc.dwHostNameLength + 12, L"%.*s:%u", uc.dwHostNameLength, uc.lpszHostName, uc.nPort );
 
    if (!uc.dwUserNameLength) info->proxyUsername = NULL;
    else if (!(info->proxyUsername = strndupW( uc.lpszUserName, uc.dwUserNameLength )))
    {
        free( info->proxy );
        return FALSE;
    }
    if (!uc.dwPasswordLength) info->proxyPassword = NULL;
    else if (!(info->proxyPassword = strndupW( uc.lpszPassword, uc.dwPasswordLength )))
    {
        free( info->proxyUsername );
        free( info->proxy );
        return FALSE;
    }
    return TRUE;
}

Referenced by init_global_proxy().

PrivacyGetZonePreferenceW()

DWORD WINAPI PrivacyGetZonePreferenceW	(	DWORD	zone,
		DWORD	type,
		LPDWORD	template,
		LPWSTR	preference,
		LPDWORD	length
	)

Definition at line 5209 of file internet.c.

{
    FIXME( "%lx %lx %p %p %p: stub\n", zone, type, template, preference, length );
 
    if (template) *template = zone_preference;
    return 0;
}

PrivacySetZonePreferenceW()

DWORD WINAPI PrivacySetZonePreferenceW	(	DWORD	zone,
		DWORD	type,
		DWORD	template,
		LPCWSTR	preference
	)

Definition at line 5198 of file internet.c.

{
    FIXME( "%lx %lx %lx %s: stub\n", zone, type, template, debugstr_w(preference) );
 
    zone_preference = template;
    return 0;
}

query_global_option()

static DWORD query_global_option ( DWORD  option, void *  buffer, DWORD *  size, BOOL  unicode  )

static

Definition at line 2925 of file internet.c.

{
    /* FIXME: This function currently handles more options than it should. Options requiring
     * proper handles should be moved to proper functions */
    switch(option) {
    case INTERNET_OPTION_HTTP_VERSION:
        if (*size < sizeof(HTTP_VERSION_INFO))
            return ERROR_INSUFFICIENT_BUFFER;
 
        /*
         * Presently hardcoded to 1.1
         */
        ((HTTP_VERSION_INFO*)buffer)->dwMajorVersion = 1;
        ((HTTP_VERSION_INFO*)buffer)->dwMinorVersion = 1;
        *size = sizeof(HTTP_VERSION_INFO);
 
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_CONNECTED_STATE:
        FIXME("INTERNET_OPTION_CONNECTED_STATE: semi-stub\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *(ULONG*)buffer = INTERNET_STATE_CONNECTED;
        *size = sizeof(ULONG);
 
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_PROXY: {
        appinfo_t ai;
        BOOL ret;
 
        TRACE("Getting global proxy info\n");
        memset(&ai, 0, sizeof(appinfo_t));
        INTERNET_ConfigureProxy(&ai);
 
        ret = APPINFO_QueryOption(&ai.hdr, INTERNET_OPTION_PROXY, buffer, size, unicode); /* FIXME */
        APPINFO_Destroy(&ai.hdr);
        return ret;
    }
 
    case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
        TRACE("INTERNET_OPTION_MAX_CONNS_PER_SERVER\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *(ULONG*)buffer = max_conns;
        *size = sizeof(ULONG);
 
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
            TRACE("INTERNET_OPTION_MAX_CONNS_1_0_SERVER\n");
 
            if (*size < sizeof(ULONG))
                return ERROR_INSUFFICIENT_BUFFER;
 
            *(ULONG*)buffer = max_1_0_conns;
            *size = sizeof(ULONG);
 
            return ERROR_SUCCESS;
 
    case INTERNET_OPTION_SECURITY_FLAGS:
        FIXME("INTERNET_OPTION_SECURITY_FLAGS: Stub\n");
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_VERSION: {
        static const INTERNET_VERSION_INFO info = { 1, 2 };
 
        TRACE("INTERNET_OPTION_VERSION\n");
 
        if (*size < sizeof(INTERNET_VERSION_INFO))
            return ERROR_INSUFFICIENT_BUFFER;
 
        memcpy(buffer, &info, sizeof(info));
        *size = sizeof(info);
 
        return ERROR_SUCCESS;
    }
 
    case INTERNET_OPTION_PER_CONNECTION_OPTION: {
        WCHAR *url = NULL;
        INTERNET_PER_CONN_OPTION_LISTW *con = buffer;
        INTERNET_PER_CONN_OPTION_LISTA *conA = buffer;
        DWORD res = ERROR_SUCCESS, i;
        proxyinfo_t pi;
        LONG ret;
 
        if((ret = INTERNET_LoadProxySettings(&pi)))
            return ret;
 
        TRACE("INTERNET_OPTION_PER_CONNECTION_OPTION\n");
 
        if (*size < sizeof(INTERNET_PER_CONN_OPTION_LISTW)) {
            FreeProxyInfo(&pi);
            return ERROR_INSUFFICIENT_BUFFER;
        }
 
        if (pi.flags & PROXY_TYPE_AUTO_DETECT)
            url = get_proxy_autoconfig_url();
 
        for (i = 0; i < con->dwOptionCount; i++) {
            INTERNET_PER_CONN_OPTIONW *optionW = con->pOptions + i;
            INTERNET_PER_CONN_OPTIONA *optionA = conA->pOptions + i;
 
            switch (optionW->dwOption) {
            case INTERNET_PER_CONN_FLAGS:
                optionW->Value.dwValue = pi.flags;
                break;
 
            case INTERNET_PER_CONN_PROXY_SERVER:
                if (unicode)
                    optionW->Value.pszValue = copy_optionW(pi.proxy);
                else
                    optionA->Value.pszValue = copy_optionA(pi.proxy);
                break;
 
            case INTERNET_PER_CONN_PROXY_BYPASS:
                if (unicode)
                    optionW->Value.pszValue = copy_optionW(pi.proxyBypass);
                else
                    optionA->Value.pszValue = copy_optionA(pi.proxyBypass);
                break;
 
            case INTERNET_PER_CONN_AUTOCONFIG_URL:
                if (unicode)
                    optionW->Value.pszValue = copy_optionW(pi.autoconf_url);
                else
                    optionA->Value.pszValue = copy_optionA(pi.autoconf_url);
                break;
 
            case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
                optionW->Value.dwValue = AUTO_PROXY_FLAG_ALWAYS_DETECT;
                break;
 
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
                if (unicode)
                    optionW->Value.pszValue = copy_optionW(url);
                else
                    optionA->Value.pszValue = copy_optionA(url);
                break;
 
            case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
            case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
                FIXME("Unhandled dwOption %ld\n", optionW->dwOption);
                memset(&optionW->Value, 0, sizeof(optionW->Value));
                break;
 
#ifdef __REACTOS__
            case INTERNET_PER_CONN_FLAGS_UI:
                WARN("Unhandled dwOption %d\n", optionW->dwOption);
                break;
 
#endif
            default:
                FIXME("Unknown dwOption %ld\n", optionW->dwOption);
                res = ERROR_INVALID_PARAMETER;
                break;
            }
        }
        free(url);
        FreeProxyInfo(&pi);
 
        return res;
    }
    case INTERNET_OPTION_REQUEST_FLAGS:
    case INTERNET_OPTION_USER_AGENT:
        *size = 0;
        return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
    case INTERNET_OPTION_POLICY:
        return ERROR_INVALID_PARAMETER;
    case INTERNET_OPTION_CONNECT_TIMEOUT:
        TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *(ULONG*)buffer = connect_timeout;
        *size = sizeof(ULONG);
 
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_SEND_TIMEOUT:
        TRACE("INTERNET_OPTION_SEND_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *(ULONG*)buffer = send_timeout;
        *size = sizeof(ULONG);
 
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_RECEIVE_TIMEOUT:
        TRACE("INTERNET_OPTION_RECEIVE_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *(ULONG*)buffer = receive_timeout;
        *size = sizeof(ULONG);
 
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_DATA_SEND_TIMEOUT:
        TRACE("INTERNET_OPTION_DATA_SEND_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *(ULONG*)buffer = data_send_timeout;
        *size = sizeof(ULONG);
 
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
        TRACE("INTERNET_OPTION_DATA_RECEIVE_TIMEOUT\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *(ULONG*)buffer = data_receive_timeout;
        *size = sizeof(ULONG);
 
        return ERROR_SUCCESS;
    }
 
    FIXME("Stub for %ld\n", option);
    return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
}

Referenced by INET_QueryOption(), InternetQueryOptionA(), and InternetQueryOptionW().

req_file_release()

void req_file_release

(

req_file_t *

req_file

)

Definition at line 4634 of file internet.c.

{
    if(InterlockedDecrement(&req_file->ref))
        return;
 
    if(!req_file->is_committed)
        DeleteFileW(req_file->file_name);
    if(req_file->file_handle && req_file->file_handle != INVALID_HANDLE_VALUE)
        CloseHandle(req_file->file_handle);
    free(req_file->file_name);
    free(req_file->url);
    free(req_file);
}

Referenced by create_cache_entry(), create_req_file(), HTTPREQ_Destroy(), and InternetUnlockRequestFile().

ResumeSuspendedDownload()

BOOL WINAPI ResumeSuspendedDownload	(	HINTERNET	hInternet,
		DWORD	dwError
	)

Definition at line 5323 of file internet.c.

{
    FIXME("(%p, 0x%08lx) stub\n", hInternet, dwError);
    return FALSE;
}

reverse_lookup()

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

static

Definition at line 2844 of file internet.c.

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

Referenced by build_wpad_url().

save_connection_settings()

static LONG save_connection_settings ( HKEY  key, const WCHAR *  connection, proxyinfo_t *  lpwpi  )

static

Definition at line 371 of file internet.c.

{
    connection_settings *settings;
    DWORD size = 0, pos = 0;
    LONG ret;
 
    connection_settings_write( NULL, &size, 0, lpwpi->proxy );
    connection_settings_write( NULL, &size, 0, lpwpi->proxyBypass );
    connection_settings_write( NULL, &size, 0, lpwpi->autoconf_url );
    size += sizeof(DWORD) * 10; /* unknown fields */
 
    settings = calloc( 1, FIELD_OFFSET(connection_settings, data[size]) );
    if (!settings)
        return ERROR_OUTOFMEMORY;
 
    settings->version = CONNECTION_SETTINGS_VERSION;
    settings->flags = lpwpi->flags;
    connection_settings_write( settings, &pos, size, lpwpi->proxy );
    connection_settings_write( settings, &pos, size, lpwpi->proxyBypass );
    connection_settings_write( settings, &pos, size, lpwpi->autoconf_url );
 
    ret = RegSetValueExW(key, connection, 0, REG_BINARY, (BYTE*)settings,
            FIELD_OFFSET(connection_settings, data[size]));
    free(settings);
    return ret;
}

Referenced by INTERNET_SaveProxySettings().

scheme_is_opaque()

static BOOL scheme_is_opaque ( INTERNET_SCHEME  nScheme )

inlinestatic

Definition at line 4812 of file internet.c.

{
    return (nScheme != INTERNET_SCHEME_FTP) &&
           (nScheme != INTERNET_SCHEME_GOPHER) &&
           (nScheme != INTERNET_SCHEME_HTTP) &&
           (nScheme != INTERNET_SCHEME_HTTPS) &&
           (nScheme != INTERNET_SCHEME_FILE);
}

Referenced by calc_url_length(), and InternetCreateUrlW().

set_global_option()

static DWORD set_global_option ( DWORD  option, void *  buf, DWORD  size  )

static

Definition at line 3350 of file internet.c.

{
    switch(option) {
    case INTERNET_OPTION_CALLBACK:
        WARN("Not global option %lu\n", option);
        return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
 
    case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
        TRACE("INTERNET_OPTION_MAX_CONNS_PER_SERVER\n");
 
        if(size != sizeof(max_conns))
            return ERROR_INTERNET_BAD_OPTION_LENGTH;
        if(!*(ULONG*)buf)
            return ERROR_BAD_ARGUMENTS;
 
        max_conns = *(ULONG*)buf;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
        TRACE("INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER\n");
 
        if(size != sizeof(max_1_0_conns))
            return ERROR_INTERNET_BAD_OPTION_LENGTH;
        if(!*(ULONG*)buf)
            return ERROR_BAD_ARGUMENTS;
 
        max_1_0_conns = *(ULONG*)buf;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_CONNECT_TIMEOUT:
        TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
 
        if(size != sizeof(connect_timeout))
            return ERROR_INTERNET_BAD_OPTION_LENGTH;
        if(!*(ULONG*)buf)
            return ERROR_BAD_ARGUMENTS;
 
        connect_timeout = *(ULONG*)buf;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_SEND_TIMEOUT:
        TRACE("INTERNET_OPTION_SEND_TIMEOUT\n");
 
        if(size != sizeof(send_timeout))
            return ERROR_INTERNET_BAD_OPTION_LENGTH;
        if(!*(ULONG*)buf)
            return ERROR_BAD_ARGUMENTS;
 
        send_timeout = *(ULONG*)buf;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_RECEIVE_TIMEOUT:
        TRACE("INTERNET_OPTION_RECEIVE_TIMEOUT\n");
 
        if(size != sizeof(receive_timeout))
            return ERROR_INTERNET_BAD_OPTION_LENGTH;
        if(!*(ULONG*)buf)
            return ERROR_BAD_ARGUMENTS;
 
        receive_timeout = *(ULONG*)buf;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_DATA_SEND_TIMEOUT:
        TRACE("INTERNET_OPTION_DATA_SEND_TIMEOUT\n");
 
        if(size != sizeof(data_send_timeout))
            return ERROR_INTERNET_BAD_OPTION_LENGTH;
        if(!*(ULONG*)buf)
            return ERROR_BAD_ARGUMENTS;
 
        data_send_timeout = *(ULONG*)buf;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
        TRACE("INTERNET_OPTION_DATA_RECEIVE_TIMEOUT\n");
 
        if(size != sizeof(data_receive_timeout))
            return ERROR_INTERNET_BAD_OPTION_LENGTH;
        if(!*(ULONG*)buf)
            return ERROR_BAD_ARGUMENTS;
 
        data_receive_timeout = *(ULONG*)buf;
        return ERROR_SUCCESS;
 
    case INTERNET_OPTION_SUPPRESS_BEHAVIOR:
        FIXME("INTERNET_OPTION_SUPPRESS_BEHAVIOR stub\n");
 
        if(size != sizeof(ULONG))
            return ERROR_INTERNET_BAD_OPTION_LENGTH;
 
        FIXME("%08lx\n", *(ULONG*)buf);
        return ERROR_SUCCESS;
    }
 
    return INET_SetOption(NULL, option, buf, size);
}

Referenced by InternetSetOptionW().

set_status_callback()

static INTERNET_STATUS_CALLBACK set_status_callback ( object_header_t *  lpwh, INTERNET_STATUS_CALLBACK  callback, BOOL  unicode  )

static

Definition at line 2455 of file internet.c.

{
    INTERNET_STATUS_CALLBACK ret;
 
    if (unicode) lpwh->dwInternalFlags |= INET_CALLBACKW;
    else lpwh->dwInternalFlags &= ~INET_CALLBACKW;
 
    ret = lpwh->lpfnStatusCB;
    lpwh->lpfnStatusCB = callback;
 
    return ret;
}

Referenced by InternetSetStatusCallbackA(), and InternetSetStatusCallbackW().

set_url_component()

static BOOL set_url_component ( WCHAR **  component, DWORD *  component_length, const WCHAR *  value, DWORD  len  )

static

Definition at line 1859 of file internet.c.

{
    TRACE("%s (%ld)\n", debugstr_wn(value, len), len);
 
    if (!*component_length)
        return TRUE;
 
    if (!*component) {
        *(const WCHAR**)component = value;
        *component_length = len;
        return TRUE;
    }
 
    if (*component_length < len+1) {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    *component_length = len;
    if(len)
        memcpy(*component, value, len*sizeof(WCHAR));
    (*component)[len] = 0;
    return TRUE;
}

Referenced by InternetCrackUrlW().

set_url_component_AtoW()

static BOOL set_url_component_AtoW ( const char *  comp_a, DWORD  len_a, WCHAR **  comp_w, DWORD *  len_w, WCHAR **  buf  )

static

Definition at line 1911 of file internet.c.

{
    *len_w = len_a;
 
    if(!comp_a) {
        *comp_w = NULL;
        return TRUE;
    }
 
    if(!(*comp_w = *buf = malloc(len_a * sizeof(WCHAR)))) {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by InternetCrackUrlA().

set_url_component_WtoA()

static BOOL set_url_component_WtoA ( const WCHAR *  comp_w, DWORD  length, const WCHAR *  url_w, char **  comp, DWORD *  ret_length, const char *  url_a  )

static

Definition at line 1884 of file internet.c.

{
    size_t size, ret_size = *ret_length;
 
    if (!*ret_length)
        return TRUE;
    size = WideCharToMultiByte(CP_ACP, 0, comp_w, length, NULL, 0, NULL, NULL);
 
    if (!*comp) {
        *comp = comp_w ? (char*)url_a + WideCharToMultiByte(CP_ACP, 0, url_w, comp_w-url_w, NULL, 0, NULL, NULL) : NULL;
        *ret_length = size;
        return TRUE;
    }
 
    if (size+1 > ret_size) {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        *ret_length = size+1;
        return FALSE;
    }
 
    *ret_length = size;
    WideCharToMultiByte(CP_ACP, 0, comp_w, length, *comp, ret_size-1, NULL, NULL);
    (*comp)[size] = 0;
    return TRUE;
}

Referenced by InternetCrackUrlA().

ShowClientAuthCerts()

DWORD WINAPI ShowClientAuthCerts

(

HWND

parent

)

Definition at line 5335 of file internet.c.

{
    FIXME("%p: stub\n", parent);
    return 0;
}

url_uses_default_port()

static BOOL url_uses_default_port ( INTERNET_SCHEME  nScheme, INTERNET_PORT  nPort  )

static

Definition at line 4789 of file internet.c.

{
    if ((nScheme == INTERNET_SCHEME_HTTP) &&
        (nPort == INTERNET_DEFAULT_HTTP_PORT))
        return TRUE;
    if ((nScheme == INTERNET_SCHEME_HTTPS) &&
        (nPort == INTERNET_DEFAULT_HTTPS_PORT))
        return TRUE;
    if ((nScheme == INTERNET_SCHEME_FTP) &&
        (nPort == INTERNET_DEFAULT_FTP_PORT))
        return TRUE;
    if ((nScheme == INTERNET_SCHEME_GOPHER) &&
        (nPort == INTERNET_DEFAULT_GOPHER_PORT))
        return TRUE;
 
    if (nPort == INTERNET_INVALID_PORT_NUMBER)
        return TRUE;
 
    return FALSE;
}

Referenced by calc_url_length(), and InternetCreateUrlW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wininet

)

WININET_AddRef()

object_header_t * WININET_AddRef

(

object_header_t *

info

)

Definition at line 202 of file internet.c.

{
    ULONG refs = InterlockedIncrement(&info->refs);
    TRACE("%p -> refcount = %ld\n", info, refs );
    return info;
}

Referenced by alloc_async_task(), FTP_Connect(), FTP_FtpOpenFileW(), FTP_ReceiveFileList(), get_handle_object(), HTTP_Connect(), and HTTP_HttpOpenRequestW().

WININET_Release()

BOOL WININET_Release

(

object_header_t *

info

)

Definition at line 244 of file internet.c.

{
    ULONG refs = InterlockedDecrement(&info->refs);
    TRACE( "object %p refcount = %ld\n", info, refs );
    if( !refs )
    {
        invalidate_handle(info);
        if ( info->vtbl->CloseConnection )
        {
            TRACE( "closing connection %p\n", info);
            info->vtbl->CloseConnection( info );
        }
        /* Don't send a callback if this is a session handle created with InternetOpenUrl */
        if ((info->htype != WH_HHTTPSESSION && info->htype != WH_HFTPSESSION)
            || !(info->dwInternalFlags & INET_OPENURL))
        {
            INTERNET_SendCallback(info, info->dwContext,
                                  INTERNET_STATUS_HANDLE_CLOSING, &info->hInternet,
                                  sizeof(HINTERNET));
        }
        TRACE( "destroying object %p\n", info);
        if ( info->htype != WH_HINIT )
            list_remove( &info->entry );
        info->vtbl->Destroy( info );
 
        if(info->hInternet) {
            UINT_PTR handle = (UINT_PTR)info->hInternet;
 
            EnterCriticalSection( &WININET_cs );
 
            handle_table[handle] = NULL;
            if(next_handle > handle)
                next_handle = handle;
 
            LeaveCriticalSection( &WININET_cs );
        }
 
        free(info);
    }
    return TRUE;
}

Referenced by FTP_Connect(), FtpCommandW(), FtpCreateDirectoryW(), FtpDeleteFileW(), FTPFILE_Destroy(), FtpFindFirstFileW(), FTPFINDNEXT_Destroy(), FtpGetCurrentDirectoryW(), FtpGetFileW(), FtpOpenFileW(), FtpPutFileW(), FtpRemoveDirectoryW(), FtpRenameFileW(), FTPSESSION_Destroy(), FtpSetCurrentDirectoryW(), HTTP_HttpOpenRequestW(), HttpAddRequestHeadersW(), HttpEndRequestW(), HttpOpenRequestW(), HttpQueryInfoW(), HTTPREQ_Destroy(), HttpSendRequestExW(), HttpSendRequestW(), HTTPSESSION_Destroy(), INTERNET_WorkerThreadFunc(), InternetCloseHandle(), InternetConnectW(), InternetErrorDlg(), InternetFindNextFileW(), InternetLockRequestFile(), InternetOpenUrlW(), InternetQueryDataAvailable(), InternetQueryOptionA(), InternetQueryOptionW(), InternetReadFile(), InternetReadFileExA(), InternetReadFileExW(), InternetSetFilePointer(), InternetSetOptionW(), InternetSetStatusCallbackA(), InternetSetStatusCallbackW(), InternetWriteFile(), and invalidate_handle().

Variable Documentation

APPINFOVtbl

const object_vtbl_t APPINFOVtbl

static

Initial value:

= {
    APPINFO_Destroy,
    NULL,
    APPINFO_QueryOption,
    APPINFO_SetOption,
    NULL,
    NULL,
    NULL,
    NULL
}

Definition at line 1312 of file internet.c.

Referenced by InternetOpenW().

connect_timeout

ULONG connect_timeout = 60000

static

Definition at line 112 of file internet.c.

Referenced by alloc_object(), query_global_option(), set_global_option(), and winhttp_request_SetTimeouts().

data_receive_timeout

ULONG data_receive_timeout = 60000

static

Definition at line 116 of file internet.c.

Referenced by alloc_object(), query_global_option(), and set_global_option().

data_send_timeout

ULONG data_send_timeout = 60000

static

Definition at line 115 of file internet.c.

Referenced by alloc_object(), query_global_option(), and set_global_option().

g_dwTlsErrIndex

DWORD g_dwTlsErrIndex = TLS_OUT_OF_INDEXES

static

Definition at line 70 of file internet.c.

Referenced by DllMain(), INTERNET_AllocThreadError(), INTERNET_GetLastError(), INTERNET_GetResponseBuffer(), INTERNET_SetLastError(), INTERNET_WorkerThreadFunc(), InternetGetLastResponseInfoA(), and InternetGetLastResponseInfoW().

global_proxy

proxyinfo_t global_proxy

static

Definition at line 606 of file internet.c.

Referenced by APPINFO_QueryOption(), APPINFO_SetOption(), free_global_proxy(), init_global_proxy(), INTERNET_GetProxySettings(), and InternetSetOptionW().

handle_table

object_header_t** handle_table

static

Definition at line 82 of file internet.c.

handle_table_size

UINT_PTR handle_table_size

static

Definition at line 84 of file internet.c.

Referenced by alloc_object(), and get_handle_object().

max_1_0_conns

ULONG max_1_0_conns = 4

static

Definition at line 111 of file internet.c.

Referenced by query_global_option(), and set_global_option().

max_conns

ULONG max_conns = 2

static

Definition at line 111 of file internet.c.

Referenced by query_global_option(), and set_global_option().

next_handle

UINT_PTR next_handle

static

Definition at line 83 of file internet.c.

Referenced by alloc_object(), and WININET_Release().

receive_timeout

ULONG receive_timeout = 60000

static

Definition at line 114 of file internet.c.

Referenced by alloc_object(), query_global_option(), set_global_option(), and winhttp_request_SetTimeouts().

send_timeout

ULONG send_timeout = 60000

static

Definition at line 113 of file internet.c.

Referenced by alloc_object(), query_global_option(), set_global_option(), and winhttp_request_SetTimeouts().

szInternetSettings

const WCHAR szInternetSettings[]

static

Initial value:

=
    L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"

Definition at line 119 of file internet.c.

Referenced by INTERNET_LoadProxySettings(), and INTERNET_SaveProxySettings().

url_schemes

const WCHAR* url_schemes[]

static

Initial value:

=
{
    L"ftp",
    L"gopher",
    L"http",
    L"https",
    L"file",
    L"news",
    L"mailto",
    L"socks",
    L"javascript",
    L"vbscript",
    L"res"
}

Definition at line 2002 of file internet.c.

Referenced by GetInternetSchemeW(), and INTERNET_GetSchemeString().

WININET_cs

static CRITICAL_SECTION WININET_cs = { &WININET_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 73 of file internet.c.

Referenced by alloc_object(), APPINFO_QueryOption(), APPINFO_SetOption(), free_global_proxy(), get_handle_object(), init_global_proxy(), INTERNET_GetProxySettings(), InternetSetOptionW(), and WININET_Release().

WININET_cs_debug

CRITICAL_SECTION_DEBUG WININET_cs_debug

static

Initial value:

= 
{
    0, 0, &WININET_cs,
    { &WININET_cs_debug.ProcessLocksList, &WININET_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": WININET_cs") }
}

Definition at line 74 of file internet.c.

WININET_hModule

HMODULE WININET_hModule

Definition at line 71 of file internet.c.

Referenced by collect_connections_proc(), DllMain(), http_release_netconn(), HTTPREQ_QueryOption(), InternetErrorDlg(), InternetGetConnectedStateExW(), and WININET_InvalidCertificateDialog().

WININET_month

const WCHAR WININET_month[12][4]

static

Initial value:

=
    { L"Jan", L"Feb", L"Mar", L"Apr",
      L"May", L"Jun", L"Jul", L"Aug",
      L"Sep", L"Oct", L"Nov", L"Dec"}

Definition at line 3888 of file internet.c.

Referenced by InternetTimeFromSystemTimeW(), and InternetTimeToSystemTimeW().

WININET_wkday

const WCHAR WININET_wkday[7][4]

static

Initial value:

=
    { L"Sun", L"Mon", L"Tue", L"Wed",
      L"Thu", L"Fri", L"Sat"}

Definition at line 3885 of file internet.c.

Referenced by InternetTimeFromSystemTimeW(), and InternetTimeToSystemTimeW().

zone_preference

DWORD zone_preference = 3

static

Definition at line 5193 of file internet.c.

Referenced by PrivacyGetZonePreferenceW(), and PrivacySetZonePreferenceW().