internet.h File Reference

#include "wine/list.h"
#include <time.h>
#include "winineti.h"

Include dependency graph for internet.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	server_t
struct	netconn_t
struct	substr_t
struct	req_file_t
struct	object_vtbl_t
struct	_object_header_t
struct	appinfo_t
struct	http_session_t
struct	HTTPHEADERW
struct	data_stream_t
struct	netconn_stream_t
struct	http_request_t
struct	task_header_t
struct	wininet_flag_info

Macros
#define	INET_OPENURL   0x0001
#define	INET_CALLBACKW   0x0002
#define	INTERNET_HANDLE_IN_USE   1
#define	HDR_ISREQUEST   0x0001
#define	HDR_COMMADELIMITED   0x0002
#define	HDR_SEMIDELIMITED   0x0004
#define	READ_BUFFER_SIZE   8192
#define	MAX_REPLY_LEN   0x1000
#define	_SECURITY_FLAG_CERT_REV_FAILED   0x00800000
#define	_SECURITY_FLAG_CERT_INVALID_CA   0x01000000
#define	_SECURITY_FLAG_CERT_INVALID_CN   0x02000000
#define	_SECURITY_FLAG_CERT_INVALID_DATE   0x04000000
#define	_SECURITY_ERROR_FLAGS_MASK

Typedefs
typedef struct _object_header_t	object_header_t
typedef struct HTTPHEADERW *	LPHTTPHEADERW
typedef struct data_stream_vtbl_t	data_stream_vtbl_t
typedef struct task_header_t	task_header_t
typedef void(*	async_task_proc_t) (task_header_t *)

Enumerations
enum	collect_type_t { COLLECT_TIMEOUT , COLLECT_CONNECTIONS , COLLECT_CLEANUP }
enum	WH_TYPE {   WH_HINIT = INTERNET_HANDLE_TYPE_INTERNET , WH_HFTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_FTP , WH_HGOPHERSESSION = INTERNET_HANDLE_TYPE_CONNECT_GOPHER , WH_HHTTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_HTTP ,   WH_HFILE = INTERNET_HANDLE_TYPE_FTP_FILE , WH_HFTPFINDNEXT = INTERNET_HANDLE_TYPE_FTP_FIND , WH_HHTTPREQ = INTERNET_HANDLE_TYPE_HTTP_REQUEST }

Functions
void	server_addref (server_t *)
void	server_release (server_t *)
BOOL	collect_connections (collect_type_t)
BOOL	is_valid_netconn (netconn_t *)
void	close_netconn (netconn_t *)
static WCHAR *	strndupW (const WCHAR *str, UINT max_len)
static WCHAR *	strndupAtoW (const char *str, int len_a, DWORD *len_w)
static WCHAR *	strdupAtoW (const char *str)
static char *	strdupWtoA (const WCHAR *str)
static substr_t	substr (const WCHAR *str, size_t len)
static substr_t	substrz (const WCHAR *str)
static void	WININET_find_data_WtoA (LPWIN32_FIND_DATAW dataW, LPWIN32_FIND_DATAA dataA)
void *	alloc_async_task (object_header_t *, async_task_proc_t, size_t)
void *	alloc_object (object_header_t *, const object_vtbl_t *, size_t)
object_header_t *	get_handle_object (HINTERNET hinternet)
object_header_t *	WININET_AddRef (object_header_t *info)
BOOL	WININET_Release (object_header_t *info)
DWORD	INET_QueryOption (object_header_t *, DWORD, void *, DWORD *, BOOL)
DWORD	INET_SetOption (object_header_t *, DWORD, void *, DWORD)
time_t	ConvertTimeString (LPCWSTR asctime)
HINTERNET	FTP_Connect (appinfo_t *hIC, LPCWSTR lpszServerName, INTERNET_PORT nServerPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext, DWORD dwInternalFlags)
DWORD	HTTP_Connect (appinfo_t *, LPCWSTR, INTERNET_PORT nServerPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext, DWORD dwInternalFlags, HINTERNET *)
BOOL	GetAddress (const WCHAR *, INTERNET_PORT, SOCKADDR *, int *, char *)
DWORD	get_cookie_header (const WCHAR *, const WCHAR *, WCHAR **)
DWORD	set_cookie (substr_t, substr_t, substr_t, substr_t, DWORD)
void	INTERNET_SetLastError (DWORD dwError)
DWORD	INTERNET_GetLastError (void)
DWORD	INTERNET_AsyncCall (task_header_t *)
LPSTR	INTERNET_GetResponseBuffer (void)
VOID	INTERNET_SendCallback (object_header_t *hdr, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInfo, DWORD dwStatusInfoLength)
WCHAR *	INTERNET_FindProxyForProtocol (LPCWSTR szProxy, LPCWSTR proto)
DWORD	create_netconn (server_t *, DWORD, BOOL, DWORD, netconn_t **)
void	free_netconn (netconn_t *)
void	NETCON_unload (void)
DWORD	NETCON_secure_connect (netconn_t *, server_t *)
DWORD	NETCON_send (netconn_t *connection, const void *msg, size_t len, int flags, int *sent)
DWORD	NETCON_recv (netconn_t *, void *, size_t, BOOL, int *)
BOOL	NETCON_is_alive (netconn_t *)
LPCVOID	NETCON_GetCert (netconn_t *connection)
int	NETCON_GetCipherStrength (netconn_t *)
DWORD	NETCON_set_timeout (netconn_t *connection, BOOL send, DWORD value)
int	sock_send (int fd, const void *msg, size_t len, int flags)
int	sock_recv (int fd, void *msg, size_t len, int flags)
server_t *	get_server (substr_t, INTERNET_PORT, BOOL, BOOL)
DWORD	create_req_file (const WCHAR *, req_file_t **)
void	req_file_release (req_file_t *)
static req_file_t *	req_file_addref (req_file_t *req_file)
BOOL	init_urlcache (void)
void	free_urlcache (void)
void	free_cookie (void)
void	free_authorization_cache (void)
void	init_winsock (void)

Variables
HMODULE	WININET_hModule

Macro Definition Documentation

_SECURITY_ERROR_FLAGS_MASK

#define _SECURITY_ERROR_FLAGS_MASK

Value:

    (_SECURITY_FLAG_CERT_REV_FAILED             \
    |_SECURITY_FLAG_CERT_INVALID_CA             \
    |_SECURITY_FLAG_CERT_INVALID_CN             \
    |_SECURITY_FLAG_CERT_INVALID_DATE)

Definition at line 445 of file internet.h.

_SECURITY_FLAG_CERT_INVALID_CA

#define _SECURITY_FLAG_CERT_INVALID_CA   0x01000000

Definition at line 441 of file internet.h.

_SECURITY_FLAG_CERT_INVALID_CN

#define _SECURITY_FLAG_CERT_INVALID_CN   0x02000000

Definition at line 442 of file internet.h.

_SECURITY_FLAG_CERT_INVALID_DATE

#define _SECURITY_FLAG_CERT_INVALID_DATE   0x04000000

Definition at line 443 of file internet.h.

_SECURITY_FLAG_CERT_REV_FAILED

#define _SECURITY_FLAG_CERT_REV_FAILED   0x00800000

Definition at line 440 of file internet.h.

HDR_COMMADELIMITED

#define HDR_COMMADELIMITED   0x0002

Definition at line 283 of file internet.h.

HDR_ISREQUEST

#define HDR_ISREQUEST   0x0001

Definition at line 282 of file internet.h.

HDR_SEMIDELIMITED

#define HDR_SEMIDELIMITED   0x0004

Definition at line 284 of file internet.h.

INET_CALLBACKW

#define INET_CALLBACKW   0x0002

Definition at line 210 of file internet.h.

INET_OPENURL

#define INET_OPENURL   0x0001

Definition at line 209 of file internet.h.

INTERNET_HANDLE_IN_USE

#define INTERNET_HANDLE_IN_USE   1

Definition at line 236 of file internet.h.

MAX_REPLY_LEN

#define MAX_REPLY_LEN   0x1000

Definition at line 430 of file internet.h.

READ_BUFFER_SIZE

#define READ_BUFFER_SIZE   8192

Definition at line 309 of file internet.h.

Typedef Documentation

async_task_proc_t

typedef void(* async_task_proc_t) (task_header_t *)

Definition at line 353 of file internet.h.

data_stream_vtbl_t

typedef struct data_stream_vtbl_t data_stream_vtbl_t

Definition at line 297 of file internet.h.

LPHTTPHEADERW

typedef struct HTTPHEADERW * LPHTTPHEADERW

object_header_t

typedef struct _object_header_t object_header_t

Definition at line 221 of file internet.h.

task_header_t

typedef struct task_header_t task_header_t

Definition at line 352 of file internet.h.

Enumeration Type Documentation

collect_type_t

enum collect_type_t

Enumerator
COLLECT_TIMEOUT
COLLECT_CONNECTIONS
COLLECT_CLEANUP

Definition at line 58 of file internet.h.

             {
    COLLECT_TIMEOUT,
    COLLECT_CONNECTIONS,
    COLLECT_CLEANUP
} collect_type_t;

WH_TYPE

enum WH_TYPE

Enumerator
WH_HINIT
WH_HFTPSESSION
WH_HGOPHERSESSION
WH_HHTTPSESSION
WH_HFILE
WH_HFTPFINDNEXT
WH_HHTTPREQ

Definition at line 198 of file internet.h.

{
    WH_HINIT = INTERNET_HANDLE_TYPE_INTERNET,
    WH_HFTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_FTP,
    WH_HGOPHERSESSION = INTERNET_HANDLE_TYPE_CONNECT_GOPHER,
    WH_HHTTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_HTTP,
    WH_HFILE = INTERNET_HANDLE_TYPE_FTP_FILE,
    WH_HFTPFINDNEXT = INTERNET_HANDLE_TYPE_FTP_FIND,
    WH_HHTTPREQ = INTERNET_HANDLE_TYPE_HTTP_REQUEST,
} WH_TYPE;

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().

close_netconn()

void close_netconn

(

netconn_t *

netconn

)

Definition at line 380 of file netconnection.c.

{
    closesocket(netconn->socket);
    netconn->socket = -1;
}

Referenced by free_netconn(), and http_release_netconn().

collect_connections()

BOOL collect_connections

(

collect_type_t

collect_type

)

Definition at line 229 of file http.c.

{
    netconn_t *netconn, *netconn_safe;
    server_t *server, *server_safe;
    BOOL remaining = FALSE;
    DWORD64 now;
 
    now = GetTickCount64();
 
    LIST_FOR_EACH_ENTRY_SAFE(server, server_safe, &connection_pool, server_t, entry) {
        LIST_FOR_EACH_ENTRY_SAFE(netconn, netconn_safe, &server->conn_pool, netconn_t, pool_entry) {
            if(collect_type > COLLECT_TIMEOUT || netconn->keep_until < now) {
                TRACE("freeing %p\n", netconn);
                list_remove(&netconn->pool_entry);
                free_netconn(netconn);
            }else {
                remaining = TRUE;
            }
        }
 
        if(collect_type == COLLECT_CLEANUP) {
            list_remove(&server->entry);
            list_init(&server->entry);
            server_release(server);
        }
    }
 
    return remaining;
}

Referenced by collect_connections_proc(), DllMain(), and INET_SetOption().

ConvertTimeString()

time_t ConvertTimeString

(

LPCWSTR

asctime

)

create_netconn()

DWORD create_netconn	(	server_t *	server,
		DWORD	security_flags,
		BOOL	mask_errors,
		DWORD	timeout,
		netconn_t **	ret
	)

Definition at line 348 of file netconnection.c.

{
    netconn_t *netconn;
    int result;
 
    netconn = calloc(1, sizeof(*netconn));
    if(!netconn)
        return ERROR_OUTOFMEMORY;
 
    netconn->socket = -1;
    netconn->security_flags = security_flags | server->security_flags;
    netconn->mask_errors = mask_errors;
    list_init(&netconn->pool_entry);
    SecInvalidateHandle(&netconn->ssl_ctx);
 
    result = create_netconn_socket(server, netconn, timeout);
    if (result != ERROR_SUCCESS) {
        free(netconn);
        return result;
    }
 
    server_addref(server);
    netconn->server = server;
    *ret = netconn;
    return result;
}

Referenced by open_http_connection().

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().

free_authorization_cache()

void free_authorization_cache

(

void

)

Definition at line 926 of file http.c.

{
    authorizationData *ad, *sa_safe;
    basicAuthorizationData *basic, *basic_safe;
 
    EnterCriticalSection(&authcache_cs);
 
    LIST_FOR_EACH_ENTRY_SAFE(basic, basic_safe, &basicAuthorizationCache, basicAuthorizationData, entry)
    {
        free(basic->host);
        free(basic->realm);
        free(basic->authorization);
 
        list_remove(&basic->entry);
        free(basic);
    }
 
    LIST_FOR_EACH_ENTRY_SAFE(ad, sa_safe, &authorizationCache, authorizationData, entry)
    {
        free(ad->host);
        free(ad->scheme);
        free(ad->user);
        free(ad->password);
        free(ad->domain);
        list_remove(&ad->entry);
        free(ad);
    }
 
    LeaveCriticalSection(&authcache_cs);
}

Referenced by InternetSetOptionW().

free_cookie()

void free_cookie

(

void

)

Definition at line 1269 of file cookie.c.

{
    EnterCriticalSection(&cookie_cs);
 
    free_cookie_domain_list(&domain_list);
 
    LeaveCriticalSection(&cookie_cs);
}

Referenced by delete_cookie(), DllMain(), InternetSetOptionW(), parse_cookie(), and set_cookies().

free_netconn()

void free_netconn

(

netconn_t *

netconn

)

Definition at line 386 of file netconnection.c.

{
    server_release(netconn->server);
 
    if (netconn->secure) {
        free(netconn->peek_msg_mem);
        netconn->peek_msg_mem = NULL;
        netconn->peek_msg = NULL;
        netconn->peek_len = 0;
        free(netconn->ssl_buf);
        netconn->ssl_buf = NULL;
        free(netconn->extra_buf);
        netconn->extra_buf = NULL;
        netconn->extra_len = 0;
    }
    if (SecIsValidHandle(&netconn->ssl_ctx))
        DeleteSecurityContext(&netconn->ssl_ctx);
 
    close_netconn(netconn);
    free(netconn);
}

Referenced by collect_connections(), and open_http_connection().

free_urlcache()

void free_urlcache

(

void

)

Definition at line 4124 of file urlcache.c.

{
    SetEvent(dll_unload_event);
    WaitForSingleObject(free_cache_running, INFINITE);
    ReleaseSemaphore(free_cache_running, 1, NULL);
    CloseHandle(free_cache_running);
    CloseHandle(dll_unload_event);
 
    cache_containers_free();
}

Referenced by DllMain().

FTP_Connect()

HINTERNET FTP_Connect	(	appinfo_t *	hIC,
		LPCWSTR	lpszServerName,
		INTERNET_PORT	nServerPort,
		LPCWSTR	lpszUserName,
		LPCWSTR	lpszPassword,
		DWORD	dwFlags,
		DWORD_PTR	dwContext,
		DWORD	dwInternalFlags
	)

Definition at line 2430 of file ftp.c.

{
    struct sockaddr_in socketAddr;
    INT nsocket = -1;
    socklen_t sock_namelen;
    BOOL bSuccess = FALSE;
    ftp_session_t *lpwfs = NULL;
    char szaddr[INET6_ADDRSTRLEN];
 
    TRACE("%p  Server(%s) Port(%d) User(%s) Paswd(%s)\n",
        hIC, debugstr_w(lpszServerName),
        nServerPort, debugstr_w(lpszUserName), debugstr_w(lpszPassword));
 
    assert( hIC->hdr.htype == WH_HINIT );
 
    if ((!lpszUserName || !*lpszUserName) && lpszPassword && *lpszPassword)
    {
    INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    
    lpwfs = alloc_object(&hIC->hdr, &FTPSESSIONVtbl, sizeof(ftp_session_t));
    if (NULL == lpwfs)
    {
        INTERNET_SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
 
    if (nServerPort == INTERNET_INVALID_PORT_NUMBER)
        lpwfs->serverport = INTERNET_DEFAULT_FTP_PORT;
    else
        lpwfs->serverport = nServerPort;
 
    lpwfs->hdr.htype = WH_HFTPSESSION;
    lpwfs->hdr.dwFlags = dwFlags;
    lpwfs->hdr.dwContext = dwContext;
    lpwfs->hdr.dwInternalFlags |= dwInternalFlags;
    lpwfs->download_in_progress = NULL;
    lpwfs->sndSocket = -1;
    lpwfs->lstnSocket = -1;
    lpwfs->pasvSocket = -1;
 
    WININET_AddRef( &hIC->hdr );
    lpwfs->lpAppInfo = hIC;
    list_add_head( &hIC->hdr.children, &lpwfs->hdr.entry );
 
    if(hIC->proxy && hIC->accessType == INTERNET_OPEN_TYPE_PROXY) {
        if(wcschr(hIC->proxy, ' '))
            FIXME("Several proxies not implemented.\n");
        if(hIC->proxyBypass)
            FIXME("Proxy bypass is ignored.\n");
    }
    if (!lpszUserName || !lpszUserName[0]) {
        HKEY key;
        WCHAR szPassword[MAX_PATH];
        DWORD len = sizeof(szPassword);
 
        lpwfs->lpszUserName = wcsdup(L"anonymous");
 
        RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", &key);
        if (RegQueryValueExW(key, L"EmailName", NULL, NULL, (LPBYTE)szPassword, &len)) {
            /* Nothing in the registry, get the username and use that as the password */
            if (!GetUserNameW(szPassword, &len)) {
                /* Should never get here, but use an empty password as failsafe */
                lstrcpyW(szPassword, L"");
            }
        }
        RegCloseKey(key);
 
        TRACE("Password used for anonymous ftp : (%s)\n", debugstr_w(szPassword));
        lpwfs->lpszPassword = wcsdup(szPassword);
    }
    else {
        lpwfs->lpszUserName = wcsdup(lpszUserName);
        lpwfs->lpszPassword = wcsdup(lpszPassword ? lpszPassword : L"");
    }
    lpwfs->servername = wcsdup(lpszServerName);
 
    /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
    if (!(lpwfs->hdr.dwInternalFlags & INET_OPENURL))
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (DWORD_PTR)lpwfs->hdr.hInternet;
        iar.dwError = ERROR_SUCCESS;
 
        INTERNET_SendCallback(&hIC->hdr, dwContext,
                      INTERNET_STATUS_HANDLE_CREATED, &iar,
                      sizeof(INTERNET_ASYNC_RESULT));
    }
        
    INTERNET_SendCallback(&hIC->hdr, dwContext, INTERNET_STATUS_RESOLVING_NAME,
        (LPWSTR) lpszServerName, (lstrlenW(lpszServerName)+1) * sizeof(WCHAR));
 
    sock_namelen = sizeof(socketAddr);
    if (!GetAddress(lpszServerName, lpwfs->serverport, (struct sockaddr *)&socketAddr, &sock_namelen, szaddr))
    {
    INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
        goto lerror;
    }
 
    if (socketAddr.sin_family != AF_INET)
    {
        WARN("unsupported address family %d\n", socketAddr.sin_family);
        INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
        goto lerror;
    }
 
    INTERNET_SendCallback(&hIC->hdr, dwContext, INTERNET_STATUS_NAME_RESOLVED,
                      szaddr, strlen(szaddr)+1);
 
    init_winsock();
    nsocket = socket(AF_INET,SOCK_STREAM,0);
    if (nsocket == -1)
    {
    INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
        goto lerror;
    }
 
    INTERNET_SendCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTING_TO_SERVER,
                      szaddr, strlen(szaddr)+1);
 
    if (connect(nsocket, (struct sockaddr *)&socketAddr, sock_namelen) < 0)
    {
    ERR("Unable to connect (%d)\n", WSAGetLastError());
    INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
    closesocket(nsocket);
    }
    else
    {
        TRACE("Connected to server\n");
    lpwfs->sndSocket = nsocket;
        INTERNET_SendCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTED_TO_SERVER,
                          szaddr, strlen(szaddr)+1);
 
    sock_namelen = sizeof(lpwfs->socketAddress);
    getsockname(nsocket, (struct sockaddr *) &lpwfs->socketAddress, &sock_namelen);
 
        if (FTP_ConnectToHost(lpwfs))
        {
            TRACE("Successfully logged into server\n");
            bSuccess = TRUE;
        }
    }
 
lerror:
    if (!bSuccess)
    {
        WININET_Release(&lpwfs->hdr);
        return NULL;
    }
 
    return lpwfs->hdr.hInternet;
}

Referenced by INTERNET_InternetOpenUrlW(), and InternetConnectW().

get_cookie_header()

DWORD get_cookie_header	(	const WCHAR *	host,
		const WCHAR *	path,
		WCHAR **	ret
	)

Definition at line 646 of file cookie.c.

{
    cookie_set_t cookie_set = {0};
    DWORD res;
 
    static const WCHAR cookieW[] = {'C','o','o','k','i','e',':',' '};
 
    EnterCriticalSection(&cookie_cs);
 
    res = get_cookie(substrz(host), substrz(path), INTERNET_COOKIE_HTTPONLY, &cookie_set);
    if(res != ERROR_SUCCESS) {
        LeaveCriticalSection(&cookie_cs);
        return res;
    }
 
    if(cookie_set.cnt) {
        WCHAR *header, *ptr;
 
        ptr = header = malloc(sizeof(cookieW) + (cookie_set.string_len + 3 /* crlf0 */) * sizeof(WCHAR));
        if(header) {
            memcpy(ptr, cookieW, sizeof(cookieW));
            ptr += ARRAY_SIZE(cookieW);
 
            cookie_set_to_string(&cookie_set, ptr);
            free(cookie_set.cookies);
            ptr += cookie_set.string_len;
 
            *ptr++ = '\r';
            *ptr++ = '\n';
            *ptr++ = 0;
 
            *ret = header;
        }else {
            res = ERROR_NOT_ENOUGH_MEMORY;
        }
    }else {
        *ret = NULL;
    }
 
    LeaveCriticalSection(&cookie_cs);
    return res;
}

Referenced by HTTP_InsertCookies().

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_server()

server_t * get_server	(	substr_t	name,
		INTERNET_PORT	port,
		BOOL	is_https,
		BOOL	do_create
	)

Definition at line 192 of file http.c.

{
    server_t *iter, *server = NULL;
 
    EnterCriticalSection(&connection_pool_cs);
 
    LIST_FOR_EACH_ENTRY(iter, &connection_pool, server_t, entry) {
        if(iter->port == port && name.len == lstrlenW(iter->name) && !wcsnicmp(iter->name, name.str, name.len)
                && iter->is_https == is_https) {
            server = iter;
            server_addref(server);
            break;
        }
    }
 
    if(!server && do_create) {
        server = calloc(1, sizeof(*server));
        if(server) {
            server->ref = 2; /* list reference and return */
            server->port = port;
            server->is_https = is_https;
            list_init(&server->conn_pool);
            server->name = strndupW(name.str, name.len);
            if(server->name && process_host_port(server)) {
                list_add_head(&connection_pool, &server->entry);
            }else {
                free(server);
                server = NULL;
            }
        }
    }
 
    LeaveCriticalSection(&connection_pool_cs);
 
    return server;
}

Referenced by HTTP_DealWithProxy(), HTTP_HandleRedirect(), and HTTP_HttpOpenRequestW().

GetAddress()

BOOL GetAddress	(	const WCHAR *	name,
		INTERNET_PORT	port,
		SOCKADDR *	psa,
		int *	sa_len,
		char *	addr_str
	)

Definition at line 47 of file utility.c.

{
    ADDRINFOW *res, hints;
    void *addr = NULL;
    int ret;
 
    TRACE("%s\n", debugstr_w(name));
 
    memset( &hints, 0, sizeof(hints) );
    /* Prefer IPv4 to IPv6 addresses, since some servers do not listen on
     * their IPv6 addresses even though they have IPv6 addresses in the DNS.
     */
    hints.ai_family = AF_INET;
 
    ret = GetAddrInfoW(name, NULL, &hints, &res);
    if (ret != 0)
    {
        TRACE("failed to get IPv4 address of %s, retrying with IPv6\n", debugstr_w(name));
        hints.ai_family = AF_INET6;
        ret = GetAddrInfoW(name, NULL, &hints, &res);
    }
    if (ret != 0)
    {
        TRACE("failed to get address of %s\n", debugstr_w(name));
        return FALSE;
    }
    if (*sa_len < res->ai_addrlen)
    {
        WARN("address too small\n");
        FreeAddrInfoW(res);
        return FALSE;
    }
    *sa_len = res->ai_addrlen;
    memcpy( psa, res->ai_addr, res->ai_addrlen );
    /* Copy port */
    switch (res->ai_family)
    {
    case AF_INET:
        addr = &((struct sockaddr_in *)psa)->sin_addr;
        ((struct sockaddr_in *)psa)->sin_port = htons(port);
        break;
    case AF_INET6:
        addr = &((struct sockaddr_in6 *)psa)->sin6_addr;
        ((struct sockaddr_in6 *)psa)->sin6_port = htons(port);
        break;
    }
 
    if(addr_str)
        inet_ntop(res->ai_family, addr, addr_str, INET6_ADDRSTRLEN);
    FreeAddrInfoW(res);
    return TRUE;
}

Referenced by DECLARE_INTERFACE_(), FTP_Connect(), HTTP_ResolveName(), and InternetCheckConnectionW().

HTTP_Connect()

DWORD HTTP_Connect	(	appinfo_t *	hIC,
		LPCWSTR	lpszServerName,
		INTERNET_PORT	nServerPort,
		LPCWSTR	lpszUserName,
		LPCWSTR	lpszPassword,
		DWORD	dwFlags,
		DWORD_PTR	dwContext,
		DWORD	dwInternalFlags,
		HINTERNET *	ret
	)

Definition at line 5910 of file http.c.

{
    http_session_t *session = NULL;
 
    TRACE("-->\n");
 
    if (!lpszServerName || !lpszServerName[0])
        return ERROR_INVALID_PARAMETER;
 
    assert( hIC->hdr.htype == WH_HINIT );
 
    session = alloc_object(&hIC->hdr, &HTTPSESSIONVtbl, sizeof(http_session_t));
    if (!session)
        return ERROR_OUTOFMEMORY;
 
   /*
    * According to my tests. The name is not resolved until a request is sent
    */
 
    session->hdr.htype = WH_HHTTPSESSION;
    session->hdr.dwFlags = dwFlags;
    session->hdr.dwContext = dwContext;
    session->hdr.dwInternalFlags |= dwInternalFlags;
    session->hdr.decoding = hIC->hdr.decoding;
 
    WININET_AddRef( &hIC->hdr );
    session->appInfo = hIC;
    list_add_head( &hIC->hdr.children, &session->hdr.entry );
 
    session->hostName = wcsdup(lpszServerName);
    if (lpszUserName && lpszUserName[0])
        session->userName = wcsdup(lpszUserName);
    session->password = wcsdup(lpszPassword);
    session->hostPort = serverPort;
    session->hdr.connect_timeout = hIC->hdr.connect_timeout;
    session->hdr.send_timeout = hIC->hdr.send_timeout;
    session->hdr.receive_timeout = hIC->hdr.receive_timeout;
 
    /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
    if (!(session->hdr.dwInternalFlags & INET_OPENURL))
    {
        INTERNET_SendCallback(&hIC->hdr, dwContext,
                              INTERNET_STATUS_HANDLE_CREATED, &session->hdr.hInternet,
                              sizeof(HINTERNET));
    }
 
/*
 * an INTERNET_STATUS_REQUEST_COMPLETE is NOT sent here as per my tests on
 * windows
 */
 
    TRACE("%p --> %p\n", hIC, session);
 
    *ret = session->hdr.hInternet;
    return ERROR_SUCCESS;
}

Referenced by INTERNET_InternetOpenUrlW(), and InternetConnectW().

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_urlcache()

BOOL init_urlcache

(

void

)

Definition at line 4106 of file urlcache.c.

{
    dll_unload_event = CreateEventW(NULL, FALSE, FALSE, NULL);
    if(!dll_unload_event)
        return FALSE;
 
    free_cache_running = CreateSemaphoreW(NULL, 1, 1, NULL);
    if(!free_cache_running) {
        CloseHandle(dll_unload_event);
        return FALSE;
    }
 
#ifndef __REACTOS__
    cache_containers_init();
#endif
    return TRUE;
}

Referenced by DllMain().

init_winsock()

void init_winsock

(

void

)

Definition at line 55 of file dpnet_main.c.

{
    static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
    InitOnceExecuteOnce(&init_once, winsock_startup, NULL, NULL);
}

Referenced by create_netconn_socket(), FTP_Connect(), FTP_InitListenSocket(), IDirectPlay8ClientImpl_Initialize(), IDirectPlay8LobbiedApplicationImpl_Initialize(), IDirectPlay8PeerImpl_Initialize(), IDirectPlay8ServerImpl_Initialize(), InternetCheckConnectionW(), InternetOpenW(), and lobbyclient_Initialize().

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_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_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_SendCallback()

VOID INTERNET_SendCallback	(	object_header_t *	hdr,
		DWORD_PTR	dwContext,
		DWORD	dwInternetStatus,
		LPVOID	lpvStatusInfo,
		DWORD	dwStatusInfoLength
	)

Referenced by async_read_file_proc(), FTP_Connect(), FTP_FtpCreateDirectoryW(), FTP_FtpDeleteFileW(), FTP_FtpFindFirstFileW(), FTP_FtpGetCurrentDirectoryW(), FTP_FtpGetFileW(), FTP_FtpOpenFileW(), FTP_FtpPutFileW(), FTP_FtpRemoveDirectoryW(), FTP_FtpRenameFileW(), FTP_FtpSetCurrentDirectoryW(), FTP_ReceiveRequestData(), FTP_ReceiveResponse(), FTPFINDNEXT_FindNextFileProc(), FTPSESSION_CloseConnection(), HTTP_Connect(), HTTP_HandleRedirect(), HTTP_HttpEndRequestW(), HTTP_HttpOpenRequestW(), HTTP_HttpSendRequestW(), http_release_netconn(), HTTP_ResolveName(), HTTPREQ_QueryDataAvailable(), HTTPREQ_ReadFile(), HTTPREQ_WriteFile(), open_http_connection(), send_request_complete(), and WININET_Release().

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().

is_valid_netconn()

BOOL is_valid_netconn

(

netconn_t *

netconn

)

Definition at line 375 of file netconnection.c.

{
    return netconn && netconn->socket != -1;
}

Referenced by drain_content(), HTTP_GetResponseHeaders(), HTTP_HttpEndRequestW(), http_release_netconn(), HTTPREQ_QueryOption(), HTTPREQ_SetOption(), netconn_end_of_data(), netconn_read(), open_http_connection(), and WININET_InvalidCertificateDialog().

NETCON_GetCert()

LPCVOID NETCON_GetCert

(

netconn_t *

connection

)

Definition at line 886 of file netconnection.c.

{
    const CERT_CONTEXT *ret;
    SECURITY_STATUS res;
 
    res = QueryContextAttributesW(&connection->ssl_ctx, SECPKG_ATTR_REMOTE_CERT_CONTEXT, (void*)&ret);
    return res == SEC_E_OK ? ret : NULL;
}

Referenced by get_security_cert_struct().

NETCON_GetCipherStrength()

int NETCON_GetCipherStrength

(

netconn_t *

connection

)

Definition at line 895 of file netconnection.c.

{
    SecPkgContext_ConnectionInfo conn_info;
    SECURITY_STATUS res;
 
    if (!connection->secure)
        return 0;
 
    res = QueryContextAttributesW(&connection->ssl_ctx, SECPKG_ATTR_CONNECTION_INFO, (void*)&conn_info);
    if(res != SEC_E_OK)
        WARN("QueryContextAttributesW failed: %08lx\n", res);
    return res == SEC_E_OK ? conn_info.dwCipherStrength : 0;
}

Referenced by get_security_cert_struct(), and netcon_secure_connect_setup().

NETCON_is_alive()

BOOL NETCON_is_alive

(

netconn_t *

netconn

)

Definition at line 875 of file netconnection.c.

{
    int len;
    char b;
 
    set_socket_blocking(netconn, FALSE);
    len = sock_recv(netconn->socket, &b, 1, MSG_PEEK);
 
    return len == 1 || (len == -1 && WSAGetLastError() == WSAEWOULDBLOCK);
}

Referenced by open_http_connection().

NETCON_recv()

DWORD NETCON_recv	(	netconn_t *	connection,
		void *	buf,
		size_t	len,
		BOOL	blocking,
		int *	recvd
	)

Definition at line 823 of file netconnection.c.

{
    *recvd = 0;
    if (!len)
        return ERROR_SUCCESS;
 
    if (!connection->secure)
    {
        set_socket_blocking(connection, blocking);
        *recvd = sock_recv(connection->socket, buf, len, 0);
        return *recvd == -1 ? WSAGetLastError() :  ERROR_SUCCESS;
    }
    else
    {
        SIZE_T size = 0;
        BOOL eof;
        DWORD res;
 
        if(connection->peek_msg) {
            size = min(len, connection->peek_len);
            memcpy(buf, connection->peek_msg, size);
            connection->peek_len -= size;
            connection->peek_msg += size;
 
            if(!connection->peek_len) {
                free(connection->peek_msg_mem);
                connection->peek_msg_mem = connection->peek_msg = NULL;
            }
 
            *recvd = size;
            return ERROR_SUCCESS;
        }
 
        do {
            res = read_ssl_chunk(connection, (BYTE*)buf, len, blocking, &size, &eof);
            if(res != ERROR_SUCCESS) {
                if(res == WSAEWOULDBLOCK) {
                    if(size)
                        res = ERROR_SUCCESS;
                }else {
                    WARN("read_ssl_chunk failed\n");
                }
                break;
            }
        }while(!size && !eof);
 
        TRACE("received %Id bytes\n", size);
        *recvd = size;
        return res;
    }
}

Referenced by chunked_read(), netconn_drain_content(), netconn_read(), and read_more_data().

NETCON_secure_connect()

DWORD NETCON_secure_connect	(	netconn_t *	connection,
		server_t *	server
	)

Definition at line 603 of file netconnection.c.

{
    DWORD res;
 
    /* can't connect if we are already connected */
    if(connection->secure) {
        ERR("already connected\n");
        return ERROR_INTERNET_CANNOT_CONNECT;
    }
 
    if(server != connection->server) {
        server_release(connection->server);
        server_addref(server);
        connection->server = server;
    }
 
    /* connect with given TLS options */
    res = netcon_secure_connect_setup(connection, FALSE);
    if (res == ERROR_SUCCESS)
        return res;
 
    /* FIXME: when got version alert and FIN from server */
    /* fallback to connect without TLSv1.1/TLSv1.2        */
    if (res == ERROR_INTERNET_SECURITY_CHANNEL_ERROR && have_compat_cred_handle)
    {
        closesocket(connection->socket);
        res = create_netconn_socket(connection->server, connection, 500);
        if (res != ERROR_SUCCESS)
            return res;
        res = netcon_secure_connect_setup(connection, TRUE);
    }
    return res;
}

Referenced by HTTP_HttpSendRequestW().

NETCON_send()

DWORD NETCON_send	(	netconn_t *	connection,
		const void *	msg,
		size_t	len,
		int	flags,
		int *	sent
	)

Definition at line 668 of file netconnection.c.

{
    /* send is always blocking. */
    set_socket_blocking(connection, TRUE);
 
    if(!connection->secure)
    {
    *sent = sock_send(connection->socket, msg, len, flags);
        return *sent == -1 ? WSAGetLastError() : ERROR_SUCCESS;
    }
    else
    {
        const BYTE *ptr = msg;
        size_t chunk_size;
 
        *sent = 0;
 
        while(len) {
            chunk_size = min(len, connection->ssl_sizes.cbMaximumMessage);
            if(!send_ssl_chunk(connection, ptr, chunk_size))
                return ERROR_INTERNET_SECURITY_CHANNEL_ERROR;
 
            *sent += chunk_size;
            ptr += chunk_size;
            len -= chunk_size;
        }
 
        return ERROR_SUCCESS;
    }
}

Referenced by HTTP_HttpSendRequestW(), and HTTPREQ_WriteFile().

NETCON_set_timeout()

DWORD NETCON_set_timeout	(	netconn_t *	connection,
		BOOL	send,
		DWORD	value
	)

Definition at line 909 of file netconnection.c.

{
    int result;
 
    result = setsockopt(connection->socket, SOL_SOCKET,
                        send ? SO_SNDTIMEO : SO_RCVTIMEO, (void*)&value,
                        sizeof(value));
    if (result == -1)
    {
        WARN("setsockopt failed\n");
        return WSAGetLastError();
    }
    return ERROR_SUCCESS;
}

Referenced by HTTP_GetResponseHeaders(), and HTTP_HttpSendRequestW().

NETCON_unload()

void NETCON_unload

(

void

)

Definition at line 408 of file netconnection.c.

{
    if(cred_handle_initialized)
        FreeCredentialsHandle(&cred_handle);
    if(have_compat_cred_handle)
        FreeCredentialsHandle(&compat_cred_handle);
    DeleteCriticalSection(&init_sechandle_cs);
    if(winsock_loaded)
        WSACleanup();
}

Referenced by DllMain().

req_file_addref()

static req_file_t * req_file_addref ( req_file_t *  req_file )

inlinestatic

Definition at line 417 of file internet.h.

{
    InterlockedIncrement(&req_file->ref);
    return req_file;
}

Referenced by HTTPREQ_LockRequestFile().

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().

server_addref()

void server_addref

(

server_t *

server

)

Definition at line 143 of file http.c.

{
    InterlockedIncrement(&server->ref);
}

Referenced by create_netconn(), get_server(), and NETCON_secure_connect().

server_release()

void server_release

(

server_t *

server

)

Definition at line 148 of file http.c.

{
    if(InterlockedDecrement(&server->ref))
        return;
 
#ifdef __REACTOS__
    EnterCriticalSection(&connection_pool_cs);
#endif
    list_remove(&server->entry);
#ifdef __REACTOS__
    LeaveCriticalSection(&connection_pool_cs);
#endif
 
    if(server->cert_chain)
        CertFreeCertificateChain(server->cert_chain);
    free(server->name);
    free(server->scheme_host_port);
    free(server);
}

Referenced by collect_connections(), free_netconn(), HTTP_HandleRedirect(), HTTPREQ_Destroy(), InternetGetSecurityInfoByURLW(), and NETCON_secure_connect().

set_cookie()

DWORD set_cookie	(	substr_t	domain,
		substr_t	path,
		substr_t	name,
		substr_t	data,
		DWORD	flags
	)

Definition at line 912 of file cookie.c.

{
    cookie_container_t *container;
    cookie_t *thisCookie;
    substr_t value;
    const WCHAR *end_ptr;
    FILETIME expiry, create;
    BOOL expired = FALSE, update_persistent = FALSE;
    DWORD cookie_flags = 0, len;
 
    TRACE("%s %s %s=%s %lx\n", debugstr_wn(domain.str, domain.len), debugstr_wn(path.str, path.len),
          debugstr_wn(name.str, name.len), debugstr_wn(data.str, data.len), flags);
 
    memset(&expiry,0,sizeof(expiry));
    GetSystemTimeAsFileTime(&create);
 
    /* lots of information can be parsed out of the cookie value */
 
    if(!(end_ptr = wmemchr(data.str, ';', data.len)))
       end_ptr = data.str + data.len;
    value = substr(data.str, end_ptr-data.str);
    data.str += value.len;
    data.len -= value.len;
 
    for(;;) {
        static const WCHAR szDomain[] = {'d','o','m','a','i','n','='};
        static const WCHAR szPath[] = {'p','a','t','h','='};
        static const WCHAR szExpires[] = {'e','x','p','i','r','e','s','='};
        static const WCHAR szSecure[] = {'s','e','c','u','r','e'};
        static const WCHAR szHttpOnly[] = {'h','t','t','p','o','n','l','y'};
        static const WCHAR szVersion[] = {'v','e','r','s','i','o','n','='};
        static const WCHAR max_ageW[] = {'m','a','x','-','a','g','e','='};
 
        /* Skip ';' */
        if(data.len)
            substr_skip(&data, 1);
 
        while(data.len && *data.str == ' ')
            substr_skip(&data, 1);
 
        if(!data.len)
            break;
 
        if(!(end_ptr = wmemchr(data.str, ';', data.len)))
            end_ptr = data.str + data.len;
 
        if(data.len >= (len = ARRAY_SIZE(szDomain)) && !wcsnicmp(data.str, szDomain, len)) {
            substr_skip(&data, len);
 
            if(data.len && *data.str == '.')
                substr_skip(&data, 1);
 
            if(!is_domain_legal_for_cookie(substr(data.str, end_ptr-data.str), domain))
                return COOKIE_STATE_UNKNOWN;
 
            domain = substr(data.str, end_ptr-data.str);
            TRACE("Parsing new domain %s\n", debugstr_wn(domain.str, domain.len));
        }else if(data.len >= (len = ARRAY_SIZE(szPath)) && !wcsnicmp(data.str, szPath, len)) {
            substr_skip(&data, len);
            path = substr(data.str, end_ptr - data.str);
            TRACE("Parsing new path %s\n", debugstr_wn(path.str, path.len));
        }else if(data.len >= (len = ARRAY_SIZE(szExpires)) && !wcsnicmp(data.str, szExpires, len)) {
            SYSTEMTIME st;
            WCHAR buf[128];
 
            substr_skip(&data, len);
 
            if(end_ptr > data.str && (end_ptr - data.str < ARRAY_SIZE(buf) - 1)) {
                memcpy(buf, data.str, data.len*sizeof(WCHAR));
                buf[data.len] = 0;
 
                if (InternetTimeToSystemTimeW(data.str, &st, 0)) {
                    SystemTimeToFileTime(&st, &expiry);
 
                    if (CompareFileTime(&create,&expiry) > 0) {
                        TRACE("Cookie already expired.\n");
                        expired = TRUE;
                    }
                }
            }
        }else if(data.len >= (len = ARRAY_SIZE(szSecure)) && !wcsnicmp(data.str, szSecure, len)) {
            substr_skip(&data, len);
            FIXME("secure not handled\n");
        }else if(data.len >= (len = ARRAY_SIZE(szHttpOnly)) && !wcsnicmp(data.str, szHttpOnly, len)) {
            substr_skip(&data, len);
 
            if(!(flags & INTERNET_COOKIE_HTTPONLY)) {
                WARN("HTTP only cookie added without INTERNET_COOKIE_HTTPONLY flag\n");
                SetLastError(ERROR_INVALID_OPERATION);
                return COOKIE_STATE_REJECT;
            }
 
            cookie_flags |= INTERNET_COOKIE_HTTPONLY;
        }else if(data.len >= (len = ARRAY_SIZE(szVersion)) && !wcsnicmp(data.str, szVersion, len)) {
            substr_skip(&data, len);
 
            FIXME("version not handled (%s)\n",debugstr_wn(data.str, data.len));
        }else if(data.len >= (len = ARRAY_SIZE(max_ageW)) && !wcsnicmp(data.str, max_ageW, len)) {
            /* Native doesn't support Max-Age attribute. */
            WARN("Max-Age ignored\n");
        }else if(data.len) {
            FIXME("Unknown additional option %s\n", debugstr_wn(data.str, data.len));
        }
 
        substr_skip(&data, end_ptr - data.str);
    }
 
    EnterCriticalSection(&cookie_cs);
 
    load_persistent_cookie(domain, path);
 
    container = get_cookie_container(domain, path, !expired);
    if(!container) {
        LeaveCriticalSection(&cookie_cs);
        return COOKIE_STATE_ACCEPT;
    }
 
    if(!expiry.dwLowDateTime && !expiry.dwHighDateTime)
        cookie_flags |= INTERNET_COOKIE_IS_SESSION;
    else
        update_persistent = TRUE;
 
    if ((thisCookie = find_cookie(container, name))) {
        if ((thisCookie->flags & INTERNET_COOKIE_HTTPONLY) && !(flags & INTERNET_COOKIE_HTTPONLY)) {
            WARN("An attempt to override httponly cookie\n");
            SetLastError(ERROR_INVALID_OPERATION);
            LeaveCriticalSection(&cookie_cs);
            return COOKIE_STATE_REJECT;
        }
 
        if (!(thisCookie->flags & INTERNET_COOKIE_IS_SESSION))
            update_persistent = TRUE;
        delete_cookie(thisCookie);
    }
 
    TRACE("setting cookie %s=%s for domain %s path %s\n", debugstr_wn(name.str, name.len),
          debugstr_wn(value.str, value.len), debugstr_w(container->domain->domain),
          debugstr_wn(container->path.str, container->path.len));
 
    if (!expired) {
        cookie_t *new_cookie;
 
        new_cookie = alloc_cookie(name, value, expiry, create, cookie_flags);
        if(!new_cookie) {
            LeaveCriticalSection(&cookie_cs);
            return COOKIE_STATE_UNKNOWN;
        }
 
        add_cookie(container, new_cookie);
    }
 
    if (!update_persistent || save_persistent_cookie(container))
    {
        LeaveCriticalSection(&cookie_cs);
        return COOKIE_STATE_ACCEPT;
    }
    LeaveCriticalSection(&cookie_cs);
    return COOKIE_STATE_UNKNOWN;
}

Referenced by HTTP_ProcessCookies(), InternetSetCookieExW(), and record_cookies().

sock_recv()

int sock_recv	(	int	fd,
		void *	msg,
		size_t	len,
		int	flags
	)

Definition at line 430 of file netconnection.c.

{
    int ret;
    do
    {
        ret = recv(fd, msg, len, flags);
    }
    while(ret == -1 && WSAGetLastError() == WSAEINTR);
    return ret;
}

Referenced by NETCON_is_alive(), NETCON_recv(), netcon_secure_connect_setup(), and read_ssl_chunk().

sock_send()

int sock_send	(	int	fd,
		const void *	msg,
		size_t	len,
		int	flags
	)

Definition at line 419 of file netconnection.c.

{
    int ret;
    do
    {
        ret = send(fd, msg, len, flags);
    }
    while(ret == -1 && WSAGetLastError() == WSAEINTR);
    return ret;
}

Referenced by netcon_secure_connect_setup(), NETCON_send(), and send_ssl_chunk().

strdupAtoW()

static WCHAR * strdupAtoW ( const char *  str )

inlinestatic

Definition at line 134 of file internet.h.

{
    LPWSTR ret = NULL;
 
    if(str) {
        DWORD len;
 
        len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
        ret = malloc(len * sizeof(WCHAR));
        if(ret)
            MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
    }
 
    return ret;
}

strdupWtoA()

static char * strdupWtoA ( const WCHAR *  str )

inlinestatic

Definition at line 150 of file internet.h.

{
    char *ret = NULL;
 
    if(str) {
        DWORD size = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
        ret = malloc(size);
        if(ret)
            WideCharToMultiByte(CP_ACP, 0, str, -1, ret, size, NULL, NULL);
    }
 
    return ret;
}

strndupAtoW()

static WCHAR * strndupAtoW ( const char *  str, int  len_a, DWORD *  len_w  )

inlinestatic

Definition at line 112 of file internet.h.

{
    WCHAR *ret = NULL;
 
    if(str) {
        size_t len;
        if(len_a < 0)
            len_a = strlen(str);
        else if(len_a > 0)
            len_a = strnlen(str, len_a);
        len = MultiByteToWideChar(CP_ACP, 0, str, len_a, NULL, 0);
        ret = malloc((len + 1) * sizeof(WCHAR));
        if(ret) {
            MultiByteToWideChar(CP_ACP, 0, str, len_a, ret, len);
            ret[len] = 0;
            *len_w = len;
        }
    }
 
    return ret;
}

Referenced by HttpAddRequestHeadersA(), InternetCrackUrlA(), InternetOpenUrlA(), and retrieve_cached_basic_authorization().

strndupW()

static WCHAR * strndupW ( const WCHAR *  str, UINT  max_len  )

inlinestatic

Definition at line 91 of file internet.h.

{
    LPWSTR ret;
    UINT len;
 
    if(!str)
        return NULL;
 
    for(len=0; len<max_len; len++)
        if(str[len] == '\0')
            break;
 
    ret = malloc(sizeof(WCHAR) * (len + 1));
    if(ret) {
        memcpy(ret, str, sizeof(WCHAR)*len);
        ret[len] = '\0';
    }
 
    return ret;
}

substr()

static substr_t substr ( const WCHAR *  str, size_t  len  )

inlinestatic

Definition at line 169 of file internet.h.

{
    substr_t r = {str, len};
    return r;
}

Referenced by _wcscats(), cookie_parse_url(), get_cookie(), HTTP_DealWithProxy(), HTTP_HandleRedirect(), HTTP_ProcessCookies(), HTTP_ShouldBypassProxy(), InternetGetSecurityInfoByURLW(), InternetSetCookieExW(), load_persistent_cookie(), pbuf_strstr(), set_cookie(), substrz(), and test_substring().

substrz()

static substr_t substrz ( const WCHAR *  str )

inlinestatic

Definition at line 175 of file internet.h.

{
    return substr(str, lstrlenW(str));
}

Referenced by get_cookie_container(), get_cookie_header(), HTTP_HttpOpenRequestW(), HTTP_ProcessCookies(), InternetSetCookieExW(), IsDomainLegalCookieDomainW(), and replace_cookie().

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_find_data_WtoA()

static void WININET_find_data_WtoA ( LPWIN32_FIND_DATAW  dataW, LPWIN32_FIND_DATAA  dataA  )

inlinestatic

Definition at line 180 of file internet.h.

{
    dataA->dwFileAttributes = dataW->dwFileAttributes;
    dataA->ftCreationTime   = dataW->ftCreationTime;
    dataA->ftLastAccessTime = dataW->ftLastAccessTime;
    dataA->ftLastWriteTime  = dataW->ftLastWriteTime;
    dataA->nFileSizeHigh    = dataW->nFileSizeHigh;
    dataA->nFileSizeLow     = dataW->nFileSizeLow;
    dataA->dwReserved0      = dataW->dwReserved0;
    dataA->dwReserved1      = dataW->dwReserved1;
    WideCharToMultiByte(CP_ACP, 0, dataW->cFileName, -1, 
        dataA->cFileName, sizeof(dataA->cFileName),
        NULL, NULL);
    WideCharToMultiByte(CP_ACP, 0, dataW->cAlternateFileName, -1, 
        dataA->cAlternateFileName, sizeof(dataA->cAlternateFileName),
        NULL, NULL);
}

Referenced by FtpFindFirstFileA(), and InternetFindNextFileA().

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

WININET_hModule

HMODULE WININET_hModule

extern

Definition at line 71 of file internet.c.

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