internet.h File Reference

#include "wine/heap.h"
#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   0x5B4
#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 *) DECLSPEC_HIDDEN
void	server_release (server_t *) DECLSPEC_HIDDEN
BOOL	collect_connections (collect_type_t) DECLSPEC_HIDDEN
BOOL	is_valid_netconn (netconn_t *) DECLSPEC_HIDDEN
void	close_netconn (netconn_t *) DECLSPEC_HIDDEN
static void *	__WINE_ALLOC_SIZE (2) heap_realloc_zero(void *mem
static LPWSTR	heap_strdupW (LPCWSTR str)
static char *	heap_strdupA (const char *str)
static LPWSTR	heap_strndupW (LPCWSTR str, UINT max_len)
static WCHAR *	heap_strndupAtoW (const char *str, int len_a, DWORD *len_w)
static WCHAR *	heap_strdupAtoW (const char *str)
static char *	heap_strdupWtoA (LPCWSTR 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) DECLSPEC_HIDDEN
void *	alloc_object (object_header_t *, const object_vtbl_t *, size_t) DECLSPEC_HIDDEN
object_header_t *	get_handle_object (HINTERNET hinternet) DECLSPEC_HIDDEN
object_header_t *	WININET_AddRef (object_header_t *info) DECLSPEC_HIDDEN
BOOL	WININET_Release (object_header_t *info) DECLSPEC_HIDDEN
DWORD	INET_QueryOption (object_header_t *, DWORD, void *, DWORD *, BOOL) DECLSPEC_HIDDEN
DWORD	INET_SetOption (object_header_t *, DWORD, void *, DWORD) DECLSPEC_HIDDEN
time_t	ConvertTimeString (LPCWSTR asctime) DECLSPEC_HIDDEN
HINTERNET	FTP_Connect (appinfo_t *hIC, LPCWSTR lpszServerName, INTERNET_PORT nServerPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext, DWORD dwInternalFlags) DECLSPEC_HIDDEN
DWORD	HTTP_Connect (appinfo_t *, LPCWSTR, INTERNET_PORT nServerPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext, DWORD dwInternalFlags, HINTERNET *) DECLSPEC_HIDDEN
BOOL	GetAddress (const WCHAR *, INTERNET_PORT, SOCKADDR *, int *, char *) DECLSPEC_HIDDEN
DWORD	get_cookie_header (const WCHAR *, const WCHAR *, WCHAR **) DECLSPEC_HIDDEN
DWORD	set_cookie (substr_t, substr_t, substr_t, substr_t, DWORD) DECLSPEC_HIDDEN
void	INTERNET_SetLastError (DWORD dwError) DECLSPEC_HIDDEN
DWORD	INTERNET_GetLastError (void) DECLSPEC_HIDDEN
DWORD	INTERNET_AsyncCall (task_header_t *) DECLSPEC_HIDDEN
LPSTR	INTERNET_GetResponseBuffer (void) DECLSPEC_HIDDEN
VOID	INTERNET_SendCallback (object_header_t *hdr, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInfo, DWORD dwStatusInfoLength) DECLSPEC_HIDDEN
WCHAR *	INTERNET_FindProxyForProtocol (LPCWSTR szProxy, LPCWSTR proto) DECLSPEC_HIDDEN
DWORD	create_netconn (server_t *, DWORD, BOOL, DWORD, netconn_t **) DECLSPEC_HIDDEN
void	free_netconn (netconn_t *) DECLSPEC_HIDDEN
void	NETCON_unload (void) DECLSPEC_HIDDEN
DWORD	NETCON_secure_connect (netconn_t *, server_t *) DECLSPEC_HIDDEN
DWORD	NETCON_send (netconn_t *connection, const void *msg, size_t len, int flags, int *sent) DECLSPEC_HIDDEN
DWORD	NETCON_recv (netconn_t *, void *, size_t, BOOL, int *) DECLSPEC_HIDDEN
BOOL	NETCON_is_alive (netconn_t *) DECLSPEC_HIDDEN
LPCVOID	NETCON_GetCert (netconn_t *connection) DECLSPEC_HIDDEN
int	NETCON_GetCipherStrength (netconn_t *) DECLSPEC_HIDDEN
DWORD	NETCON_set_timeout (netconn_t *connection, BOOL send, DWORD value) DECLSPEC_HIDDEN
int	sock_send (int fd, const void *msg, size_t len, int flags) DECLSPEC_HIDDEN
int	sock_recv (int fd, void *msg, size_t len, int flags) DECLSPEC_HIDDEN
server_t *	get_server (substr_t, INTERNET_PORT, BOOL, BOOL) DECLSPEC_HIDDEN
DWORD	create_req_file (const WCHAR *, req_file_t **) DECLSPEC_HIDDEN
void	req_file_release (req_file_t *) DECLSPEC_HIDDEN
static req_file_t *	req_file_addref (req_file_t *req_file)
BOOL	init_urlcache (void) DECLSPEC_HIDDEN
void	free_urlcache (void) DECLSPEC_HIDDEN
void	free_cookie (void) DECLSPEC_HIDDEN
void	free_authorization_cache (void) DECLSPEC_HIDDEN
void	init_winsock (void) DECLSPEC_HIDDEN

Variables
HMODULE WININET_hModule	DECLSPEC_HIDDEN
static void size_t	len

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 477 of file internet.h.

_SECURITY_FLAG_CERT_INVALID_CA

#define _SECURITY_FLAG_CERT_INVALID_CA   0x01000000

Definition at line 473 of file internet.h.

_SECURITY_FLAG_CERT_INVALID_CN

#define _SECURITY_FLAG_CERT_INVALID_CN   0x02000000

Definition at line 474 of file internet.h.

_SECURITY_FLAG_CERT_INVALID_DATE

#define _SECURITY_FLAG_CERT_INVALID_DATE   0x04000000

Definition at line 475 of file internet.h.

_SECURITY_FLAG_CERT_REV_FAILED

#define _SECURITY_FLAG_CERT_REV_FAILED   0x00800000

Definition at line 472 of file internet.h.

HDR_COMMADELIMITED

#define HDR_COMMADELIMITED   0x0002

Definition at line 315 of file internet.h.

HDR_ISREQUEST

#define HDR_ISREQUEST   0x0001

Definition at line 314 of file internet.h.

HDR_SEMIDELIMITED

#define HDR_SEMIDELIMITED   0x0004

Definition at line 316 of file internet.h.

INET_CALLBACKW

#define INET_CALLBACKW   0x0002

Definition at line 244 of file internet.h.

INET_OPENURL

#define INET_OPENURL   0x0001

Definition at line 243 of file internet.h.

INTERNET_HANDLE_IN_USE

#define INTERNET_HANDLE_IN_USE   1

Definition at line 269 of file internet.h.

MAX_REPLY_LEN

#define MAX_REPLY_LEN   0x5B4

Definition at line 462 of file internet.h.

READ_BUFFER_SIZE

#define READ_BUFFER_SIZE   8192

Definition at line 341 of file internet.h.

Typedef Documentation

async_task_proc_t

typedef void(* async_task_proc_t) (task_header_t *)

Definition at line 385 of file internet.h.

data_stream_vtbl_t

typedef struct data_stream_vtbl_t data_stream_vtbl_t

Definition at line 329 of file internet.h.

LPHTTPHEADERW

typedef struct HTTPHEADERW * LPHTTPHEADERW

object_header_t

typedef struct _object_header_t object_header_t

Definition at line 255 of file internet.h.

task_header_t

typedef struct task_header_t task_header_t

Definition at line 384 of file internet.h.

Enumeration Type Documentation

collect_type_t

enum collect_type_t

Enumerator
COLLECT_TIMEOUT
COLLECT_CONNECTIONS
COLLECT_CLEANUP

Definition at line 59 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 232 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

__WINE_ALLOC_SIZE()

static void * __WINE_ALLOC_SIZE ( 2  )

inlinestatic

alloc_async_task()

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

Definition at line 3894 of file internet.c.

{
    task_header_t *task;
 
    task = heap_alloc(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 103 of file internet.c.

{
    UINT_PTR handle = 0, num;
    object_header_t *ret;
    object_header_t **p;
    BOOL res = TRUE;
 
    ret = heap_alloc_zero(size);
    if(!ret)
        return NULL;
 
    list_init(&ret->children);
 
    EnterCriticalSection( &WININET_cs );
 
    if(!handle_table_size) {
        num = 16;
        p = heap_alloc_zero(sizeof(handle_table[0]) * num);
        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 = heap_realloc_zero(handle_table, sizeof(handle_table[0]) * num);
        if(p) {
            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) {
        heap_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;
    }
 
    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 379 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 235 of file http.c.

{
    netconn_t *netconn, *netconn_safe;
    server_t *server, *server_safe;
    BOOL remaining = FALSE;
    DWORD64 now;
 
#ifdef __REACTOS__
    now = GetTickCount();
#else
    now = GetTickCount64();
#endif
 
    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

)

Definition at line 49 of file utility.c.

{
    WCHAR tmpChar[TIME_STRING_LEN];
    WCHAR *tmpChar2;
    struct tm t;
    int timelen = lstrlenW(asctime);
 
    if(!timelen)
        return 0;
 
    /* FIXME: the atoiWs below rely on that tmpChar is \0 padded */
    memset( tmpChar, 0, sizeof(tmpChar) );
    lstrcpynW(tmpChar, asctime, TIME_STRING_LEN);
 
    /* Assert that the string is the expected length */
    if (lstrlenW(asctime) >= TIME_STRING_LEN) FIXME("\n");
 
    /* Convert a time such as 'Mon, 15 Nov 1999 16:09:35 GMT' into a SYSTEMTIME structure
     * We assume the time is in this format
     * and divide it into easy to swallow chunks
     */
    tmpChar[3]='\0';
    tmpChar[7]='\0';
    tmpChar[11]='\0';
    tmpChar[16]='\0';
    tmpChar[19]='\0';
    tmpChar[22]='\0';
    tmpChar[25]='\0';
 
    memset( &t, 0, sizeof(t) );
    t.tm_year = wcstol(tmpChar+12, NULL, 10) - 1900;
    t.tm_mday = wcstol(tmpChar+5, NULL, 10);
    t.tm_hour = wcstol(tmpChar+17, NULL, 10);
    t.tm_min = wcstol(tmpChar+20, NULL, 10);
    t.tm_sec = wcstol(tmpChar+23, NULL, 10);
 
    /* and month */
    tmpChar2 = tmpChar + 8;
    switch(tmpChar2[2])
    {
        case 'n':
            if(tmpChar2[1]=='a')
                t.tm_mon = 0;
            else
                t.tm_mon = 5;
            break;
        case 'b':
            t.tm_mon = 1;
            break;
        case 'r':
            if(tmpChar2[1]=='a')
                t.tm_mon = 2;
            else
                t.tm_mon = 3;
            break;
        case 'y':
            t.tm_mon = 4;
            break;
        case 'l':
            t.tm_mon = 6;
            break;
        case 'g':
            t.tm_mon = 7;
            break;
        case 'p':
            t.tm_mon = 8;
            break;
        case 't':
            t.tm_mon = 9;
            break;
        case 'v':
            t.tm_mon = 10;
            break;
        case 'c':
            t.tm_mon = 11;
            break;
        default:
            FIXME("\n");
    }
 
    return mktime(&t);
}

Referenced by HTTP_HttpQueryInfoW().

create_netconn()

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

Definition at line 347 of file netconnection.c.

{
    netconn_t *netconn;
    int result;
 
    netconn = heap_alloc_zero(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) {
        heap_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 3988 of file internet.c.

{
    req_file_t *req_file;
 
    req_file = heap_alloc_zero(sizeof(*req_file));
    if(!req_file)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    req_file->ref = 1;
 
    req_file->file_name = heap_strdupW(file_name);
    if(!req_file->file_name) {
        heap_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 943 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)
    {
        heap_free(basic->host);
        heap_free(basic->realm);
        heap_free(basic->authorization);
 
        list_remove(&basic->entry);
        heap_free(basic);
    }
 
    LIST_FOR_EACH_ENTRY_SAFE(ad, sa_safe, &authorizationCache, authorizationData, entry)
    {
        heap_free(ad->host);
        heap_free(ad->scheme);
        heap_free(ad->user);
        heap_free(ad->password);
        heap_free(ad->domain);
        list_remove(&ad->entry);
        heap_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 385 of file netconnection.c.

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

Referenced by collect_connections(), and open_http_connection().

free_urlcache()

void free_urlcache

(

void

)

Definition at line 4130 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 2428 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 = heap_strdupW(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 = heap_strdupW(szPassword);
    }
    else {
        lpwfs->lpszUserName = heap_strdupW(lpszUserName);
        lpwfs->lpszPassword = heap_strdupW(lpszPassword ? lpszPassword : L"");
    }
    lpwfs->servername = heap_strdupW(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 = heap_alloc(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);
            heap_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 176 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 %ld -> %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(), 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 198 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 = heap_alloc_zero(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 = heap_strndupW(name.str, name.len);
            if(server->name && process_host_port(server)) {
                list_add_head(&connection_pool, &server->entry);
            }else {
                heap_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 133 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 FTP_Connect(), HTTP_ResolveName(), and InternetCheckConnectionW().

heap_strdupA()

static char * heap_strdupA ( const char *  str )

inlinestatic

Definition at line 113 of file internet.h.

{
    char *ret = NULL;
 
    if(str) {
        DWORD size = strlen(str)+1;
 
        ret = heap_alloc(size);
        if(ret)
            memcpy(ret, str, size);
    }
 
    return ret;
}

heap_strdupAtoW()

static WCHAR * heap_strdupAtoW ( const char *  str )

inlinestatic

Definition at line 168 of file internet.h.

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

heap_strdupW()

static LPWSTR heap_strdupW ( LPCWSTR  str )

inlinestatic

Definition at line 97 of file internet.h.

{
    LPWSTR ret = NULL;
 
    if(str) {
        DWORD size;
 
        size = (lstrlenW(str)+1)*sizeof(WCHAR);
        ret = heap_alloc(size);
        if(ret)
            memcpy(ret, str, size);
    }
 
    return ret;
}

heap_strdupWtoA()

static char * heap_strdupWtoA ( LPCWSTR  str )

inlinestatic

Definition at line 184 of file internet.h.

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

heap_strndupAtoW()

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

inlinestatic

Definition at line 149 of file internet.h.

{
    WCHAR *ret = NULL;
 
    if(str) {
        size_t len;
        if(len_a < 0) len_a = strlen(str);
        len = MultiByteToWideChar(CP_ACP, 0, str, len_a, NULL, 0);
        ret = heap_alloc((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().

heap_strndupW()

static LPWSTR heap_strndupW ( LPCWSTR  str, UINT  max_len  )

inlinestatic

Definition at line 128 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 = heap_alloc(sizeof(WCHAR)*(len+1));
    if(ret) {
        memcpy(ret, str, sizeof(WCHAR)*len);
        ret[len] = '\0';
    }
 
    return ret;
}

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 5836 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 = heap_strdupW(lpszServerName);
    if (lpszUserName && lpszUserName[0])
        session->userName = heap_strdupW(lpszUserName);
    session->password = heap_strdupW(lpszPassword);
    session->hostPort = serverPort;
    session->connect_timeout = hIC->connect_timeout;
    session->send_timeout = 0;
    session->receive_timeout = 0;
 
    /* 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 2654 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 %u\n", option);
        return ERROR_INTERNET_INVALID_OPERATION;
    }
 
    /* 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 2753 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 %u\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 %u\n", option);
        return ERROR_INTERNET_INVALID_OPERATION;
    case INTERNET_OPTION_REFRESH:
        return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
    }
 
    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 4112 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 281 of file netconnection.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(), InternetCheckConnectionW(), and InternetOpenW().

INTERNET_AsyncCall()

DWORD INTERNET_AsyncCall

(

task_header_t *

task

)

Definition at line 3915 of file internet.c.

{
    BOOL bSuccess;
 
    TRACE("\n");
 
    bSuccess = QueueUserWorkItem(INTERNET_WorkerThreadFunc, task, WT_EXECUTELONGFUNCTION);
    if (!bSuccess)
    {
        heap_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 384 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 = heap_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 = heap_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 3858 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 3937 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 3837 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 374 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 887 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 896 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: %08x\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 876 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 824 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) {
                heap_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 %ld 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 604 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 669 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 910 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 407 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 449 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 4015 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);
    heap_free(req_file->file_name);
    heap_free(req_file->url);
    heap_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 149 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 154 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);
    heap_free(server->name);
    heap_free(server->scheme_host_port);
    heap_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 %x\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 429 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 418 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().

substr()

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

inlinestatic

Definition at line 203 of file internet.h.

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

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

substrz()

static substr_t substrz ( const WCHAR *  str )

inlinestatic

Definition at line 209 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 169 of file internet.c.

{
    ULONG refs = InterlockedIncrement(&info->refs);
    TRACE("%p -> refcount = %d\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 214 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 211 of file internet.c.

{
    ULONG refs = InterlockedDecrement(&info->refs);
    TRACE( "object %p refcount = %d\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 );
        }
 
        heap_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(), InternetSetOptionW(), InternetSetStatusCallbackA(), InternetSetStatusCallbackW(), InternetWriteFile(), and invalidate_handle().

Variable Documentation

DECLSPEC_HIDDEN

HMODULE WININET_hModule DECLSPEC_HIDDEN

extern

Definition at line 289 of file d3dcompiler_private.h.

len

void size_t len

Initial value:

{
    return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, len)

Definition at line 92 of file internet.h.

Referenced by heap_strdupAtoW(), heap_strndupAtoW(), and heap_strndupW().