http.c File Reference

#include <stdlib.h>
#include "winsock2.h"
#include "ws2ipdef.h"
#include <stdarg.h>
#include <stdio.h>
#include <time.h>
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include "windef.h"
#include "winbase.h"
#include "wininet.h"
#include "winerror.h"
#include "winternl.h"
#include "shlwapi.h"
#include "sspi.h"
#include "wincrypt.h"
#include "winuser.h"
#include "internet.h"
#include "zlib.h"
#include "resource.h"
#include "wine/debug.h"
#include "wine/exception.h"

Include dependency graph for http.c:

Go to the source code of this file.

Classes
struct	HttpAuthInfo
struct	_basicAuthorizationData
struct	_authorizationData
struct	data_stream_vtbl_t
struct	chunked_stream_t
struct	gzip_stream_t
struct	read_file_task_t
struct	send_request_task_t
struct	end_request_task_t

Macros
#define	NO_SHLWAPI_STREAM
#define	NO_SHLWAPI_REG
#define	NO_SHLWAPI_GDI
#define	HTTP_ADDHDR_FLAG_ADD   0x20000000
#define	HTTP_ADDHDR_FLAG_ADD_IF_NEW   0x10000000
#define	HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA   0x40000000
#define	HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON   0x01000000
#define	HTTP_ADDHDR_FLAG_REPLACE   0x80000000
#define	HTTP_ADDHDR_FLAG_REQ   0x02000000
#define	COLLECT_TIME   60000
#define	FE(x)   { x, #x }
#define	COALESCEFLAGS   (HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)

Typedefs
typedef struct _basicAuthorizationData	basicAuthorizationData
typedef struct _authorizationData	authorizationData

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wininet)
static DWORD	HTTP_GetResponseHeaders (http_request_t *req, INT *len)
static DWORD	HTTP_ProcessHeader (http_request_t *req, LPCWSTR field, LPCWSTR value, DWORD dwModifier)
static LPWSTR *	HTTP_InterpretHttpHeader (LPCWSTR buffer)
static DWORD	HTTP_InsertCustomHeader (http_request_t *req, LPHTTPHEADERW lpHdr)
static INT	HTTP_GetCustomHeaderIndex (http_request_t *req, LPCWSTR lpszField, INT index, BOOL Request)
static BOOL	HTTP_DeleteCustomHeader (http_request_t *req, DWORD index)
static LPWSTR	HTTP_build_req (LPCWSTR *list, int len)
static DWORD	HTTP_HttpQueryInfoW (http_request_t *, DWORD, LPVOID, LPDWORD, LPDWORD)
static UINT	HTTP_DecodeBase64 (LPCWSTR base64, LPSTR bin)
static DWORD	drain_content (http_request_t *, BOOL)
void	server_addref (server_t *server)
void	server_release (server_t *server)
static BOOL	process_host_port (server_t *server)
server_t *	get_server (substr_t name, INTERNET_PORT port, BOOL is_https, BOOL do_create)
BOOL	collect_connections (collect_type_t collect_type)
static DWORD WINAPI	collect_connections_proc (void *arg)
static LPHTTPHEADERW	HTTP_GetHeader (http_request_t *req, LPCWSTR head)
static WCHAR *	get_host_header (http_request_t *req)
static void	destroy_data_stream (data_stream_t *stream)
static void	reset_data_stream (http_request_t *req)
static void	remove_header (http_request_t *request, const WCHAR *str, BOOL from_request)
static BOOL	gzip_end_of_data (data_stream_t *stream, http_request_t *req)
static DWORD	gzip_read (data_stream_t *stream, http_request_t *req, BYTE *buf, DWORD size, DWORD *read, BOOL allow_blocking)
static DWORD	gzip_drain_content (data_stream_t *stream, http_request_t *req, BOOL allow_blocking)
static void	gzip_destroy (data_stream_t *stream)
static voidpf	wininet_zalloc (voidpf opaque, uInt items, uInt size)
static void	wininet_zfree (voidpf opaque, voidpf address)
static DWORD	init_gzip_stream (http_request_t *req, BOOL is_gzip)
static void	HTTP_FreeTokens (LPWSTR *token_array)
static void	HTTP_FixURL (http_request_t *request)
static WCHAR *	build_request_header (http_request_t *request, const WCHAR *verb, const WCHAR *path, const WCHAR *version, BOOL use_cr)
static WCHAR *	build_response_header (http_request_t *request, BOOL use_cr)
static void	HTTP_ProcessCookies (http_request_t *request)
static void	strip_spaces (LPWSTR start)
static BOOL	is_basic_auth_value (LPCWSTR pszAuthValue, LPWSTR *pszRealm)
static void	destroy_authinfo (struct HttpAuthInfo *authinfo)
static UINT	retrieve_cached_basic_authorization (http_request_t *req, const WCHAR *host, const WCHAR *realm, char **auth_data)
static void	cache_basic_authorization (LPWSTR host, LPWSTR realm, LPSTR auth_data, UINT auth_data_len)
static BOOL	retrieve_cached_authorization (LPWSTR host, LPWSTR scheme, SEC_WINNT_AUTH_IDENTITY_W *nt_auth_identity)
static void	cache_authorization (LPWSTR host, LPWSTR scheme, SEC_WINNT_AUTH_IDENTITY_W *nt_auth_identity)
void	free_authorization_cache (void)
static BOOL	HTTP_DoAuthorization (http_request_t *request, LPCWSTR pszAuthValue, struct HttpAuthInfo **ppAuthInfo, LPWSTR domain_and_username, LPWSTR password, LPWSTR host)
static DWORD	HTTP_HttpAddRequestHeadersW (http_request_t *request, LPCWSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
BOOL WINAPI	HttpAddRequestHeadersW (HINTERNET hHttpRequest, LPCWSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
BOOL WINAPI	HttpAddRequestHeadersA (HINTERNET hHttpRequest, LPCSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
static void	free_accept_types (WCHAR **accept_types)
static WCHAR **	convert_accept_types (const char **accept_types)
HINTERNET WINAPI	HttpOpenRequestA (HINTERNET hHttpSession, LPCSTR lpszVerb, LPCSTR lpszObjectName, LPCSTR lpszVersion, LPCSTR lpszReferrer, LPCSTR *lpszAcceptTypes, DWORD dwFlags, DWORD_PTR dwContext)
static UINT	HTTP_EncodeBase64 (LPCSTR bin, unsigned int len, LPWSTR base64)
static WCHAR *	encode_auth_data (const WCHAR *scheme, const char *data, UINT data_len)
static BOOL	HTTP_InsertAuthorization (http_request_t *request, struct HttpAuthInfo *pAuthInfo, LPCWSTR header)
static WCHAR *	build_proxy_path_url (http_request_t *req)
static BOOL	HTTP_DomainMatches (LPCWSTR server, substr_t domain)
static BOOL	HTTP_ShouldBypassProxy (appinfo_t *lpwai, LPCWSTR server)
static BOOL	HTTP_DealWithProxy (appinfo_t *hIC, http_session_t *session, http_request_t *request)
static DWORD	HTTP_ResolveName (http_request_t *request)
static WCHAR *	compose_request_url (http_request_t *req)
static void	HTTPREQ_Destroy (object_header_t *hdr)
static void	http_release_netconn (http_request_t *req, BOOL reuse)
static BOOL	HTTP_KeepAlive (http_request_t *request)
static void	HTTPREQ_CloseConnection (object_header_t *hdr)
static DWORD	str_to_buffer (const WCHAR *str, void *buffer, DWORD *size, BOOL unicode)
static DWORD	get_security_cert_struct (http_request_t *req, INTERNET_CERTIFICATE_INFOA *info)
static DWORD	HTTPREQ_QueryOption (object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
static DWORD	HTTPREQ_SetOption (object_header_t *hdr, DWORD option, void *buffer, DWORD size)
static void	commit_cache_entry (http_request_t *req)
static void	create_cache_entry (http_request_t *req)
static DWORD	read_more_data (http_request_t *req, int maxlen)
static void	remove_data (http_request_t *req, int count)
static DWORD	read_line (http_request_t *req, LPSTR buffer, DWORD *len)
static BOOL	end_of_read_data (http_request_t *req)
static DWORD	read_http_stream (http_request_t *req, BYTE *buf, DWORD size, DWORD *read, BOOL allow_blocking)
static DWORD	refill_read_buffer (http_request_t *req, BOOL allow_blocking, DWORD *read_bytes)
static BOOL	netconn_end_of_data (data_stream_t *stream, http_request_t *req)
static DWORD	netconn_read (data_stream_t *stream, http_request_t *req, BYTE *buf, DWORD size, DWORD *read, BOOL allow_blocking)
static DWORD	netconn_drain_content (data_stream_t *stream, http_request_t *req, BOOL allow_blocking)
static void	netconn_destroy (data_stream_t *stream)
static char	next_chunked_data_char (chunked_stream_t *stream)
static BOOL	chunked_end_of_data (data_stream_t *stream, http_request_t *req)
static DWORD	chunked_read (data_stream_t *stream, http_request_t *req, BYTE *buf, DWORD size, DWORD *read, BOOL allow_blocking)
static DWORD	chunked_drain_content (data_stream_t *stream, http_request_t *req, BOOL allow_blocking)
static void	chunked_destroy (data_stream_t *stream)
static DWORD	set_content_length (http_request_t *request)
static void	send_request_complete (http_request_t *req, DWORD_PTR result, DWORD error)
static void	HTTP_ReceiveRequestData (http_request_t *req)
static DWORD	HTTPREQ_Read (http_request_t *req, void *buffer, DWORD size, DWORD *read, BOOL allow_blocking)
static void	async_read_file_proc (task_header_t *hdr)
static DWORD	async_read (http_request_t *req, void *buf, DWORD size, DWORD read_pos, DWORD *ret_read)
static DWORD	HTTPREQ_ReadFile (object_header_t *hdr, void *buf, DWORD size, DWORD *ret_read, DWORD flags, DWORD_PTR context)
static DWORD	HTTPREQ_WriteFile (object_header_t *hdr, const void *buffer, DWORD size, DWORD *written)
static DWORD	HTTPREQ_QueryDataAvailable (object_header_t *hdr, DWORD *available, DWORD flags, DWORD_PTR ctx)
static DWORD	HTTPREQ_LockRequestFile (object_header_t *hdr, req_file_t **ret)
static DWORD	HTTP_HttpOpenRequestW (http_session_t *session, LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion, LPCWSTR lpszReferrer, LPCWSTR *lpszAcceptTypes, DWORD dwFlags, DWORD_PTR dwContext, HINTERNET *ret)
HINTERNET WINAPI	HttpOpenRequestW (HINTERNET hHttpSession, LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion, LPCWSTR lpszReferrer, LPCWSTR *lpszAcceptTypes, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	HttpQueryInfoW (HINTERNET hHttpRequest, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
BOOL WINAPI	HttpQueryInfoA (HINTERNET hHttpRequest, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
static WCHAR *	get_redirect_url (http_request_t *request)
static DWORD	HTTP_HandleRedirect (http_request_t *request, WCHAR *url)
static void	HTTP_InsertCookies (http_request_t *request)
static WORD	HTTP_ParseWkday (LPCWSTR day)
static WORD	HTTP_ParseMonth (LPCWSTR month)
static BOOL	HTTP_ParseTime (SYSTEMTIME *st, LPCWSTR *str)
static BOOL	HTTP_ParseDateAsAsctime (LPCWSTR value, FILETIME *ft)
static BOOL	HTTP_ParseRfc1123Date (LPCWSTR value, FILETIME *ft)
static WORD	HTTP_ParseWeekday (LPCWSTR day)
static BOOL	HTTP_ParseRfc850Date (LPCWSTR value, FILETIME *ft)
static BOOL	HTTP_ParseDate (LPCWSTR value, FILETIME *ft)
static void	HTTP_ProcessExpires (http_request_t *request)
static void	HTTP_ProcessLastModified (http_request_t *request)
static void	http_process_keep_alive (http_request_t *req)
static DWORD	open_http_connection (http_request_t *request, BOOL *reusing)
static char *	build_ascii_request (const WCHAR *str, void *data, DWORD data_len, DWORD *out_len)
static void	set_content_length_header (http_request_t *request, DWORD len, DWORD flags)
static DWORD	HTTP_HttpSendRequestW (http_request_t *request, LPCWSTR lpszHeaders, DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength, DWORD dwContentLength, BOOL bEndRequest)
static void	AsyncHttpSendRequestProc (task_header_t *hdr)
static DWORD	HTTP_HttpEndRequestW (http_request_t *request, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	HttpEndRequestA (HINTERNET hRequest, LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
static void	AsyncHttpEndRequestProc (task_header_t *hdr)
BOOL WINAPI	HttpEndRequestW (HINTERNET hRequest, LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	HttpSendRequestExA (HINTERNET hRequest, LPINTERNET_BUFFERSA lpBuffersIn, LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	HttpSendRequestExW (HINTERNET hRequest, LPINTERNET_BUFFERSW lpBuffersIn, LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	HttpSendRequestW (HINTERNET hHttpRequest, LPCWSTR lpszHeaders, DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength)
BOOL WINAPI	HttpSendRequestA (HINTERNET hHttpRequest, LPCSTR lpszHeaders, DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength)
static void	HTTPSESSION_Destroy (object_header_t *hdr)
static DWORD	HTTPSESSION_QueryOption (object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
static DWORD	HTTPSESSION_SetOption (object_header_t *hdr, DWORD option, void *buffer, DWORD size)
DWORD	HTTP_Connect (appinfo_t *hIC, LPCWSTR lpszServerName, INTERNET_PORT serverPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext, DWORD dwInternalFlags, HINTERNET *ret)
static void	HTTP_clear_response_headers (http_request_t *request)
static INT	HTTP_GetCustomHeaderIndex (http_request_t *request, LPCWSTR lpszField, int requested_index, BOOL request_only)
BOOL WINAPI	IsHostInProxyBypassList (DWORD flags, LPCSTR szHost, DWORD length)

Variables
static struct list	basicAuthorizationCache = LIST_INIT(basicAuthorizationCache)
static struct list	authorizationCache = LIST_INIT(authorizationCache)
static CRITICAL_SECTION	authcache_cs = { &critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	critsect_debug
static CRITICAL_SECTION	connection_pool_cs = { &connection_pool_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	connection_pool_debug
static struct list	connection_pool = LIST_INIT(connection_pool)
static BOOL	collector_running
static const data_stream_vtbl_t	gzip_stream_vtbl
static const signed char	HTTP_Base64Dec []
static const data_stream_vtbl_t	netconn_stream_vtbl
static const data_stream_vtbl_t	chunked_stream_vtbl
static const object_vtbl_t	HTTPREQVtbl
static const LPCWSTR	header_lookup []
static const object_vtbl_t	HTTPSESSIONVtbl

Macro Definition Documentation

COALESCEFLAGS

#define COALESCEFLAGS   (HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)

Definition at line 6115 of file http.c.

COLLECT_TIME

#define COLLECT_TIME   60000

Definition at line 74 of file http.c.

FE

#define FE

(

x

)

{ x, #x }

HTTP_ADDHDR_FLAG_ADD

#define HTTP_ADDHDR_FLAG_ADD   0x20000000

Definition at line 67 of file http.c.

HTTP_ADDHDR_FLAG_ADD_IF_NEW

#define HTTP_ADDHDR_FLAG_ADD_IF_NEW   0x10000000

Definition at line 68 of file http.c.

HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA

#define HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA   0x40000000

Definition at line 69 of file http.c.

HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON

#define HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON   0x01000000

Definition at line 70 of file http.c.

HTTP_ADDHDR_FLAG_REPLACE

#define HTTP_ADDHDR_FLAG_REPLACE   0x80000000

Definition at line 71 of file http.c.

HTTP_ADDHDR_FLAG_REQ

#define HTTP_ADDHDR_FLAG_REQ   0x02000000

Definition at line 72 of file http.c.

NO_SHLWAPI_GDI

#define NO_SHLWAPI_GDI

Definition at line 52 of file http.c.

NO_SHLWAPI_REG

#define NO_SHLWAPI_REG

Definition at line 51 of file http.c.

NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

Definition at line 50 of file http.c.

Typedef Documentation

authorizationData

typedef struct _authorizationData authorizationData

basicAuthorizationData

typedef struct _basicAuthorizationData basicAuthorizationData

Function Documentation

async_read()

static DWORD async_read ( http_request_t *  req, void *  buf, DWORD  size, DWORD  read_pos, DWORD *  ret_read  )

static

Definition at line 3157 of file http.c.

{
    read_file_task_t *task;
 
    task = alloc_async_task(&req->hdr, async_read_file_proc, sizeof(*task));
    if(!task)
        return ERROR_OUTOFMEMORY;
 
    task->buf = buf;
    task->size = size;
    task->read_pos = read_pos;
    task->ret_read = ret_read;
 
    INTERNET_AsyncCall(&task->hdr);
    return ERROR_IO_PENDING;
}

Referenced by HTTPREQ_QueryDataAvailable(), and HTTPREQ_ReadFile().

async_read_file_proc()

static void async_read_file_proc ( task_header_t *  hdr )

static

Definition at line 3117 of file http.c.

{
    read_file_task_t *task = (read_file_task_t*)hdr;
    http_request_t *req = (http_request_t*)task->hdr.hdr;
    DWORD res = ERROR_SUCCESS, read = task->read_pos, complete_arg = 0;
 
    TRACE("req %p buf %p size %u read_pos %u ret_read %p\n", req, task->buf, task->size, task->read_pos, task->ret_read);
 
    if(task->buf) {
        DWORD read_bytes;
        while (read < task->size) {
            res = HTTPREQ_Read(req, (char*)task->buf + read, task->size - read, &read_bytes, TRUE);
            if (res != ERROR_SUCCESS || !read_bytes)
                break;
            read += read_bytes;
        }
    }else {
        EnterCriticalSection(&req->read_section);
        res = refill_read_buffer(req, TRUE, &read);
        LeaveCriticalSection(&req->read_section);
 
        if(task->ret_read)
            complete_arg = read; /* QueryDataAvailable reports read bytes in request complete notification */
        if(res != ERROR_SUCCESS || !read)
            http_release_netconn(req, drain_content(req, FALSE) == ERROR_SUCCESS);
    }
 
    TRACE("res %u read %u\n", res, read);
 
    if(task->ret_read)
        *task->ret_read = read;
 
    /* FIXME: We should report bytes transferred before decoding content. */
    INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED, &read, sizeof(read));
 
    if(res != ERROR_SUCCESS)
        complete_arg = res;
    send_request_complete(req, res == ERROR_SUCCESS, complete_arg);
}

Referenced by async_read().

AsyncHttpEndRequestProc()

static void AsyncHttpEndRequestProc ( task_header_t *  hdr )

static

Definition at line 5369 of file http.c.

{
    end_request_task_t *task = (end_request_task_t*)hdr;
    http_request_t *req = (http_request_t*)task->hdr.hdr;
 
    TRACE("%p\n", req);
 
    HTTP_HttpEndRequestW(req, task->flags, task->context);
}

Referenced by HttpEndRequestW().

AsyncHttpSendRequestProc()

static void AsyncHttpSendRequestProc ( task_header_t *  hdr )

static

Definition at line 5255 of file http.c.

{
    send_request_task_t *task = (send_request_task_t*)hdr;
    http_request_t *request = (http_request_t*)task->hdr.hdr;
 
    TRACE("%p\n", request);
 
    HTTP_HttpSendRequestW(request, task->headers, task->headers_len, task->optional,
            task->optional_len, task->content_len, task->end_request);
 
    heap_free(task->headers);
}

Referenced by HttpSendRequestExW(), and HttpSendRequestW().

build_ascii_request()

static char * build_ascii_request ( const WCHAR *  str, void *  data, DWORD  data_len, DWORD *  out_len  )

static

Definition at line 4879 of file http.c.

{
    int len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
    char *ret;
 
    if (!(ret = heap_alloc( len + data_len ))) return NULL;
    WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
    if (data_len) memcpy( ret + len - 1, data, data_len );
    *out_len = len + data_len - 1;
    ret[*out_len] = 0;
    return ret;
}

Referenced by HTTP_HttpSendRequestW().

build_proxy_path_url()

static WCHAR * build_proxy_path_url ( http_request_t *  req )

static

Definition at line 1657 of file http.c.

{
    DWORD size, len;
    WCHAR *url;
 
    len = lstrlenW(req->server->scheme_host_port);
    size = len + lstrlenW(req->path) + 1;
    if(*req->path != '/')
        size++;
    url = heap_alloc(size * sizeof(WCHAR));
    if(!url)
        return NULL;
 
    memcpy(url, req->server->scheme_host_port, len*sizeof(WCHAR));
    if(*req->path != '/')
        url[len++] = '/';
 
    lstrcpyW(url+len, req->path);
 
    TRACE("url=%s\n", debugstr_w(url));
    return url;
}

Referenced by HTTP_HttpSendRequestW().

build_request_header()

static WCHAR * build_request_header ( http_request_t *  request, const WCHAR *  verb, const WCHAR *  path, const WCHAR *  version, BOOL  use_cr  )

static

Definition at line 556 of file http.c.

{
    LPWSTR requestString;
    DWORD len, n;
    LPCWSTR *req;
    UINT i;
 
    EnterCriticalSection( &request->headers_section );
 
    /* allocate space for an array of all the string pointers to be added */
    len = request->nCustHeaders * 5 + 10;
    if (!(req = heap_alloc( len * sizeof(const WCHAR *) )))
    {
        LeaveCriticalSection( &request->headers_section );
        return NULL;
    }
 
    /* add the verb, path and HTTP version string */
    n = 0;
    req[n++] = verb;
    req[n++] = L" ";
    req[n++] = path;
    req[n++] = L" ";
    req[n++] = version;
    if (use_cr)
        req[n++] = L"\r";
    req[n++] = L"\n";
 
    /* Append custom request headers */
    for (i = 0; i < request->nCustHeaders; i++)
    {
        if (request->custHeaders[i].wFlags & HDR_ISREQUEST)
        {
            req[n++] = request->custHeaders[i].lpszField;
            req[n++] = L": ";
            req[n++] = request->custHeaders[i].lpszValue;
            if (use_cr)
                req[n++] = L"\r";
            req[n++] = L"\n";
 
            TRACE("Adding custom header %s (%s)\n",
                   debugstr_w(request->custHeaders[i].lpszField),
                   debugstr_w(request->custHeaders[i].lpszValue));
        }
    }
    if (use_cr)
        req[n++] = L"\r";
    req[n++] = L"\n";
    req[n] = NULL;
 
    requestString = HTTP_build_req( req, 4 );
    heap_free( req );
    LeaveCriticalSection( &request->headers_section );
    return requestString;
}

Referenced by HTTP_HttpQueryInfoW(), and HTTP_HttpSendRequestW().

build_response_header()

static WCHAR * build_response_header ( http_request_t *  request, BOOL  use_cr  )

static

Definition at line 613 of file http.c.

{
    const WCHAR **req;
    WCHAR *ret, buf[14];
    DWORD i, n = 0;
 
    EnterCriticalSection( &request->headers_section );
 
    if (!(req = heap_alloc( (request->nCustHeaders * 5 + 8) * sizeof(WCHAR *) )))
    {
        LeaveCriticalSection( &request->headers_section );
        return NULL;
    }
 
    if (request->status_code)
    {
        req[n++] = request->version;
        swprintf(buf, ARRAY_SIZE(buf), L" %u ", request->status_code);
        req[n++] = buf;
        req[n++] = request->statusText;
        if (use_cr)
            req[n++] = L"\r";
        req[n++] = L"\n";
    }
 
    for(i = 0; i < request->nCustHeaders; i++)
    {
        if(!(request->custHeaders[i].wFlags & HDR_ISREQUEST)
                && wcscmp(request->custHeaders[i].lpszField, L"Status"))
        {
            req[n++] = request->custHeaders[i].lpszField;
            req[n++] = L": ";
            req[n++] = request->custHeaders[i].lpszValue;
            if(use_cr)
                req[n++] = L"\r";
            req[n++] = L"\n";
 
            TRACE("Adding custom header %s (%s)\n",
                    debugstr_w(request->custHeaders[i].lpszField),
                    debugstr_w(request->custHeaders[i].lpszValue));
        }
    }
    if(use_cr)
        req[n++] = L"\r";
    req[n++] = L"\n";
    req[n] = NULL;
 
    ret = HTTP_build_req(req, 0);
    heap_free(req);
    LeaveCriticalSection( &request->headers_section );
    return ret;
}

Referenced by commit_cache_entry(), and HTTP_HttpQueryInfoW().

cache_authorization()

static void cache_authorization ( LPWSTR  host, LPWSTR  scheme, SEC_WINNT_AUTH_IDENTITY_W *  nt_auth_identity  )

static

Definition at line 891 of file http.c.

{
    authorizationData *ad;
    BOOL found = FALSE;
 
    TRACE("Caching authorization for %s:%s\n", debugstr_w(host), debugstr_w(scheme));
 
    EnterCriticalSection(&authcache_cs);
    LIST_FOR_EACH_ENTRY(ad, &authorizationCache, authorizationData, entry)
        if(!wcsicmp(host, ad->host) && !wcsicmp(scheme, ad->scheme)) {
            found = TRUE;
            break;
        }
 
    if(found) {
        heap_free(ad->user);
        heap_free(ad->password);
        heap_free(ad->domain);
    } else {
        ad = heap_alloc(sizeof(authorizationData));
        if(!ad) {
            LeaveCriticalSection(&authcache_cs);
            return;
        }
 
        ad->host = heap_strdupW(host);
        ad->scheme = heap_strdupW(scheme);
        list_add_head(&authorizationCache, &ad->entry);
    }
 
    ad->user = heap_strndupW(nt_auth_identity->User, nt_auth_identity->UserLength);
    ad->password = heap_strndupW(nt_auth_identity->Password, nt_auth_identity->PasswordLength);
    ad->domain = heap_strndupW(nt_auth_identity->Domain, nt_auth_identity->DomainLength);
    ad->user_len = nt_auth_identity->UserLength;
    ad->password_len = nt_auth_identity->PasswordLength;
    ad->domain_len = nt_auth_identity->DomainLength;
 
    if(!ad->host || !ad->scheme || !ad->user || !ad->password
            || (nt_auth_identity->Domain && !ad->domain)) {
        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 HTTP_DoAuthorization().

cache_basic_authorization()

static void cache_basic_authorization ( LPWSTR  host, LPWSTR  realm, LPSTR  auth_data, UINT  auth_data_len  )

static

Definition at line 814 of file http.c.

{
    struct list *cursor;
    basicAuthorizationData* ad = NULL;
 
    TRACE("caching authorization for %s:%s = %s\n",debugstr_w(host),debugstr_w(realm),debugstr_an(auth_data,auth_data_len));
 
    EnterCriticalSection(&authcache_cs);
    LIST_FOR_EACH(cursor, &basicAuthorizationCache)
    {
        basicAuthorizationData *check = LIST_ENTRY(cursor,basicAuthorizationData,entry);
        if (!wcsicmp(host,check->host) && !wcscmp(realm,check->realm))
        {
            ad = check;
            break;
        }
    }
 
    if (ad)
    {
        TRACE("Found match in cache, replacing\n");
        heap_free(ad->authorization);
        ad->authorization = heap_alloc(auth_data_len);
        memcpy(ad->authorization, auth_data, auth_data_len);
        ad->authorizationLen = auth_data_len;
    }
    else
    {
        ad = heap_alloc(sizeof(basicAuthorizationData));
        ad->host = heap_strdupW(host);
        ad->realm = heap_strdupW(realm);
        ad->authorization = heap_alloc(auth_data_len);
        memcpy(ad->authorization, auth_data, auth_data_len);
        ad->authorizationLen = auth_data_len;
        list_add_head(&basicAuthorizationCache,&ad->entry);
        TRACE("authorization cached\n");
    }
    LeaveCriticalSection(&authcache_cs);
}

Referenced by HTTP_DoAuthorization().

chunked_destroy()

static void chunked_destroy ( data_stream_t *  stream )

static

Definition at line 2929 of file http.c.

{
    chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
    heap_free(chunked_stream);
}

chunked_drain_content()

static DWORD chunked_drain_content ( data_stream_t *  stream, http_request_t *  req, BOOL  allow_blocking  )

static

Definition at line 2911 of file http.c.

{
    chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
    BYTE buf[1024];
    DWORD size, res;
 
    while(chunked_stream->state != CHUNKED_STREAM_STATE_END_OF_STREAM
          && chunked_stream->state != CHUNKED_STREAM_STATE_ERROR) {
        res = chunked_read(stream, req, buf, sizeof(buf), &size, allow_blocking);
        if(res != ERROR_SUCCESS)
            return res;
    }
 
    if(chunked_stream->state != CHUNKED_STREAM_STATE_END_OF_STREAM)
        return ERROR_NO_DATA;
    return ERROR_SUCCESS;
}

chunked_end_of_data()

static BOOL chunked_end_of_data ( data_stream_t *  stream, http_request_t *  req  )

static

Definition at line 2755 of file http.c.

{
    chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
    switch(chunked_stream->state) {
    case CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END:
    case CHUNKED_STREAM_STATE_END_OF_STREAM:
    case CHUNKED_STREAM_STATE_ERROR:
        return TRUE;
    default:
        return FALSE;
    }
}

chunked_read()

static DWORD chunked_read ( data_stream_t *  stream, http_request_t *  req, BYTE *  buf, DWORD  size, DWORD *  read, BOOL  allow_blocking  )

static

Definition at line 2768 of file http.c.

{
    chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
    DWORD ret_read = 0, res = ERROR_SUCCESS;
    BOOL continue_read = TRUE;
    int read_bytes;
    char ch;
 
    do {
        TRACE("state %d\n", chunked_stream->state);
 
        /* Ensure that we have data in the buffer for states that need it. */
        if(!chunked_stream->buf_size) {
            BOOL blocking_read = allow_blocking;
 
            switch(chunked_stream->state) {
            case CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END:
            case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE:
                /* never allow blocking after 0 chunk size */
                if(!chunked_stream->chunk_size)
                    blocking_read = FALSE;
                /* fall through */
            case CHUNKED_STREAM_STATE_READING_CHUNK_SIZE:
            case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA:
                chunked_stream->buf_pos = 0;
                res = NETCON_recv(req->netconn, chunked_stream->buf, sizeof(chunked_stream->buf), blocking_read, &read_bytes);
                if(res == ERROR_SUCCESS && read_bytes) {
                    chunked_stream->buf_size += read_bytes;
                }else if(res == WSAEWOULDBLOCK) {
                    if(ret_read || allow_blocking)
                        res = ERROR_SUCCESS;
                    continue_read = FALSE;
                    continue;
                }else {
                    chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
                }
                break;
            default:
                break;
            }
        }
 
        switch(chunked_stream->state) {
        case CHUNKED_STREAM_STATE_READING_CHUNK_SIZE:
            ch = next_chunked_data_char(chunked_stream);
 
            if(ch >= '0' && ch <= '9') {
                chunked_stream->chunk_size = chunked_stream->chunk_size * 16 + ch - '0';
            }else if(ch >= 'a' && ch <= 'f') {
                chunked_stream->chunk_size = chunked_stream->chunk_size * 16 + ch - 'a' + 10;
            }else if (ch >= 'A' && ch <= 'F') {
                chunked_stream->chunk_size = chunked_stream->chunk_size * 16 + ch - 'A' + 10;
            }else if (ch == ';' || ch == '\r' || ch == '\n') {
                TRACE("reading %u byte chunk\n", chunked_stream->chunk_size);
                chunked_stream->buf_size++;
                chunked_stream->buf_pos--;
                if(req->contentLength == ~0) req->contentLength = chunked_stream->chunk_size;
                else req->contentLength += chunked_stream->chunk_size;
                chunked_stream->state = CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE;
            }
            break;
 
        case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE:
            ch = next_chunked_data_char(chunked_stream);
            if(ch == '\n')
                chunked_stream->state = chunked_stream->chunk_size
                    ? CHUNKED_STREAM_STATE_READING_CHUNK
                    : CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END;
            else if(ch != '\r')
                WARN("unexpected char '%c'\n", ch);
            break;
 
        case CHUNKED_STREAM_STATE_READING_CHUNK:
            assert(chunked_stream->chunk_size);
            if(!size) {
                continue_read = FALSE;
                break;
            }
            read_bytes = min(size, chunked_stream->chunk_size);
 
            if(chunked_stream->buf_size) {
                if(read_bytes > chunked_stream->buf_size)
                    read_bytes = chunked_stream->buf_size;
 
                memcpy(buf+ret_read, chunked_stream->buf+chunked_stream->buf_pos, read_bytes);
                chunked_stream->buf_pos += read_bytes;
                chunked_stream->buf_size -= read_bytes;
            }else {
                res = NETCON_recv(req->netconn, (char*)buf+ret_read, read_bytes,
                                  allow_blocking, (int*)&read_bytes);
                if(res != ERROR_SUCCESS) {
                    continue_read = FALSE;
                    break;
                }
 
                if(!read_bytes) {
                    chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
                    continue;
                }
            }
 
            chunked_stream->chunk_size -= read_bytes;
            size -= read_bytes;
            ret_read += read_bytes;
            if(!chunked_stream->chunk_size)
                chunked_stream->state = CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA;
            allow_blocking = FALSE;
            break;
 
        case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA:
            ch = next_chunked_data_char(chunked_stream);
            if(ch == '\n')
                chunked_stream->state = CHUNKED_STREAM_STATE_READING_CHUNK_SIZE;
            else if(ch != '\r')
                WARN("unexpected char '%c'\n", ch);
            break;
 
        case CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END:
            ch = next_chunked_data_char(chunked_stream);
            if(ch == '\n')
                chunked_stream->state = CHUNKED_STREAM_STATE_END_OF_STREAM;
            else if(ch != '\r')
                WARN("unexpected char '%c'\n", ch);
            break;
 
        case CHUNKED_STREAM_STATE_END_OF_STREAM:
        case CHUNKED_STREAM_STATE_ERROR:
            continue_read = FALSE;
            break;
        }
    } while(continue_read);
 
    if(ret_read)
        res = ERROR_SUCCESS;
    if(res != ERROR_SUCCESS)
        return res;
 
    TRACE("read %d bytes\n", ret_read);
    *read = ret_read;
    return ERROR_SUCCESS;
}

Referenced by chunked_drain_content().

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

collect_connections_proc()

static DWORD WINAPI collect_connections_proc ( void *  arg )

static

Definition at line 269 of file http.c.

{
    BOOL remaining_conns;
 
    do {
        /* FIXME: Use more sophisticated method */
        Sleep(5000);
 
        EnterCriticalSection(&connection_pool_cs);
 
        remaining_conns = collect_connections(COLLECT_TIMEOUT);
        if(!remaining_conns)
            collector_running = FALSE;
 
        LeaveCriticalSection(&connection_pool_cs);
    }while(remaining_conns);
 
    FreeLibraryAndExitThread(WININET_hModule, 0);
}

Referenced by http_release_netconn().

commit_cache_entry()

static void commit_cache_entry ( http_request_t *  req )

static

Definition at line 2426 of file http.c.

{
    WCHAR *header;
    DWORD header_len;
    BOOL res;
 
    TRACE("%p\n", req);
 
    CloseHandle(req->hCacheFile);
    req->hCacheFile = NULL;
 
    header = build_response_header(req, TRUE);
    header_len = (header ? lstrlenW(header) : 0);
    res = CommitUrlCacheEntryW(req->req_file->url, req->req_file->file_name, req->expires,
             req->last_modified, NORMAL_CACHE_ENTRY,
            header, header_len, NULL, 0);
    if(res)
        req->req_file->is_committed = TRUE;
    else
        WARN("CommitUrlCacheEntry failed: %u\n", GetLastError());
    heap_free(header);
}

Referenced by create_cache_entry(), and read_http_stream().

compose_request_url()

static WCHAR * compose_request_url ( http_request_t *  req )

static

Definition at line 1815 of file http.c.

{
    const WCHAR *host, *scheme;
    WCHAR *buf, *ptr;
    size_t len;
 
    host = req->server->canon_host_port;
 
    if (req->server->is_https)
        scheme = L"https://";
    else
        scheme = L"http://";
 
    len = lstrlenW(scheme) + lstrlenW(host) + (req->path[0] != '/' ? 1 : 0) + lstrlenW(req->path);
    ptr = buf = heap_alloc((len+1) * sizeof(WCHAR));
    if(buf) {
        lstrcpyW(ptr, scheme);
        ptr += lstrlenW(ptr);
 
        lstrcpyW(ptr, host);
        ptr += lstrlenW(ptr);
 
        if(req->path[0] != '/')
            *ptr++ = '/';
 
        lstrcpyW(ptr, req->path);
        ptr += lstrlenW(ptr);
        *ptr = 0;
    }
 
    return buf;
}

Referenced by create_cache_entry(), and HTTPREQ_QueryOption().

convert_accept_types()

static WCHAR ** convert_accept_types ( const char **  accept_types )

static

Definition at line 1359 of file http.c.

{
    unsigned int count;
    const char **types = accept_types;
    WCHAR **typesW;
    BOOL invalid_pointer = FALSE;
 
    if (!types) return NULL;
    count = 0;
    while (*types)
    {
        __TRY
        {
            /* find out how many there are */
            if (*types && **types)
            {
                TRACE("accept type: %s\n", debugstr_a(*types));
                count++;
            }
        }
        __EXCEPT_PAGE_FAULT
        {
            WARN("invalid accept type pointer\n");
            invalid_pointer = TRUE;
        }
        __ENDTRY;
        types++;
    }
    if (invalid_pointer) return NULL;
    if (!(typesW = heap_alloc( sizeof(WCHAR *) * (count + 1) ))) return NULL;
    count = 0;
    types = accept_types;
    while (*types)
    {
        if (*types && **types) typesW[count++] = heap_strdupAtoW( *types );
        types++;
    }
    typesW[count] = NULL;
    return typesW;
}

Referenced by HttpOpenRequestA().

create_cache_entry()

static void create_cache_entry ( http_request_t *  req )

static

Definition at line 2449 of file http.c.

{
    WCHAR file_name[MAX_PATH+1];
    WCHAR *url;
    BOOL b = TRUE;
 
    /* FIXME: We should free previous cache file earlier */
    if(req->req_file) {
        req_file_release(req->req_file);
        req->req_file = NULL;
    }
    if(req->hCacheFile) {
        CloseHandle(req->hCacheFile);
        req->hCacheFile = NULL;
    }
 
    if(req->hdr.dwFlags & INTERNET_FLAG_NO_CACHE_WRITE)
        b = FALSE;
 
    if(b) {
        int header_idx;
 
        EnterCriticalSection( &req->headers_section );
 
        header_idx = HTTP_GetCustomHeaderIndex(req, L"Cache-Control", 0, FALSE);
        if(header_idx != -1) {
            WCHAR *ptr;
 
            for(ptr=req->custHeaders[header_idx].lpszValue; *ptr; ) {
                WCHAR *end;
 
                while(*ptr==' ' || *ptr=='\t')
                    ptr++;
 
                end = wcschr(ptr, ',');
                if(!end)
                    end = ptr + lstrlenW(ptr);
 
                if(!wcsnicmp(ptr, L"no-cache", ARRAY_SIZE(L"no-cache")-1)
                        || !wcsnicmp(ptr, L"no-store", ARRAY_SIZE(L"no-store")-1)) {
                    b = FALSE;
                    break;
                }
 
                ptr = end;
                if(*ptr == ',')
                    ptr++;
            }
        }
 
        LeaveCriticalSection( &req->headers_section );
    }
 
    if(!b) {
        if(!(req->hdr.dwFlags & INTERNET_FLAG_NEED_FILE))
            return;
 
        FIXME("INTERNET_FLAG_NEED_FILE is not supported correctly\n");
    }
 
    url = compose_request_url(req);
    if(!url) {
        WARN("Could not get URL\n");
        return;
    }
 
    b = CreateUrlCacheEntryW(url, req->contentLength == ~0 ? 0 : req->contentLength, NULL, file_name, 0);
    if(!b) {
        WARN("Could not create cache entry: %08x\n", GetLastError());
        return;
    }
 
    create_req_file(file_name, &req->req_file);
    req->req_file->url = url;
 
    req->hCacheFile = CreateFileW(file_name, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
              NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if(req->hCacheFile == INVALID_HANDLE_VALUE) {
        WARN("Could not create file: %u\n", GetLastError());
        req->hCacheFile = NULL;
        return;
    }
 
    if(req->read_size) {
        DWORD written;
 
        b = WriteFile(req->hCacheFile, req->read_buf+req->read_pos, req->read_size, &written, NULL);
        if(!b)
            FIXME("WriteFile failed: %u\n", GetLastError());
 
        if(req->data_stream->vtbl->end_of_data(req->data_stream, req))
            commit_cache_entry(req);
    }
}

Referenced by HTTP_HttpEndRequestW(), and HTTP_HttpSendRequestW().

destroy_authinfo()

static void destroy_authinfo ( struct HttpAuthInfo *  authinfo )

static

Definition at line 763 of file http.c.

{
    if (!authinfo) return;
 
    if (SecIsValidHandle(&authinfo->ctx))
        DeleteSecurityContext(&authinfo->ctx);
    if (SecIsValidHandle(&authinfo->cred))
        FreeCredentialsHandle(&authinfo->cred);
 
    heap_free(authinfo->auth_data);
    heap_free(authinfo->scheme);
    heap_free(authinfo);
}

Referenced by HTTP_DoAuthorization(), HTTP_HttpSendRequestW(), and HTTPREQ_Destroy().

destroy_data_stream()

static void destroy_data_stream ( data_stream_t *  stream )

inlinestatic

Definition at line 342 of file http.c.

{
    stream->vtbl->destroy(stream);
}

Referenced by gzip_destroy(), HTTPREQ_Destroy(), and reset_data_stream().

drain_content()

static DWORD drain_content ( http_request_t *  req, BOOL  blocking  )

static

Definition at line 3091 of file http.c.

{
    DWORD res;
 
    TRACE("%p\n", req->netconn);
 
    if(!is_valid_netconn(req->netconn))
        return ERROR_NO_DATA;
 
    if(!wcscmp(req->verb, L"HEAD"))
        return ERROR_SUCCESS;
 
    EnterCriticalSection( &req->read_section );
    res = req->data_stream->vtbl->drain_content(req->data_stream, req, blocking);
    LeaveCriticalSection( &req->read_section );
    return res;
}

Referenced by async_read_file_proc(), HTTP_HttpEndRequestW(), HTTP_HttpSendRequestW(), HTTPREQ_CloseConnection(), HTTPREQ_Read(), and open_http_connection().

encode_auth_data()

static WCHAR * encode_auth_data ( const WCHAR *  scheme, const char *  data, UINT  data_len  )

static

Definition at line 1574 of file http.c.

{
    WCHAR *ret;
    UINT len, scheme_len = lstrlenW( scheme );
 
    /* scheme + space + base64 encoded data (3/2/1 bytes data -> 4 bytes of characters) */
    len = scheme_len + 1 + ((data_len + 2) * 4) / 3;
    if (!(ret = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
    memcpy( ret, scheme, scheme_len * sizeof(WCHAR) );
    ret[scheme_len] = ' ';
    HTTP_EncodeBase64( data, data_len, ret + scheme_len + 1 );
    return ret;
}

Referenced by HTTP_InsertAuthorization().

end_of_read_data()

static BOOL end_of_read_data ( http_request_t *  req )

static

Definition at line 2625 of file http.c.

{
    return !req->read_size && req->data_stream->vtbl->end_of_data(req->data_stream, req);
}

Referenced by HTTPREQ_QueryDataAvailable(), and HTTPREQ_ReadFile().

free_accept_types()

static void free_accept_types ( WCHAR **  accept_types )

static

Definition at line 1346 of file http.c.

{
    WCHAR *ptr, **types = accept_types;
 
    if (!types) return;
    while ((ptr = *types))
    {
        heap_free( ptr );
        types++;
    }
    heap_free( accept_types );
}

Referenced by HttpOpenRequestA().

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

get_host_header()

static WCHAR * get_host_header ( http_request_t *  req )

static

Definition at line 304 of file http.c.

{
    HTTPHEADERW *header;
    WCHAR *ret = NULL;
 
    EnterCriticalSection( &req->headers_section );
    if ((header = HTTP_GetHeader( req, L"Host" ))) ret = heap_strdupW( header->lpszValue );
    else ret = heap_strdupW( req->server->canon_host_port );
    LeaveCriticalSection( &req->headers_section );
    return ret;
}

Referenced by HTTP_InsertAuthorization().

get_redirect_url()

static WCHAR * get_redirect_url ( http_request_t *  request )

static

Definition at line 4076 of file http.c.

{
    static WCHAR szHttp[] = L"http";
    static WCHAR szHttps[] = L"https";
    http_session_t *session = request->session;
    URL_COMPONENTSW urlComponents = { sizeof(urlComponents) };
    WCHAR *orig_url = NULL, *redirect_url = NULL, *combined_url = NULL;
    DWORD url_length = 0, res;
    BOOL b;
 
    url_length = 0;
    res = HTTP_HttpQueryInfoW(request, HTTP_QUERY_LOCATION, redirect_url, &url_length, NULL);
    if(res == ERROR_INSUFFICIENT_BUFFER) {
        redirect_url = heap_alloc(url_length);
        res = HTTP_HttpQueryInfoW(request, HTTP_QUERY_LOCATION, redirect_url, &url_length, NULL);
    }
    if(res != ERROR_SUCCESS) {
        heap_free(redirect_url);
        return NULL;
    }
 
    urlComponents.dwSchemeLength = 1;
    b = InternetCrackUrlW(redirect_url, url_length / sizeof(WCHAR), 0, &urlComponents);
    if(b && urlComponents.dwSchemeLength &&
       urlComponents.nScheme != INTERNET_SCHEME_HTTP && urlComponents.nScheme != INTERNET_SCHEME_HTTPS) {
        TRACE("redirect to non-http URL\n");
        return NULL;
    }
 
    urlComponents.lpszScheme = (request->hdr.dwFlags & INTERNET_FLAG_SECURE) ? szHttps : szHttp;
    urlComponents.dwSchemeLength = 0;
    urlComponents.lpszHostName = request->server->name;
    urlComponents.nPort = request->server->port;
    urlComponents.lpszUserName = session->userName;
    urlComponents.lpszUrlPath = request->path;
 
    b = InternetCreateUrlW(&urlComponents, 0, NULL, &url_length);
    if(!b && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
        orig_url = heap_alloc(url_length);
 
        /* convert from bytes to characters */
        url_length = url_length / sizeof(WCHAR) - 1;
        b = InternetCreateUrlW(&urlComponents, 0, orig_url, &url_length);
    }
 
    if(b) {
        url_length = 0;
        b = InternetCombineUrlW(orig_url, redirect_url, NULL, &url_length, ICU_ENCODE_SPACES_ONLY);
        if(!b && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
            combined_url = heap_alloc(url_length * sizeof(WCHAR));
            b = InternetCombineUrlW(orig_url, redirect_url, combined_url, &url_length, ICU_ENCODE_SPACES_ONLY);
            if(!b) {
                heap_free(combined_url);
                combined_url = NULL;
            }
        }
    }
 
    heap_free(orig_url);
    heap_free(redirect_url);
    return combined_url;
}

Referenced by HTTP_HttpEndRequestW(), and HTTP_HttpSendRequestW().

get_security_cert_struct()

static DWORD get_security_cert_struct ( http_request_t *  req, INTERNET_CERTIFICATE_INFOA *  info  )

static

Definition at line 2022 of file http.c.

{
    PCCERT_CONTEXT context;
    DWORD len;
 
    context = (PCCERT_CONTEXT)NETCON_GetCert(req->netconn);
    if(!context)
        return ERROR_NOT_SUPPORTED;
 
    memset(info, 0, sizeof(*info));
    info->ftExpiry = context->pCertInfo->NotAfter;
    info->ftStart = context->pCertInfo->NotBefore;
    len = CertNameToStrA(context->dwCertEncodingType,
             &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR|CERT_NAME_STR_CRLF_FLAG, NULL, 0);
    info->lpszSubjectInfo = LocalAlloc(0, len);
    if(info->lpszSubjectInfo)
        CertNameToStrA(context->dwCertEncodingType,
                 &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR|CERT_NAME_STR_CRLF_FLAG,
                 info->lpszSubjectInfo, len);
    len = CertNameToStrA(context->dwCertEncodingType,
             &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR|CERT_NAME_STR_CRLF_FLAG, NULL, 0);
    info->lpszIssuerInfo = LocalAlloc(0, len);
    if(info->lpszIssuerInfo)
        CertNameToStrA(context->dwCertEncodingType,
                 &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR|CERT_NAME_STR_CRLF_FLAG,
                 info->lpszIssuerInfo, len);
    info->dwKeySize = NETCON_GetCipherStrength(req->netconn);
 
    CertFreeCertificateContext(context);
    return ERROR_SUCCESS;
}

Referenced by HTTPREQ_QueryOption().

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

gzip_destroy()

static void gzip_destroy ( data_stream_t *  stream )

static

Definition at line 450 of file http.c.

{
    gzip_stream_t *gzip_stream = (gzip_stream_t*)stream;
 
    destroy_data_stream(gzip_stream->parent_stream);
 
    if(!gzip_stream->end_of_data)
        inflateEnd(&gzip_stream->zstream);
    heap_free(gzip_stream);
}

gzip_drain_content()

static DWORD gzip_drain_content ( data_stream_t *  stream, http_request_t *  req, BOOL  allow_blocking  )

static

Definition at line 444 of file http.c.

{
    gzip_stream_t *gzip_stream = (gzip_stream_t*)stream;
    return gzip_stream->parent_stream->vtbl->drain_content(gzip_stream->parent_stream, req, allow_blocking);
}

gzip_end_of_data()

static BOOL gzip_end_of_data ( data_stream_t *  stream, http_request_t *  req  )

static

Definition at line 374 of file http.c.

{
    gzip_stream_t *gzip_stream = (gzip_stream_t*)stream;
    return gzip_stream->end_of_data
        || (!gzip_stream->buf_size && gzip_stream->parent_stream->vtbl->end_of_data(gzip_stream->parent_stream, req));
}

gzip_read()

static DWORD gzip_read ( data_stream_t *  stream, http_request_t *  req, BYTE *  buf, DWORD  size, DWORD *  read, BOOL  allow_blocking  )

static

Definition at line 381 of file http.c.

{
    gzip_stream_t *gzip_stream = (gzip_stream_t*)stream;
    z_stream *zstream = &gzip_stream->zstream;
    DWORD current_read, ret_read = 0;
    int zres;
    DWORD res = ERROR_SUCCESS;
 
    TRACE("(%d %x)\n", size, allow_blocking);
 
    while(size && !gzip_stream->end_of_data) {
        if(!gzip_stream->buf_size) {
            if(gzip_stream->buf_pos) {
                if(gzip_stream->buf_size)
                    memmove(gzip_stream->buf, gzip_stream->buf+gzip_stream->buf_pos, gzip_stream->buf_size);
                gzip_stream->buf_pos = 0;
            }
            res = gzip_stream->parent_stream->vtbl->read(gzip_stream->parent_stream, req, gzip_stream->buf+gzip_stream->buf_size,
                    sizeof(gzip_stream->buf)-gzip_stream->buf_size, &current_read, allow_blocking);
            if(res != ERROR_SUCCESS)
                break;
 
            gzip_stream->buf_size += current_read;
            if(!current_read) {
                WARN("unexpected end of data\n");
                gzip_stream->end_of_data = TRUE;
                break;
            }
        }
 
        zstream->next_in = gzip_stream->buf+gzip_stream->buf_pos;
        zstream->avail_in = gzip_stream->buf_size;
        zstream->next_out = buf+ret_read;
        zstream->avail_out = size;
        zres = inflate(&gzip_stream->zstream, 0);
        current_read = size - zstream->avail_out;
        size -= current_read;
        ret_read += current_read;
        gzip_stream->buf_size -= zstream->next_in - (gzip_stream->buf+gzip_stream->buf_pos);
        gzip_stream->buf_pos = zstream->next_in-gzip_stream->buf;
        if(zres == Z_STREAM_END) {
            TRACE("end of data\n");
            gzip_stream->end_of_data = TRUE;
            inflateEnd(zstream);
        }else if(zres != Z_OK) {
            WARN("inflate failed %d: %s\n", zres, debugstr_a(zstream->msg));
            if(!ret_read)
                res = ERROR_INTERNET_DECODING_FAILED;
            break;
        }
 
        if(ret_read)
            allow_blocking = FALSE;
    }
 
    TRACE("read %u bytes\n", ret_read);
    if(ret_read)
        res = ERROR_SUCCESS;
    *read = ret_read;
    return res;
}

HTTP_build_req()

static LPWSTR HTTP_build_req ( LPCWSTR *  list, int  len  )

static

Definition at line 4259 of file http.c.

{
    LPCWSTR *t;
    LPWSTR str;
 
    for( t = list; *t ; t++  )
        len += lstrlenW( *t );
    len++;
 
    str = heap_alloc(len*sizeof(WCHAR));
    *str = 0;
 
    for( t = list; *t ; t++ )
        lstrcatW( str, *t );
 
    return str;
}

Referenced by build_request_header(), and build_response_header().

HTTP_clear_response_headers()

static void HTTP_clear_response_headers ( http_request_t *  request )

static

Definition at line 5901 of file http.c.

{
    DWORD i;
 
    EnterCriticalSection( &request->headers_section );
 
    for( i=0; i<request->nCustHeaders; i++)
    {
        if( !request->custHeaders[i].lpszField )
            continue;
        if( !request->custHeaders[i].lpszValue )
            continue;
        if ( request->custHeaders[i].wFlags & HDR_ISREQUEST )
            continue;
        HTTP_DeleteCustomHeader( request, i );
        i--;
    }
 
    LeaveCriticalSection( &request->headers_section );
}

Referenced by HTTP_GetResponseHeaders().

HTTP_Connect()

DWORD HTTP_Connect	(	appinfo_t *	hIC,
		LPCWSTR	lpszServerName,
		INTERNET_PORT	serverPort,
		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().

HTTP_DealWithProxy()

static BOOL HTTP_DealWithProxy ( appinfo_t *  hIC, http_session_t *  session, http_request_t *  request  )

static

Definition at line 1748 of file http.c.

{
    static WCHAR szNul[] = L"";
    URL_COMPONENTSW UrlComponents = { sizeof(UrlComponents) };
    server_t *new_server = NULL;
    WCHAR *proxy;
 
    proxy = INTERNET_FindProxyForProtocol(hIC->proxy, L"http");
    if(!proxy)
        return FALSE;
    if(CSTR_EQUAL != CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
                                    proxy, lstrlenW(L"http://"), L"http://", lstrlenW(L"http://"))) {
        WCHAR *proxy_url = heap_alloc(lstrlenW(proxy)*sizeof(WCHAR) + sizeof(L"http://"));
        if(!proxy_url) {
            heap_free(proxy);
            return FALSE;
        }
        lstrcpyW(proxy_url, L"http://");
        lstrcatW(proxy_url, proxy);
        heap_free(proxy);
        proxy = proxy_url;
    }
 
    UrlComponents.dwHostNameLength = 1;
    if(InternetCrackUrlW(proxy, 0, 0, &UrlComponents) && UrlComponents.dwHostNameLength) {
        if( !request->path )
            request->path = szNul;
 
        new_server = get_server(substr(UrlComponents.lpszHostName, UrlComponents.dwHostNameLength),
                                UrlComponents.nPort, UrlComponents.nScheme == INTERNET_SCHEME_HTTPS, TRUE);
    }
    heap_free(proxy);
    if(!new_server)
        return FALSE;
 
    request->proxy = new_server;
 
    TRACE("proxy server=%s port=%d\n", debugstr_w(new_server->name), new_server->port);
    return TRUE;
}

Referenced by HTTP_HttpOpenRequestW().

HTTP_DecodeBase64()

static UINT HTTP_DecodeBase64 ( LPCWSTR  base64, LPSTR  bin  )

static

Definition at line 1524 of file http.c.

{
    unsigned int n = 0;
 
    while(*base64)
    {
        signed char in[4];
 
        if (base64[0] >= ARRAY_SIZE(HTTP_Base64Dec) ||
            ((in[0] = HTTP_Base64Dec[base64[0]]) == -1) ||
            base64[1] >= ARRAY_SIZE(HTTP_Base64Dec) ||
            ((in[1] = HTTP_Base64Dec[base64[1]]) == -1))
        {
            WARN("invalid base64: %s\n", debugstr_w(base64));
            return 0;
        }
        if (bin)
            bin[n] = (unsigned char) (in[0] << 2 | in[1] >> 4);
        n++;
 
        if ((base64[2] == '=') && (base64[3] == '='))
            break;
        if (base64[2] > ARRAY_SIZE(HTTP_Base64Dec) ||
            ((in[2] = HTTP_Base64Dec[base64[2]]) == -1))
        {
            WARN("invalid base64: %s\n", debugstr_w(&base64[2]));
            return 0;
        }
        if (bin)
            bin[n] = (unsigned char) (in[1] << 4 | in[2] >> 2);
        n++;
 
        if (base64[3] == '=')
            break;
        if (base64[3] > ARRAY_SIZE(HTTP_Base64Dec) ||
            ((in[3] = HTTP_Base64Dec[base64[3]]) == -1))
        {
            WARN("invalid base64: %s\n", debugstr_w(&base64[3]));
            return 0;
        }
        if (bin)
            bin[n] = (unsigned char) (((in[2] << 6) & 0xc0) | in[3]);
        n++;
 
        base64 += 4;
    }
 
    return n;
}

Referenced by HTTP_DoAuthorization().

HTTP_DeleteCustomHeader()

static BOOL HTTP_DeleteCustomHeader ( http_request_t *  req, DWORD  index  )

static

Definition at line 6322 of file http.c.

{
    if( request->nCustHeaders <= 0 )
        return FALSE;
    if( index >= request->nCustHeaders )
        return FALSE;
    request->nCustHeaders--;
 
    heap_free(request->custHeaders[index].lpszField);
    heap_free(request->custHeaders[index].lpszValue);
 
    memmove( &request->custHeaders[index], &request->custHeaders[index+1],
             (request->nCustHeaders - index)* sizeof(HTTPHEADERW) );
    memset( &request->custHeaders[request->nCustHeaders], 0, sizeof(HTTPHEADERW) );
 
    return TRUE;
}

Referenced by HTTP_clear_response_headers(), HTTP_ProcessHeader(), remove_header(), and set_content_length().

HTTP_DoAuthorization()

static BOOL HTTP_DoAuthorization ( http_request_t *  request, LPCWSTR  pszAuthValue, struct HttpAuthInfo **  ppAuthInfo, LPWSTR  domain_and_username, LPWSTR  password, LPWSTR  host  )

static

Definition at line 974 of file http.c.

{
    SECURITY_STATUS sec_status;
    struct HttpAuthInfo *pAuthInfo = *ppAuthInfo;
    BOOL first = FALSE;
    LPWSTR szRealm = NULL;
 
    TRACE("%s\n", debugstr_w(pszAuthValue));
 
    if (!pAuthInfo)
    {
        TimeStamp exp;
 
        first = TRUE;
        pAuthInfo = heap_alloc(sizeof(*pAuthInfo));
        if (!pAuthInfo)
            return FALSE;
 
        SecInvalidateHandle(&pAuthInfo->cred);
        SecInvalidateHandle(&pAuthInfo->ctx);
        memset(&pAuthInfo->exp, 0, sizeof(pAuthInfo->exp));
        pAuthInfo->attr = 0;
        pAuthInfo->auth_data = NULL;
        pAuthInfo->auth_data_len = 0;
        pAuthInfo->finished = FALSE;
 
        if (is_basic_auth_value(pszAuthValue,NULL))
        {
            pAuthInfo->scheme = heap_strdupW(L"Basic");
            if (!pAuthInfo->scheme)
            {
                heap_free(pAuthInfo);
                return FALSE;
            }
        }
        else
        {
            PVOID pAuthData;
            SEC_WINNT_AUTH_IDENTITY_W nt_auth_identity;
 
            pAuthInfo->scheme = heap_strdupW(pszAuthValue);
            if (!pAuthInfo->scheme)
            {
                heap_free(pAuthInfo);
                return FALSE;
            }
 
            if (domain_and_username)
            {
                WCHAR *user = wcschr(domain_and_username, '\\');
                WCHAR *domain = domain_and_username;
 
                /* FIXME: make sure scheme accepts SEC_WINNT_AUTH_IDENTITY before calling AcquireCredentialsHandle */
 
                pAuthData = &nt_auth_identity;
 
                if (user) user++;
                else
                {
                    user = domain_and_username;
                    domain = NULL;
                }
 
                nt_auth_identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
                nt_auth_identity.User = user;
                nt_auth_identity.UserLength = lstrlenW(nt_auth_identity.User);
                nt_auth_identity.Domain = domain;
                nt_auth_identity.DomainLength = domain ? user - domain - 1 : 0;
                nt_auth_identity.Password = password;
                nt_auth_identity.PasswordLength = lstrlenW(nt_auth_identity.Password);
 
                cache_authorization(host, pAuthInfo->scheme, &nt_auth_identity);
            }
            else if(retrieve_cached_authorization(host, pAuthInfo->scheme, &nt_auth_identity))
                pAuthData = &nt_auth_identity;
            else
                /* use default credentials */
                pAuthData = NULL;
 
            sec_status = AcquireCredentialsHandleW(NULL, pAuthInfo->scheme,
                                                   SECPKG_CRED_OUTBOUND, NULL,
                                                   pAuthData, NULL,
                                                   NULL, &pAuthInfo->cred,
                                                   &exp);
 
            if(pAuthData && !domain_and_username) {
                heap_free(nt_auth_identity.User);
                heap_free(nt_auth_identity.Domain);
                heap_free(nt_auth_identity.Password);
            }
 
            if (sec_status == SEC_E_OK)
            {
                PSecPkgInfoW sec_pkg_info;
                sec_status = QuerySecurityPackageInfoW(pAuthInfo->scheme, &sec_pkg_info);
                if (sec_status == SEC_E_OK)
                {
                    pAuthInfo->max_token = sec_pkg_info->cbMaxToken;
                    FreeContextBuffer(sec_pkg_info);
                }
            }
            if (sec_status != SEC_E_OK)
            {
                WARN("AcquireCredentialsHandleW for scheme %s failed with error 0x%08x\n",
                     debugstr_w(pAuthInfo->scheme), sec_status);
                heap_free(pAuthInfo->scheme);
                heap_free(pAuthInfo);
                return FALSE;
            }
        }
        *ppAuthInfo = pAuthInfo;
    }
    else if (pAuthInfo->finished)
        return FALSE;
 
    if ((lstrlenW(pszAuthValue) < lstrlenW(pAuthInfo->scheme)) ||
        wcsnicmp(pszAuthValue, pAuthInfo->scheme, lstrlenW(pAuthInfo->scheme)))
    {
        ERR("authentication scheme changed from %s to %s\n",
            debugstr_w(pAuthInfo->scheme), debugstr_w(pszAuthValue));
        return FALSE;
    }
 
    if (is_basic_auth_value(pszAuthValue,&szRealm))
    {
        int userlen;
        int passlen;
        char *auth_data = NULL;
        UINT auth_data_len = 0;
 
        TRACE("basic authentication realm %s\n",debugstr_w(szRealm));
 
        if (!domain_and_username)
        {
            if (host && szRealm)
                auth_data_len = retrieve_cached_basic_authorization(request, host, szRealm,&auth_data);
            if (auth_data_len == 0)
            {
                heap_free(szRealm);
                return FALSE;
            }
        }
        else
        {
            userlen = WideCharToMultiByte(CP_UTF8, 0, domain_and_username, lstrlenW(domain_and_username), NULL, 0, NULL, NULL);
            passlen = WideCharToMultiByte(CP_UTF8, 0, password, lstrlenW(password), NULL, 0, NULL, NULL);
 
            /* length includes a nul terminator, which will be re-used for the ':' */
            auth_data = heap_alloc(userlen + 1 + passlen);
            if (!auth_data)
            {
                heap_free(szRealm);
                return FALSE;
            }
 
            WideCharToMultiByte(CP_UTF8, 0, domain_and_username, -1, auth_data, userlen, NULL, NULL);
            auth_data[userlen] = ':';
            WideCharToMultiByte(CP_UTF8, 0, password, -1, &auth_data[userlen+1], passlen, NULL, NULL);
            auth_data_len = userlen + 1 + passlen;
            if (host && szRealm)
                cache_basic_authorization(host, szRealm, auth_data, auth_data_len);
        }
 
        pAuthInfo->auth_data = auth_data;
        pAuthInfo->auth_data_len = auth_data_len;
        pAuthInfo->finished = TRUE;
        heap_free(szRealm);
        return TRUE;
    }
    else
    {
        LPCWSTR pszAuthData;
        SecBufferDesc out_desc, in_desc;
        SecBuffer out, in;
        unsigned char *buffer;
        ULONG context_req = ISC_REQ_CONNECTION | ISC_REQ_USE_DCE_STYLE |
            ISC_REQ_MUTUAL_AUTH | ISC_REQ_DELEGATE;
 
        in.BufferType = SECBUFFER_TOKEN;
        in.cbBuffer = 0;
        in.pvBuffer = NULL;
 
        in_desc.ulVersion = 0;
        in_desc.cBuffers = 1;
        in_desc.pBuffers = &in;
 
        pszAuthData = pszAuthValue + lstrlenW(pAuthInfo->scheme);
        if (*pszAuthData == ' ')
        {
            pszAuthData++;
            in.cbBuffer = HTTP_DecodeBase64(pszAuthData, NULL);
            in.pvBuffer = heap_alloc(in.cbBuffer);
            HTTP_DecodeBase64(pszAuthData, in.pvBuffer);
        }
 
        buffer = heap_alloc(pAuthInfo->max_token);
 
        out.BufferType = SECBUFFER_TOKEN;
        out.cbBuffer = pAuthInfo->max_token;
        out.pvBuffer = buffer;
 
        out_desc.ulVersion = 0;
        out_desc.cBuffers = 1;
        out_desc.pBuffers = &out;
 
        sec_status = InitializeSecurityContextW(first ? &pAuthInfo->cred : NULL,
                                                first ? NULL : &pAuthInfo->ctx,
                                                first ? request->server->name : NULL,
                                                context_req, 0, SECURITY_NETWORK_DREP,
                                                in.pvBuffer ? &in_desc : NULL,
                                                0, &pAuthInfo->ctx, &out_desc,
                                                &pAuthInfo->attr, &pAuthInfo->exp);
        if (sec_status == SEC_E_OK)
        {
            pAuthInfo->finished = TRUE;
            pAuthInfo->auth_data = out.pvBuffer;
            pAuthInfo->auth_data_len = out.cbBuffer;
            TRACE("sending last auth packet\n");
        }
        else if (sec_status == SEC_I_CONTINUE_NEEDED)
        {
            pAuthInfo->auth_data = out.pvBuffer;
            pAuthInfo->auth_data_len = out.cbBuffer;
            TRACE("sending next auth packet\n");
        }
        else
        {
            ERR("InitializeSecurityContextW returned error 0x%08x\n", sec_status);
            heap_free(out.pvBuffer);
            destroy_authinfo(pAuthInfo);
            *ppAuthInfo = NULL;
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by HTTP_HttpSendRequestW().

HTTP_DomainMatches()

static BOOL HTTP_DomainMatches ( LPCWSTR  server, substr_t  domain  )

static

Definition at line 1680 of file http.c.

{
    const WCHAR *dot, *ptr;
    int len;
 
    if(domain.len == ARRAY_SIZE(L"<local>")-1 && !wcsnicmp(domain.str, L"<local>", domain.len) && !wcschr(server, '.' ))
        return TRUE;
 
    if(domain.len && *domain.str != '*')
        return domain.len == lstrlenW(server) && !wcsnicmp(server, domain.str, domain.len);
 
    if(domain.len < 2 || domain.str[1] != '.')
        return FALSE;
 
    /* For a hostname to match a wildcard, the last domain must match
     * the wildcard exactly.  E.g. if the wildcard is *.a.b, and the
     * hostname is www.foo.a.b, it matches, but a.b does not.
     */
    dot = wcschr(server, '.');
    if(!dot)
        return FALSE;
 
    len = lstrlenW(dot + 1);
    if(len < domain.len - 2)
        return FALSE;
 
    /* The server's domain is longer than the wildcard, so it
     * could be a subdomain.  Compare the last portion of the
     * server's domain.
     */
    ptr = dot + 1 + len - domain.len + 2;
    if(!wcsnicmp(ptr, domain.str+2, domain.len-2))
        /* This is only a match if the preceding character is
         * a '.', i.e. that it is a matching domain.  E.g.
         * if domain is '*.b.c' and server is 'www.ab.c' they
         * do not match.
         */
        return *(ptr - 1) == '.';
 
    return len == domain.len-2 && !wcsnicmp(dot + 1, domain.str + 2, len);
}

Referenced by HTTP_ShouldBypassProxy().

HTTP_EncodeBase64()

static UINT HTTP_EncodeBase64 ( LPCSTR  bin, unsigned int  len, LPWSTR  base64  )

static

Definition at line 1468 of file http.c.

{
    UINT n = 0, x;
    static const CHAR HTTP_Base64Enc[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
    while( len > 0 )
    {
        /* first 6 bits, all from bin[0] */
        base64[n++] = HTTP_Base64Enc[(bin[0] & 0xfc) >> 2];
        x = (bin[0] & 3) << 4;
 
        /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
        if( len == 1 )
        {
            base64[n++] = HTTP_Base64Enc[x];
            base64[n++] = '=';
            base64[n++] = '=';
            break;
        }
        base64[n++] = HTTP_Base64Enc[ x | ( (bin[1]&0xf0) >> 4 ) ];
        x = ( bin[1] & 0x0f ) << 2;
 
        /* next 6 bits 4 from bin[1] and 2 from bin[2] */
        if( len == 2 )
        {
            base64[n++] = HTTP_Base64Enc[x];
            base64[n++] = '=';
            break;
        }
        base64[n++] = HTTP_Base64Enc[ x | ( (bin[2]&0xc0 ) >> 6 ) ];
 
        /* last 6 bits, all from bin [2] */
        base64[n++] = HTTP_Base64Enc[ bin[2] & 0x3f ];
        bin += 3;
        len -= 3;
    }
    base64[n] = 0;
    return n;
}

Referenced by encode_auth_data().

HTTP_FixURL()

static void HTTP_FixURL ( http_request_t *  request )

static

Definition at line 524 of file http.c.

{
    /* If we don't have a path we set it to root */
    if (NULL == request->path)
        request->path = heap_strdupW(L"/");
    else /* remove \r and \n*/
    {
        int nLen = lstrlenW(request->path);
        while ((nLen >0 ) && ((request->path[nLen-1] == '\r')||(request->path[nLen-1] == '\n')))
        {
            nLen--;
            request->path[nLen]='\0';
        }
        /* Replace '\' with '/' */
        while (nLen>0) {
            nLen--;
            if (request->path[nLen] == '\\') request->path[nLen]='/';
        }
    }
 
    if(CSTR_EQUAL != CompareStringW( LOCALE_INVARIANT, NORM_IGNORECASE,
                       request->path, lstrlenW(request->path), L"http://", lstrlenW(L"http://") )
       && request->path[0] != '/') /* not an absolute path ?? --> fix it !! */
    {
        WCHAR *fixurl = heap_alloc((lstrlenW(request->path) + 2)*sizeof(WCHAR));
        *fixurl = '/';
        lstrcpyW(fixurl + 1, request->path);
        heap_free( request->path );
        request->path = fixurl;
    }
}

Referenced by HTTP_HttpSendRequestW().

HTTP_FreeTokens()

static void HTTP_FreeTokens ( LPWSTR *  token_array )

static

Definition at line 517 of file http.c.

{
    int i;
    for (i = 0; token_array[i]; i++) heap_free(token_array[i]);
    heap_free(token_array);
}

Referenced by HTTP_GetResponseHeaders(), HTTP_HttpAddRequestHeadersW(), and HTTP_InterpretHttpHeader().

HTTP_GetCustomHeaderIndex() [1/2]

static INT HTTP_GetCustomHeaderIndex ( http_request_t *  req, LPCWSTR  lpszField, INT  index, BOOL  Request  )

static

Referenced by create_cache_entry(), HTTP_GetHeader(), HTTP_HttpQueryInfoW(), HTTP_HttpSendRequestW(), http_process_keep_alive(), HTTP_ProcessCookies(), HTTP_ProcessExpires(), HTTP_ProcessHeader(), HTTP_ProcessLastModified(), remove_header(), and set_content_length().

HTTP_GetCustomHeaderIndex() [2/2]

static INT HTTP_GetCustomHeaderIndex ( http_request_t *  request, LPCWSTR  lpszField, int  requested_index, BOOL  request_only  )

static

Definition at line 6252 of file http.c.

{
    DWORD index;
 
    TRACE("%s, %d, %d\n", debugstr_w(lpszField), requested_index, request_only);
 
    for (index = 0; index < request->nCustHeaders; index++)
    {
        if (wcsicmp(request->custHeaders[index].lpszField, lpszField))
            continue;
 
        if (request_only && !(request->custHeaders[index].wFlags & HDR_ISREQUEST))
            continue;
 
        if (!request_only && (request->custHeaders[index].wFlags & HDR_ISREQUEST))
            continue;
 
        if (requested_index == 0)
            break;
        requested_index --;
    }
 
    if (index >= request->nCustHeaders)
    index = -1;
 
    TRACE("Return: %d\n", index);
    return index;
}

HTTP_GetHeader()

static LPHTTPHEADERW HTTP_GetHeader ( http_request_t *  req, LPCWSTR  head  )

static

Definition at line 294 of file http.c.

{
    int HeaderIndex = 0;
    HeaderIndex = HTTP_GetCustomHeaderIndex(req, head, 0, TRUE);
    if (HeaderIndex == -1)
        return NULL;
    else
        return &req->custHeaders[HeaderIndex];
}

Referenced by get_host_header(), and HTTP_HttpSendRequestW().

HTTP_GetResponseHeaders()

static DWORD HTTP_GetResponseHeaders ( http_request_t *  req, INT *  len  )

static

Definition at line 5932 of file http.c.

{
    INT cbreaks = 0;
    WCHAR buffer[MAX_REPLY_LEN];
    DWORD buflen = MAX_REPLY_LEN;
    INT  rc = 0;
    char bufferA[MAX_REPLY_LEN];
    LPWSTR status_code = NULL, status_text = NULL;
    DWORD res = ERROR_HTTP_INVALID_SERVER_RESPONSE;
    BOOL codeHundred = FALSE;
 
    TRACE("-->\n");
 
    if(!is_valid_netconn(request->netconn))
        goto lend;
 
    /* clear old response headers (eg. from a redirect response) */
    HTTP_clear_response_headers( request );
 
    NETCON_set_timeout( request->netconn, FALSE, request->receive_timeout );
    do {
        /*
         * We should first receive 'HTTP/1.x nnn OK' where nnn is the status code.
         */
        buflen = MAX_REPLY_LEN;
        if ((res = read_line(request, bufferA, &buflen)))
            goto lend;
 
        if (!buflen) goto lend;
 
        rc += buflen;
        MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
        /* check is this a status code line? */
        if (!wcsncmp(buffer, L"HTTP/1.0", 4))
        {
            /* split the version from the status code */
            status_code = wcschr( buffer, ' ' );
            if( !status_code )
                goto lend;
            *status_code++=0;
 
            /* split the status code from the status text */
            status_text = wcschr( status_code, ' ' );
            if( status_text )
                *status_text++=0;
 
            request->status_code = wcstol(status_code, NULL, 10);
 
            TRACE("version [%s] status code [%s] status text [%s]\n",
               debugstr_w(buffer), debugstr_w(status_code), debugstr_w(status_text) );
 
            codeHundred = request->status_code == HTTP_STATUS_CONTINUE;
        }
        else if (!codeHundred)
        {
            WARN("No status line at head of response (%s)\n", debugstr_w(buffer));
 
            heap_free(request->version);
            heap_free(request->statusText);
 
            request->status_code = HTTP_STATUS_OK;
            request->version = heap_strdupW(L"HTTP/1.0");
            request->statusText = heap_strdupW(L"OK");
 
            goto lend;
        }
    } while (codeHundred);
 
    /* Add status code */
    HTTP_ProcessHeader(request, L"Status", status_code,
                       HTTP_ADDHDR_FLAG_REPLACE | HTTP_ADDHDR_FLAG_ADD);
 
    heap_free(request->version);
    heap_free(request->statusText);
 
    request->version = heap_strdupW(buffer);
    request->statusText = heap_strdupW(status_text ? status_text : L"");
 
    /* Restore the spaces */
    *(status_code-1) = ' ';
    if (status_text)
        *(status_text-1) = ' ';
 
    /* Parse each response line */
    do
    {
        buflen = MAX_REPLY_LEN;
        if (!read_line(request, bufferA, &buflen) && buflen)
        {
            LPWSTR * pFieldAndValue;
 
            TRACE("got line %s, now interpreting\n", debugstr_a(bufferA));
 
            if (!bufferA[0]) break;
            MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
 
            pFieldAndValue = HTTP_InterpretHttpHeader(buffer);
            if (pFieldAndValue)
            {
                HTTP_ProcessHeader(request, pFieldAndValue[0], pFieldAndValue[1],
                                   HTTP_ADDREQ_FLAG_ADD );
                HTTP_FreeTokens(pFieldAndValue);
            }
        }
        else
        {
            cbreaks++;
            if (cbreaks >= 2)
                break;
        }
    }while(1);
 
    res = ERROR_SUCCESS;
 
lend:
 
    *len = rc;
    TRACE("<--\n");
    return res;
}

Referenced by HTTP_HttpEndRequestW(), and HTTP_HttpSendRequestW().

HTTP_HandleRedirect()

static DWORD HTTP_HandleRedirect ( http_request_t *  request, WCHAR *  url  )

static

Definition at line 4143 of file http.c.

{
    URL_COMPONENTSW urlComponents = { sizeof(urlComponents) };
    http_session_t *session = request->session;
    size_t url_len = lstrlenW(url);
 
    if(url[0] == '/')
    {
        /* if it's an absolute path, keep the same session info */
        urlComponents.lpszUrlPath = url;
        urlComponents.dwUrlPathLength = url_len;
    }
    else
    {
        urlComponents.dwHostNameLength = 1;
        urlComponents.dwUserNameLength = 1;
        urlComponents.dwUrlPathLength = 1;
        if(!InternetCrackUrlW(url, url_len, 0, &urlComponents))
            return INTERNET_GetLastError();
 
        if(!urlComponents.dwHostNameLength)
            return ERROR_INTERNET_INVALID_URL;
    }
 
    INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_REDIRECT,
                          url, (url_len + 1) * sizeof(WCHAR));
 
    if(urlComponents.dwHostNameLength) {
        BOOL custom_port = FALSE;
        substr_t host;
 
        if(urlComponents.nScheme == INTERNET_SCHEME_HTTP) {
            if(request->hdr.dwFlags & INTERNET_FLAG_SECURE) {
                TRACE("redirect from secure page to non-secure page\n");
                /* FIXME: warn about from secure redirect to non-secure page */
                request->hdr.dwFlags &= ~INTERNET_FLAG_SECURE;
            }
 
            custom_port = urlComponents.nPort != INTERNET_DEFAULT_HTTP_PORT;
        }else if(urlComponents.nScheme == INTERNET_SCHEME_HTTPS) {
            if(!(request->hdr.dwFlags & INTERNET_FLAG_SECURE)) {
                TRACE("redirect from non-secure page to secure page\n");
                /* FIXME: notify about redirect to secure page */
                request->hdr.dwFlags |= INTERNET_FLAG_SECURE;
            }
 
            custom_port = urlComponents.nPort != INTERNET_DEFAULT_HTTPS_PORT;
        }
 
        heap_free(session->hostName);
 
        session->hostName = heap_strndupW(urlComponents.lpszHostName, urlComponents.dwHostNameLength);
        session->hostPort = urlComponents.nPort;
 
        heap_free(session->userName);
        session->userName = NULL;
        if (urlComponents.dwUserNameLength)
            session->userName = heap_strndupW(urlComponents.lpszUserName, urlComponents.dwUserNameLength);
 
        reset_data_stream(request);
 
        host = substr(urlComponents.lpszHostName, urlComponents.dwHostNameLength);
 
        if(host.len != lstrlenW(request->server->name) || wcsnicmp(request->server->name, host.str, host.len)
           || request->server->port != urlComponents.nPort) {
            server_t *new_server;
 
            new_server = get_server(host, urlComponents.nPort, urlComponents.nScheme == INTERNET_SCHEME_HTTPS, TRUE);
            server_release(request->server);
            request->server = new_server;
        }
 
        if (custom_port)
            HTTP_ProcessHeader(request, L"Host", request->server->host_port,
                               HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDHDR_FLAG_REQ);
        else
            HTTP_ProcessHeader(request, L"Host", request->server->name,
                               HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDHDR_FLAG_REQ);
    }
 
    heap_free(request->path);
    request->path = NULL;
    if(urlComponents.dwUrlPathLength)
    {
        DWORD needed = 1;
        HRESULT rc;
        WCHAR dummy[] = L"";
        WCHAR *path;
 
        path = heap_strndupW(urlComponents.lpszUrlPath, urlComponents.dwUrlPathLength);
        rc = UrlEscapeW(path, dummy, &needed, URL_ESCAPE_SPACES_ONLY);
        if (rc != E_POINTER)
            ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(path),rc);
        request->path = heap_alloc(needed*sizeof(WCHAR));
        rc = UrlEscapeW(path, request->path, &needed,
                        URL_ESCAPE_SPACES_ONLY);
        if (rc != S_OK)
        {
            ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(path),rc);
            lstrcpyW(request->path, path);
        }
        heap_free(path);
    }
 
    /* Remove custom content-type/length headers on redirects.  */
    remove_header(request, L"Content-Type", TRUE);
    remove_header(request, L"Content-Length", TRUE);
 
    return ERROR_SUCCESS;
}

Referenced by HTTP_HttpEndRequestW(), and HTTP_HttpSendRequestW().

HTTP_HttpAddRequestHeadersW()

static DWORD HTTP_HttpAddRequestHeadersW ( http_request_t *  request, LPCWSTR  lpszHeader, DWORD  dwHeaderLength, DWORD  dwModifier  )

static

Definition at line 1218 of file http.c.

{
    LPWSTR lpszStart;
    LPWSTR lpszEnd;
    LPWSTR buffer;
    DWORD len, res = ERROR_HTTP_INVALID_HEADER;
 
    TRACE("copying header: %s\n", debugstr_wn(lpszHeader, dwHeaderLength));
 
    if( dwHeaderLength == ~0U )
        len = lstrlenW(lpszHeader);
    else
        len = dwHeaderLength;
    buffer = heap_alloc(sizeof(WCHAR)*(len+1));
    lstrcpynW( buffer, lpszHeader, len + 1);
 
    lpszStart = buffer;
 
    do
    {
        LPWSTR * pFieldAndValue;
 
        lpszEnd = lpszStart;
 
        while (*lpszEnd != '\0')
        {
            if (*lpszEnd == '\r' || *lpszEnd == '\n')
                 break;
            lpszEnd++;
        }
 
        if (*lpszStart == '\0')
        break;
 
        if (*lpszEnd == '\r' || *lpszEnd == '\n')
        {
            *lpszEnd = '\0';
            lpszEnd++; /* Jump over newline */
        }
        TRACE("interpreting header %s\n", debugstr_w(lpszStart));
        if (*lpszStart == '\0')
        {
            /* Skip 0-length headers */
            lpszStart = lpszEnd;
            res = ERROR_SUCCESS;
            continue;
        }
        pFieldAndValue = HTTP_InterpretHttpHeader(lpszStart);
        if (pFieldAndValue)
        {
            res = HTTP_ProcessHeader(request, pFieldAndValue[0],
                pFieldAndValue[1], dwModifier | HTTP_ADDHDR_FLAG_REQ);
            HTTP_FreeTokens(pFieldAndValue);
        }
 
        lpszStart = lpszEnd;
    } while (res == ERROR_SUCCESS);
 
    heap_free(buffer);
    return res;
}

Referenced by HTTP_HttpSendRequestW(), HTTP_InsertCookies(), HttpAddRequestHeadersW(), and set_content_length_header().

HTTP_HttpEndRequestW()

static DWORD HTTP_HttpEndRequestW ( http_request_t *  request, DWORD  dwFlags, DWORD_PTR  dwContext  )

static

Definition at line 5269 of file http.c.

{
    INT responseLen;
    DWORD res = ERROR_SUCCESS;
 
    if(!is_valid_netconn(request->netconn)) {
        WARN("Not connected\n");
        send_request_complete(request, 0, ERROR_INTERNET_OPERATION_CANCELLED);
        return ERROR_INTERNET_OPERATION_CANCELLED;
    }
 
    INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
                  INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
 
    if (HTTP_GetResponseHeaders(request, &responseLen) || !responseLen)
        res = ERROR_HTTP_HEADER_NOT_FOUND;
 
    INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
                  INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen, sizeof(DWORD));
 
    /* process cookies here. Is this right? */
    http_process_keep_alive(request);
    HTTP_ProcessCookies(request);
    HTTP_ProcessExpires(request);
    HTTP_ProcessLastModified(request);
 
    if ((res = set_content_length(request)) == ERROR_SUCCESS) {
        if(!request->contentLength)
            http_release_netconn(request, TRUE);
    }
 
    if (res == ERROR_SUCCESS && !(request->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT))
    {
        switch(request->status_code) {
        case HTTP_STATUS_REDIRECT:
        case HTTP_STATUS_MOVED:
        case HTTP_STATUS_REDIRECT_METHOD:
        case HTTP_STATUS_REDIRECT_KEEP_VERB: {
            WCHAR *new_url;
 
            new_url = get_redirect_url(request);
            if(!new_url)
                break;
 
            if (wcscmp(request->verb, L"GET") && wcscmp(request->verb, L"HEAD") &&
                request->status_code != HTTP_STATUS_REDIRECT_KEEP_VERB)
            {
                heap_free(request->verb);
                request->verb = heap_strdupW(L"GET");
            }
            http_release_netconn(request, drain_content(request, FALSE) == ERROR_SUCCESS);
            res = HTTP_HandleRedirect(request, new_url);
            heap_free(new_url);
            if (res == ERROR_SUCCESS)
                res = HTTP_HttpSendRequestW(request, NULL, 0, NULL, 0, 0, TRUE);
        }
        }
    }
 
    if(res == ERROR_SUCCESS)
        create_cache_entry(request);
 
    if (res == ERROR_SUCCESS && request->contentLength)
        HTTP_ReceiveRequestData(request);
    else
        send_request_complete(request, res == ERROR_SUCCESS, res);
 
    return res;
}

Referenced by AsyncHttpEndRequestProc(), and HttpEndRequestW().

HTTP_HttpOpenRequestW()

static DWORD HTTP_HttpOpenRequestW ( http_session_t *  session, LPCWSTR  lpszVerb, LPCWSTR  lpszObjectName, LPCWSTR  lpszVersion, LPCWSTR  lpszReferrer, LPCWSTR *  lpszAcceptTypes, DWORD  dwFlags, DWORD_PTR  dwContext, HINTERNET *  ret  )

static

Definition at line 3354 of file http.c.

{
    appinfo_t *hIC = session->appInfo;
    http_request_t *request;
    DWORD port, len;
 
    TRACE("-->\n");
 
    request = alloc_object(&session->hdr, &HTTPREQVtbl, sizeof(http_request_t));
    if(!request)
        return ERROR_OUTOFMEMORY;
 
    request->hdr.htype = WH_HHTTPREQ;
    request->hdr.dwFlags = dwFlags;
    request->hdr.dwContext = dwContext;
    request->hdr.decoding = session->hdr.decoding;
    request->contentLength = ~0;
 
    request->netconn_stream.data_stream.vtbl = &netconn_stream_vtbl;
    request->data_stream = &request->netconn_stream.data_stream;
    request->connect_timeout = session->connect_timeout;
    request->send_timeout = session->send_timeout;
    request->receive_timeout = session->receive_timeout;
 
    InitializeCriticalSection( &request->headers_section );
    request->headers_section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": http_request_t.headers_section");
 
    InitializeCriticalSection( &request->read_section );
    request->read_section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": http_request_t.read_section");
 
    WININET_AddRef( &session->hdr );
    request->session = session;
    list_add_head( &session->hdr.children, &request->hdr.entry );
 
    port = session->hostPort;
    if (port == INTERNET_INVALID_PORT_NUMBER)
        port = (session->hdr.dwFlags & INTERNET_FLAG_SECURE) ?
                INTERNET_DEFAULT_HTTPS_PORT : INTERNET_DEFAULT_HTTP_PORT;
 
    request->server = get_server(substrz(session->hostName), port, (dwFlags & INTERNET_FLAG_SECURE) != 0, TRUE);
    if(!request->server) {
        WININET_Release(&request->hdr);
        return ERROR_OUTOFMEMORY;
    }
 
    if (dwFlags & INTERNET_FLAG_IGNORE_CERT_CN_INVALID)
        request->security_flags |= SECURITY_FLAG_IGNORE_CERT_CN_INVALID;
    if (dwFlags & INTERNET_FLAG_IGNORE_CERT_DATE_INVALID)
        request->security_flags |= SECURITY_FLAG_IGNORE_CERT_DATE_INVALID;
 
    if (lpszObjectName && *lpszObjectName) {
        HRESULT rc;
        WCHAR dummy;
 
        len = 1;
        rc = UrlCanonicalizeW(lpszObjectName, &dummy, &len, URL_ESCAPE_SPACES_ONLY);
        if (rc != E_POINTER)
            len = lstrlenW(lpszObjectName)+1;
        request->path = heap_alloc(len*sizeof(WCHAR));
        rc = UrlCanonicalizeW(lpszObjectName, request->path, &len,
                   URL_ESCAPE_SPACES_ONLY);
        if (rc != S_OK)
        {
            ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(lpszObjectName),rc);
            lstrcpyW(request->path,lpszObjectName);
        }
    }else {
        request->path = heap_strdupW(L"/");
    }
 
    if (lpszReferrer && *lpszReferrer)
        HTTP_ProcessHeader(request, L"Referer", lpszReferrer, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REQ);
 
    if (lpszAcceptTypes)
    {
        int i;
        for (i = 0; lpszAcceptTypes[i]; i++)
        {
            if (!*lpszAcceptTypes[i]) continue;
            HTTP_ProcessHeader(request, L"Accept", lpszAcceptTypes[i],
                               HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA |
                               HTTP_ADDHDR_FLAG_REQ |
                               (i == 0 ? (HTTP_ADDHDR_FLAG_REPLACE | HTTP_ADDHDR_FLAG_ADD) : 0));
        }
    }
 
    request->verb = heap_strdupW(lpszVerb && *lpszVerb ? lpszVerb : L"GET");
    request->version = heap_strdupW(lpszVersion && *lpszVersion ? lpszVersion : L"HTTP/1.1");
 
    if (hIC->proxy && hIC->proxy[0] && !HTTP_ShouldBypassProxy(hIC, session->hostName))
        HTTP_DealWithProxy( hIC, session, request );
 
    INTERNET_SendCallback(&session->hdr, dwContext,
                          INTERNET_STATUS_HANDLE_CREATED, &request->hdr.hInternet,
                          sizeof(HINTERNET));
 
    TRACE("<-- (%p)\n", request);
 
    *ret = request->hdr.hInternet;
    return ERROR_SUCCESS;
}

Referenced by HttpOpenRequestW().

HTTP_HttpQueryInfoW()

static DWORD HTTP_HttpQueryInfoW ( http_request_t *  request, DWORD  dwInfoLevel, LPVOID  lpBuffer, LPDWORD  lpdwBufferLength, LPDWORD  lpdwIndex  )

static

Definition at line 3592 of file http.c.

{
    LPHTTPHEADERW lphttpHdr = NULL;
    BOOL request_only = !!(dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS);
    INT requested_index = lpdwIndex ? *lpdwIndex : 0;
    DWORD level = (dwInfoLevel & ~HTTP_QUERY_MODIFIER_FLAGS_MASK);
    INT index = -1;
 
    EnterCriticalSection( &request->headers_section );
 
    /* Find requested header structure */
    switch (level)
    {
    case HTTP_QUERY_CUSTOM:
        if (!lpBuffer)
        {
            LeaveCriticalSection( &request->headers_section );
            return ERROR_INVALID_PARAMETER;
        }
        index = HTTP_GetCustomHeaderIndex(request, lpBuffer, requested_index, request_only);
        break;
    case HTTP_QUERY_RAW_HEADERS_CRLF:
        {
            LPWSTR headers;
            DWORD len = 0;
            DWORD res = ERROR_INVALID_PARAMETER;
 
            if (request_only)
                headers = build_request_header(request, request->verb, request->path, request->version, TRUE);
            else
                headers = build_response_header(request, TRUE);
            if (!headers)
            {
                LeaveCriticalSection( &request->headers_section );
                return ERROR_OUTOFMEMORY;
            }
 
            len = lstrlenW(headers) * sizeof(WCHAR);
            if (len + sizeof(WCHAR) > *lpdwBufferLength)
            {
                len += sizeof(WCHAR);
                res = ERROR_INSUFFICIENT_BUFFER;
            }
            else if (lpBuffer)
            {
                memcpy(lpBuffer, headers, len + sizeof(WCHAR));
                TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len / sizeof(WCHAR)));
                res = ERROR_SUCCESS;
            }
            *lpdwBufferLength = len;
 
            heap_free(headers);
            LeaveCriticalSection( &request->headers_section );
            return res;
        }
    case HTTP_QUERY_RAW_HEADERS:
        {
            LPWSTR headers;
            DWORD len;
 
            if (request_only)
                headers = build_request_header(request, request->verb, request->path, request->version, FALSE);
            else
                headers = build_response_header(request, FALSE);
 
            if (!headers)
            {
                LeaveCriticalSection( &request->headers_section );
                return ERROR_OUTOFMEMORY;
            }
 
            len = lstrlenW(headers) * sizeof(WCHAR);
            if (len > *lpdwBufferLength)
            {
                *lpdwBufferLength = len;
                heap_free(headers);
                LeaveCriticalSection( &request->headers_section );
                return ERROR_INSUFFICIENT_BUFFER;
            }
 
            if (lpBuffer)
            {
                DWORD i;
 
                TRACE("returning data: %s\n", debugstr_wn(headers, len / sizeof(WCHAR)));
 
                for (i = 0; i < len / sizeof(WCHAR); i++)
                {
                    if (headers[i] == '\n')
                        headers[i] = 0;
                }
                memcpy(lpBuffer, headers, len);
            }
            *lpdwBufferLength = len - sizeof(WCHAR);
 
            heap_free(headers);
            LeaveCriticalSection( &request->headers_section );
            return ERROR_SUCCESS;
        }
    case HTTP_QUERY_STATUS_TEXT:
        if (request->statusText)
        {
            DWORD len = lstrlenW(request->statusText);
            if (len + 1 > *lpdwBufferLength/sizeof(WCHAR))
            {
                *lpdwBufferLength = (len + 1) * sizeof(WCHAR);
                LeaveCriticalSection( &request->headers_section );
                return ERROR_INSUFFICIENT_BUFFER;
            }
            if (lpBuffer)
            {
                memcpy(lpBuffer, request->statusText, (len + 1) * sizeof(WCHAR));
                TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len));
            }
            *lpdwBufferLength = len * sizeof(WCHAR);
            LeaveCriticalSection( &request->headers_section );
            return ERROR_SUCCESS;
        }
        break;
    case HTTP_QUERY_VERSION:
        if (request->version)
        {
            DWORD len = lstrlenW(request->version);
            if (len + 1 > *lpdwBufferLength/sizeof(WCHAR))
            {
                *lpdwBufferLength = (len + 1) * sizeof(WCHAR);
                LeaveCriticalSection( &request->headers_section );
                return ERROR_INSUFFICIENT_BUFFER;
            }
            if (lpBuffer)
            {
                memcpy(lpBuffer, request->version, (len + 1) * sizeof(WCHAR));
                TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len));
            }
            *lpdwBufferLength = len * sizeof(WCHAR);
            LeaveCriticalSection( &request->headers_section );
            return ERROR_SUCCESS;
        }
        break;
    case HTTP_QUERY_CONTENT_ENCODING:
        index = HTTP_GetCustomHeaderIndex(request, header_lookup[request->read_gzip ? HTTP_QUERY_CONTENT_TYPE : level],
                requested_index,request_only);
        break;
    case HTTP_QUERY_STATUS_CODE: {
        DWORD res = ERROR_SUCCESS;
 
        if(request_only)
        {
            LeaveCriticalSection( &request->headers_section );
            return ERROR_HTTP_INVALID_QUERY_REQUEST;
        }
 
        if(requested_index)
            break;
 
        if(dwInfoLevel & HTTP_QUERY_FLAG_NUMBER) {
            if(*lpdwBufferLength >= sizeof(DWORD))
                *(DWORD*)lpBuffer = request->status_code;
            else
                res = ERROR_INSUFFICIENT_BUFFER;
            *lpdwBufferLength = sizeof(DWORD);
        }else {
            WCHAR buf[12];
            DWORD size;
 
            size = swprintf(buf, ARRAY_SIZE(buf), L"%u", request->status_code) * sizeof(WCHAR);
 
            if(size <= *lpdwBufferLength) {
                memcpy(lpBuffer, buf, size+sizeof(WCHAR));
            }else {
                size += sizeof(WCHAR);
                res = ERROR_INSUFFICIENT_BUFFER;
            }
 
            *lpdwBufferLength = size;
        }
        LeaveCriticalSection( &request->headers_section );
        return res;
    }
    default:
        assert (ARRAY_SIZE(header_lookup) == (HTTP_QUERY_UNLESS_MODIFIED_SINCE + 1));
 
        if (level < ARRAY_SIZE(header_lookup) && header_lookup[level])
            index = HTTP_GetCustomHeaderIndex(request, header_lookup[level],
                                              requested_index,request_only);
    }
 
    if (index >= 0)
        lphttpHdr = &request->custHeaders[index];
 
    /* Ensure header satisfies requested attributes */
    if (!lphttpHdr ||
        ((dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS) &&
         (~lphttpHdr->wFlags & HDR_ISREQUEST)))
    {
        LeaveCriticalSection( &request->headers_section );
        return ERROR_HTTP_HEADER_NOT_FOUND;
    }
 
    /* coalesce value to requested type */
    if (dwInfoLevel & HTTP_QUERY_FLAG_NUMBER && lpBuffer)
    {
        unsigned long value;
 
        if (*lpdwBufferLength != sizeof(DWORD))
        {
            LeaveCriticalSection( &request->headers_section );
            return ERROR_HTTP_INVALID_HEADER;
        }
 
        errno = 0;
        value = wcstoul( lphttpHdr->lpszValue, NULL, 10 );
        if (value > UINT_MAX || (value == ULONG_MAX && errno == ERANGE))
        {
            LeaveCriticalSection( &request->headers_section );
            return ERROR_HTTP_INVALID_HEADER;
        }
 
        *(DWORD *)lpBuffer = value;
        TRACE(" returning number: %u\n", *(DWORD *)lpBuffer);
    }
    else if (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME && lpBuffer)
    {
        time_t tmpTime;
        struct tm tmpTM;
        SYSTEMTIME *STHook;
 
        tmpTime = ConvertTimeString(lphttpHdr->lpszValue);
 
        tmpTM = *gmtime(&tmpTime);
        STHook = (SYSTEMTIME *)lpBuffer;
        STHook->wDay = tmpTM.tm_mday;
        STHook->wHour = tmpTM.tm_hour;
        STHook->wMilliseconds = 0;
        STHook->wMinute = tmpTM.tm_min;
        STHook->wDayOfWeek = tmpTM.tm_wday;
        STHook->wMonth = tmpTM.tm_mon + 1;
        STHook->wSecond = tmpTM.tm_sec;
        STHook->wYear = 1900+tmpTM.tm_year;
 
        TRACE(" returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
              STHook->wYear, STHook->wMonth, STHook->wDay, STHook->wDayOfWeek,
              STHook->wHour, STHook->wMinute, STHook->wSecond, STHook->wMilliseconds);
    }
    else if (lphttpHdr->lpszValue)
    {
        DWORD len = (lstrlenW(lphttpHdr->lpszValue) + 1) * sizeof(WCHAR);
 
        if (len > *lpdwBufferLength)
        {
            *lpdwBufferLength = len;
            LeaveCriticalSection( &request->headers_section );
            return ERROR_INSUFFICIENT_BUFFER;
        }
        if (lpBuffer)
        {
            memcpy(lpBuffer, lphttpHdr->lpszValue, len);
            TRACE("! returning string: %s\n", debugstr_w(lpBuffer));
        }
        *lpdwBufferLength = len - sizeof(WCHAR);
    }
    if (lpdwIndex) (*lpdwIndex)++;
 
    LeaveCriticalSection( &request->headers_section );
    return ERROR_SUCCESS;
}

Referenced by get_redirect_url(), HTTP_HttpSendRequestW(), HTTP_KeepAlive(), HttpQueryInfoW(), and set_content_length().

HTTP_HttpSendRequestW()

static DWORD HTTP_HttpSendRequestW ( http_request_t *  request, LPCWSTR  lpszHeaders, DWORD  dwHeaderLength, LPVOID  lpOptional, DWORD  dwOptionalLength, DWORD  dwContentLength, BOOL  bEndRequest  )

static

Definition at line 4910 of file http.c.

{
    BOOL redirected = FALSE, secure_proxy_connect = FALSE, loop_next;
    WCHAR *request_header = NULL;
    INT responseLen, cnt;
    DWORD res;
 
    TRACE("--> %p\n", request);
 
    assert(request->hdr.htype == WH_HHTTPREQ);
 
    /* if the verb is NULL default to GET */
    if (!request->verb)
        request->verb = heap_strdupW(L"GET");
 
    HTTP_ProcessHeader(request, L"Host", request->server->canon_host_port,
                       HTTP_ADDREQ_FLAG_ADD_IF_NEW | HTTP_ADDHDR_FLAG_REQ);
 
    if (dwContentLength || wcscmp(request->verb, L"GET"))
    {
        set_content_length_header(request, dwContentLength, HTTP_ADDREQ_FLAG_ADD_IF_NEW);
        request->bytesToWrite = dwContentLength;
    }
    if (request->session->appInfo->agent)
    {
        WCHAR *agent_header;
        int len;
 
        len = lstrlenW(request->session->appInfo->agent) + lstrlenW(L"User-Agent: %s\r\n");
        agent_header = heap_alloc(len * sizeof(WCHAR));
        swprintf(agent_header, len, L"User-Agent: %s\r\n", request->session->appInfo->agent);
 
        HTTP_HttpAddRequestHeadersW(request, agent_header, lstrlenW(agent_header), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
        heap_free(agent_header);
    }
    if (request->hdr.dwFlags & INTERNET_FLAG_PRAGMA_NOCACHE)
    {
        HTTP_HttpAddRequestHeadersW(request, L"Pragma: no-cache\r\n",
                                    lstrlenW(L"Pragma: no-cache\r\n"), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
    }
    if ((request->hdr.dwFlags & INTERNET_FLAG_NO_CACHE_WRITE) && wcscmp(request->verb, L"GET"))
    {
        HTTP_HttpAddRequestHeadersW(request, L"Cache-Control: no-cache\r\n",
                                    lstrlenW(L"Cache-Control: no-cache\r\n"), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
    }
 
    /* add the headers the caller supplied */
    if( lpszHeaders && dwHeaderLength )
        HTTP_HttpAddRequestHeadersW(request, lpszHeaders, dwHeaderLength, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REPLACE);
 
    do
    {
        DWORD len, data_len = dwOptionalLength;
        BOOL reusing_connection;
        char *ascii_req;
 
        loop_next = FALSE;
 
        if(redirected) {
            request->contentLength = ~0;
            request->bytesToWrite = 0;
        }
 
        if (TRACE_ON(wininet))
        {
            HTTPHEADERW *host;
 
            EnterCriticalSection( &request->headers_section );
            host = HTTP_GetHeader(request, L"Host");
            TRACE("Going to url %s %s\n", debugstr_w(host->lpszValue), debugstr_w(request->path));
            LeaveCriticalSection( &request->headers_section );
        }
 
        HTTP_FixURL(request);
        if (request->hdr.dwFlags & INTERNET_FLAG_KEEP_CONNECTION)
        {
            HTTP_ProcessHeader(request, L"Connection", L"Keep-Alive",
                               HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE | HTTP_ADDHDR_FLAG_ADD);
        }
        HTTP_InsertAuthorization(request, request->authInfo, L"Authorization");
        HTTP_InsertAuthorization(request, request->proxyAuthInfo, L"Proxy-Authorization");
 
        if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_COOKIES))
            HTTP_InsertCookies(request);
 
        res = open_http_connection(request, &reusing_connection);
        if (res != ERROR_SUCCESS)
            break;
 
        if (!reusing_connection && (request->hdr.dwFlags & INTERNET_FLAG_SECURE))
        {
            if (request->proxy) secure_proxy_connect = TRUE;
            else
            {
                res =