winhttp_private.h File Reference

#include <wine/heap.h>
#include "ole2.h"
#include "sspi.h"
#include "wincrypt.h"
#include "wine/list.h"

Include dependency graph for winhttp_private.h:

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

Go to the source code of this file.

Classes
struct	object_vtbl
struct	object_header
struct	hostdata
struct	session
struct	connect
struct	netconn
struct	header
struct	authinfo
class	queue< _Tp, _Sequence >
struct	request
struct	socket
struct	task_header
struct	send_callback
struct	send_request
struct	receive_response
struct	query_data
struct	read_data
struct	write_data
struct	socket_send
struct	socket_receive
struct	socket_shutdown

Macros
#define	WINHTTP_HANDLE_TYPE_SOCKET   4
#define	MIN_WEBSOCKET_SEND_BUFFER_SIZE   16

Typedefs
typedef void(*	TASK_CALLBACK) (void *ctx, BOOL abort)

Enumerations
enum	auth_target { TARGET_INVALID = -1 , TARGET_SERVER , TARGET_PROXY , TARGET_MAX }
enum	auth_scheme {   SCHEME_INVALID = -1 , SCHEME_BASIC , SCHEME_NTLM , SCHEME_PASSPORT ,   SCHEME_DIGEST , SCHEME_NEGOTIATE , SCHEME_MAX }
enum	request_flags { REQUEST_FLAG_WEBSOCKET_UPGRADE = 0x01 }
enum	request_response_state {   REQUEST_RESPONSE_STATE_NONE , REQUEST_RESPONSE_STATE_SENDING_REQUEST , REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED , REQUEST_RESPONSE_STATE_REQUEST_SENT ,   REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED_REQUEST_SENT , REQUEST_RESPONSE_STATE_REPLY_RECEIVED , REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED_REPLY_RECEIVED , REQUEST_RESPONSE_RECURSIVE_REQUEST ,   REQUEST_RESPONSE_STATE_RESPONSE_RECEIVED }
enum	socket_state { SOCKET_STATE_OPEN = 0 , SOCKET_STATE_SHUTDOWN = 1 , SOCKET_STATE_CLOSED = 2 }
enum	socket_opcode {   SOCKET_OPCODE_CONTINUE = 0x00 , SOCKET_OPCODE_TEXT = 0x01 , SOCKET_OPCODE_BINARY = 0x02 , SOCKET_OPCODE_RESERVED3 = 0x03 ,   SOCKET_OPCODE_RESERVED4 = 0x04 , SOCKET_OPCODE_RESERVED5 = 0x05 , SOCKET_OPCODE_RESERVED6 = 0x06 , SOCKET_OPCODE_RESERVED7 = 0x07 ,   SOCKET_OPCODE_CLOSE = 0x08 , SOCKET_OPCODE_PING = 0x09 , SOCKET_OPCODE_PONG = 0x0a , SOCKET_OPCODE_INVALID = 0xff }
enum	fragment_type { SOCKET_FRAGMENT_NONE , SOCKET_FRAGMENT_BINARY , SOCKET_FRAGMENT_UTF8 }

Functions
struct object_header *	addref_object (struct object_header *)
struct object_header *	grab_object (HINTERNET)
void	release_object (struct object_header *)
HINTERNET	alloc_handle (struct object_header *)
BOOL	free_handle (HINTERNET)
void	send_callback (struct object_header *, DWORD, LPVOID, DWORD)
void	close_connection (struct request *)
void	init_queue (struct queue *queue)
void	stop_queue (struct queue *)
void	netconn_addref (struct netconn *)
void	netconn_release (struct netconn *)
DWORD	netconn_create (struct hostdata *, const struct sockaddr_storage *, int, struct netconn **)
void	netconn_unload (void)
ULONG	netconn_query_data_available (struct netconn *)
DWORD	netconn_recv (struct netconn *, void *, size_t, int, int *)
DWORD	netconn_resolve (WCHAR *, INTERNET_PORT, struct sockaddr_storage *, int)
DWORD	netconn_secure_connect (struct netconn *, WCHAR *, DWORD, CredHandle *, BOOL)
DWORD	netconn_send (struct netconn *, const void *, size_t, int *, WSAOVERLAPPED *)
BOOL	netconn_wait_overlapped_result (struct netconn *conn, WSAOVERLAPPED *ovr, DWORD *len)
void	netconn_cancel_io (struct netconn *conn)
DWORD	netconn_set_timeout (struct netconn *, BOOL, int)
BOOL	netconn_is_alive (struct netconn *)
const void *	netconn_get_certificate (struct netconn *)
int	netconn_get_cipher_strength (struct netconn *)
BOOL	set_cookies (struct request *, const WCHAR *)
DWORD	add_cookie_headers (struct request *)
DWORD	add_request_headers (struct request *, const WCHAR *, DWORD, DWORD)
void	destroy_cookies (struct session *)
BOOL	set_server_for_hostname (struct connect *, const WCHAR *, INTERNET_PORT)
void	destroy_authinfo (struct authinfo *)
void	release_host (struct hostdata *)
DWORD	process_header (struct request *, const WCHAR *, const WCHAR *, DWORD, BOOL)
HRESULT	WinHttpRequest_create (void **)
void	release_typelib (void)
static WCHAR *	strdupAW (const char *src)
static char *	strdupWA (const WCHAR *src)

Variables
HINSTANCE	winhttp_instance

Macro Definition Documentation

MIN_WEBSOCKET_SEND_BUFFER_SIZE

#define MIN_WEBSOCKET_SEND_BUFFER_SIZE   16

Definition at line 472 of file winhttp_private.h.

WINHTTP_HANDLE_TYPE_SOCKET

#define WINHTTP_HANDLE_TYPE_SOCKET   4

Definition at line 35 of file winhttp_private.h.

Typedef Documentation

TASK_CALLBACK

typedef void(* TASK_CALLBACK) (void *ctx, BOOL abort)

Definition at line 316 of file winhttp_private.h.

Enumeration Type Documentation

auth_scheme

enum auth_scheme

Enumerator
SCHEME_INVALID
SCHEME_BASIC
SCHEME_NTLM
SCHEME_PASSPORT
SCHEME_DIGEST
SCHEME_NEGOTIATE
SCHEME_MAX

Definition at line 148 of file winhttp_private.h.

{
    SCHEME_INVALID = -1,
    SCHEME_BASIC,
    SCHEME_NTLM,
    SCHEME_PASSPORT,
    SCHEME_DIGEST,
    SCHEME_NEGOTIATE,
    SCHEME_MAX
};

auth_target

enum auth_target

Enumerator
TARGET_INVALID
TARGET_SERVER
TARGET_PROXY
TARGET_MAX

Definition at line 140 of file winhttp_private.h.

{
    TARGET_INVALID = -1,
    TARGET_SERVER,
    TARGET_PROXY,
    TARGET_MAX
};

fragment_type

enum fragment_type

Enumerator
SOCKET_FRAGMENT_NONE
SOCKET_FRAGMENT_BINARY
SOCKET_FRAGMENT_UTF8

Definition at line 277 of file winhttp_private.h.

{
    SOCKET_FRAGMENT_NONE,
    SOCKET_FRAGMENT_BINARY,
    SOCKET_FRAGMENT_UTF8,
};

request_flags

enum request_flags

Enumerator
REQUEST_FLAG_WEBSOCKET_UPGRADE

Definition at line 179 of file winhttp_private.h.

{
    REQUEST_FLAG_WEBSOCKET_UPGRADE = 0x01,
};

request_response_state

enum request_response_state

Enumerator
REQUEST_RESPONSE_STATE_NONE
REQUEST_RESPONSE_STATE_SENDING_REQUEST
REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED
REQUEST_RESPONSE_STATE_REQUEST_SENT
REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED_REQUEST_SENT
REQUEST_RESPONSE_STATE_REPLY_RECEIVED
REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED_REPLY_RECEIVED
REQUEST_RESPONSE_RECURSIVE_REQUEST
REQUEST_RESPONSE_STATE_RESPONSE_RECEIVED

Definition at line 184 of file winhttp_private.h.

{
    REQUEST_RESPONSE_STATE_NONE,
    REQUEST_RESPONSE_STATE_SENDING_REQUEST,
    REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED,
    REQUEST_RESPONSE_STATE_REQUEST_SENT,
    REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED_REQUEST_SENT,
    REQUEST_RESPONSE_STATE_REPLY_RECEIVED,
    REQUEST_RESPONSE_STATE_READ_RESPONSE_QUEUED_REPLY_RECEIVED,
    REQUEST_RESPONSE_RECURSIVE_REQUEST,
    REQUEST_RESPONSE_STATE_RESPONSE_RECEIVED,
};

socket_opcode

enum socket_opcode

Enumerator
SOCKET_OPCODE_CONTINUE
SOCKET_OPCODE_TEXT
SOCKET_OPCODE_BINARY
SOCKET_OPCODE_RESERVED3
SOCKET_OPCODE_RESERVED4
SOCKET_OPCODE_RESERVED5
SOCKET_OPCODE_RESERVED6
SOCKET_OPCODE_RESERVED7
SOCKET_OPCODE_CLOSE
SOCKET_OPCODE_PING
SOCKET_OPCODE_PONG
SOCKET_OPCODE_INVALID

Definition at line 261 of file winhttp_private.h.

{
    SOCKET_OPCODE_CONTINUE  = 0x00,
    SOCKET_OPCODE_TEXT      = 0x01,
    SOCKET_OPCODE_BINARY    = 0x02,
    SOCKET_OPCODE_RESERVED3 = 0x03,
    SOCKET_OPCODE_RESERVED4 = 0x04,
    SOCKET_OPCODE_RESERVED5 = 0x05,
    SOCKET_OPCODE_RESERVED6 = 0x06,
    SOCKET_OPCODE_RESERVED7 = 0x07,
    SOCKET_OPCODE_CLOSE     = 0x08,
    SOCKET_OPCODE_PING      = 0x09,
    SOCKET_OPCODE_PONG      = 0x0a,
    SOCKET_OPCODE_INVALID   = 0xff,
};

socket_state

enum socket_state

Enumerator
SOCKET_STATE_OPEN
SOCKET_STATE_SHUTDOWN
SOCKET_STATE_CLOSED

Definition at line 253 of file winhttp_private.h.

{
    SOCKET_STATE_OPEN     = 0,
    SOCKET_STATE_SHUTDOWN = 1,
    SOCKET_STATE_CLOSED   = 2,
};

Function Documentation

add_cookie_headers()

DWORD add_cookie_headers

(

struct request *

request

)

Definition at line 322 of file cookie.c.

{
    struct list *domain_cursor;
    struct session *session = request->connect->session;
    DWORD ret = ERROR_SUCCESS;
 
    EnterCriticalSection( &session->cs );
 
    LIST_FOR_EACH( domain_cursor, &session->cookie_cache )
    {
        struct domain *domain = LIST_ENTRY( domain_cursor, struct domain, entry );
        if (domain_match( request->connect->servername, domain, TRUE ))
        {
            struct list *cookie_cursor;
            TRACE("found domain %s\n", debugstr_w(domain->name));
 
            LIST_FOR_EACH( cookie_cursor, &domain->cookies )
            {
                struct cookie *cookie = LIST_ENTRY( cookie_cursor, struct cookie, entry );
 
                TRACE("comparing path %s with %s\n", debugstr_w(request->path), debugstr_w(cookie->path));
 
                if (wcsstr( request->path, cookie->path ) == request->path)
                {
                    static const WCHAR cookieW[] = {'C','o','o','k','i','e',':',' '};
                    int len, len_cookie = ARRAY_SIZE( cookieW ), len_name = lstrlenW( cookie->name );
                    WCHAR *header;
 
                    len = len_cookie + len_name;
                    if (cookie->value) len += lstrlenW( cookie->value ) + 1;
                    if (!(header = malloc( (len + 1) * sizeof(WCHAR) )))
                    {
                        LeaveCriticalSection( &session->cs );
                        return ERROR_OUTOFMEMORY;
                    }
 
                    memcpy( header, cookieW, len_cookie * sizeof(WCHAR) );
                    lstrcpyW( header + len_cookie, cookie->name );
                    if (cookie->value)
                    {
                        header[len_cookie + len_name] = '=';
                        lstrcpyW( header + len_cookie + len_name + 1, cookie->value );
                    }
 
                    TRACE("%s\n", debugstr_w(header));
                    ret = add_request_headers( request, header, len,
                                               WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
                    free( header );
                }
            }
        }
    }
 
    LeaveCriticalSection( &session->cs );
    return ret;
}

Referenced by send_request().

add_request_headers()

DWORD add_request_headers	(	struct request *	request,
		const WCHAR *	headers,
		DWORD	len,
		DWORD	flags
	)

Definition at line 485 of file request.c.

{
    DWORD ret = ERROR_WINHTTP_INVALID_HEADER;
    struct header *header;
    const WCHAR *p, *q;
 
    if (len == ~0u) len = lstrlenW( headers );
    if (!len) return ERROR_SUCCESS;
 
    p = headers;
    do
    {
        const WCHAR *end;
 
        if (p >= headers + len) break;
 
        for (q = p; q < headers + len && *q != '\r' && *q != '\n'; ++q)
            ;
        end = q;
        while (*q == '\r' || *q == '\n')
            ++q;
 
        if ((header = parse_header( p, end - p, FALSE )))
        {
            ret = process_header( request, header->field, header->value, flags, TRUE );
            free_header( header );
        }
        p = q;
    } while (!ret);
 
    return ret;
}

Referenced by add_cookie_headers(), send_request(), and WinHttpAddRequestHeaders().

addref_object()

struct object_header * addref_object

(

struct object_header *

hdr

)

Definition at line 48 of file handle.c.

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

Referenced by alloc_handle(), grab_object(), queue_task(), WinHttpConnect(), and WinHttpOpenRequest().

alloc_handle()

HINTERNET alloc_handle

(

struct object_header *

hdr

)

Definition at line 86 of file handle.c.

{
    struct object_header **p;
    ULONG_PTR handle, num;
 
    hdr->handle = NULL;
 
    EnterCriticalSection( &handle_cs );
    if (!max_handles)
    {
        num = HANDLE_CHUNK_SIZE;
        if (!(p = calloc( 1, sizeof(*p) * num ))) goto end;
        handles = p;
        max_handles = num;
    }
    if (max_handles == next_handle)
    {
        size_t new_size, old_size = max_handles * sizeof(*handles);
        num = max_handles * 2;
        new_size = num * sizeof(*handles);
        if (!(p = realloc( handles, new_size ))) goto end;
        memset( (char *)p + old_size, 0, new_size - old_size );
        handles = p;
        max_handles = num;
    }
    handle = next_handle;
    if (handles[handle]) ERR("handle isn't free but should be\n");
 
    handles[handle] = addref_object( hdr );
    hdr->handle = (HINTERNET)(handle + 1);
    while ((next_handle < max_handles) && handles[next_handle]) next_handle++;
 
end:
    LeaveCriticalSection( &handle_cs );
    return hdr->handle;
}

close_connection()

void close_connection

(

struct request *

request

)

Definition at line 1740 of file request.c.

{
    if (!request->netconn) return;
 
    netconn_release( request->netconn );
    request->netconn = NULL;
}

destroy_authinfo()

void destroy_authinfo

(

struct authinfo *

authinfo

)

Definition at line 1097 of file request.c.

{
    if (!authinfo) return;
 
    if (SecIsValidHandle( &authinfo->ctx ))
        DeleteSecurityContext( &authinfo->ctx );
    if (SecIsValidHandle( &authinfo->cred ))
        FreeCredentialsHandle( &authinfo->cred );
 
    free( authinfo->data );
    free( authinfo );
}

Referenced by do_authorization().

destroy_cookies()

void destroy_cookies

(

struct session *

session

)

Definition at line 120 of file cookie.c.

{
    struct list *item, *next;
    struct domain *domain;
 
    LIST_FOR_EACH_SAFE( item, next, &session->cookie_cache )
    {
        domain = LIST_ENTRY( item, struct domain, entry );
        delete_domain( domain );
    }
}

Referenced by session_destroy().

free_handle()

BOOL free_handle

(

HINTERNET

hinternet

)

Definition at line 123 of file handle.c.

{
    BOOL ret = FALSE;
    ULONG_PTR handle = (ULONG_PTR)hinternet;
    struct object_header *hdr = NULL;
 
    EnterCriticalSection( &handle_cs );
 
    if ((handle > 0) && (handle <= max_handles))
    {
        handle--;
        if (handles[handle])
        {
            hdr = handles[handle];
            TRACE( "destroying handle %Ix for object %p\n", handle + 1, hdr );
            handles[handle] = NULL;
            ret = TRUE;
        }
    }
 
    LeaveCriticalSection( &handle_cs );
 
    if (hdr)
    {
        if (hdr->vtbl->handle_closing)
            hdr->vtbl->handle_closing( hdr );
        release_object( hdr );
    }
 
    EnterCriticalSection( &handle_cs );
    if (next_handle > handle && !handles[handle]) next_handle = handle;
    LeaveCriticalSection( &handle_cs );
 
    return ret;
}

Referenced by pqInsert(), and WinHttpCloseHandle().

grab_object()

struct object_header * grab_object

(

HINTERNET

hinternet

)

Definition at line 55 of file handle.c.

{
    struct object_header *hdr = NULL;
    ULONG_PTR handle = (ULONG_PTR)hinternet;
 
    EnterCriticalSection( &handle_cs );
 
    if ((handle > 0) && (handle <= max_handles) && handles[handle - 1])
        hdr = addref_object( handles[handle - 1] );
 
    LeaveCriticalSection( &handle_cs );
 
    TRACE( "handle %Ix -> %p\n", handle, hdr );
    return hdr;
}

Referenced by WinHttpAddRequestHeaders(), WinHttpCloseHandle(), WinHttpConnect(), WinHttpGetProxyForUrl(), WinHttpOpenRequest(), WinHttpQueryAuthSchemes(), WinHttpQueryDataAvailable(), WinHttpQueryHeaders(), WinHttpQueryOption(), WinHttpReadData(), WinHttpReceiveResponse(), WinHttpSendRequest(), WinHttpSetCredentials(), WinHttpSetOption(), WinHttpSetStatusCallback(), WinHttpSetTimeouts(), WinHttpWebSocketClose(), WinHttpWebSocketCompleteUpgrade(), WinHttpWebSocketQueryCloseStatus(), WinHttpWebSocketReceive(), WinHttpWebSocketSend(), WinHttpWebSocketShutdown(), and WinHttpWriteData().

init_queue()

void init_queue

(

struct queue *

queue

)

Definition at line 137 of file request.c.

{
    InitializeSRWLock( &queue->lock );
    list_init( &queue->queued_tasks );
    queue->callback_running = FALSE;
}

Referenced by WinHttpOpenRequest(), and WinHttpWebSocketCompleteUpgrade().

netconn_addref()

void netconn_addref

(

struct netconn *

conn

)

Definition at line 290 of file net.c.

{
    InterlockedIncrement( &conn->refs );
}

Referenced by WinHttpWebSocketCompleteUpgrade().

netconn_cancel_io()

void netconn_cancel_io

(

struct netconn *

conn

)

Definition at line 674 of file net.c.

{
    SOCKET socket = InterlockedExchange( (LONG *)&conn->socket, -1 );
 
    closesocket( socket );
}

Referenced by socket_handle_closing().

netconn_create()

DWORD netconn_create	(	struct hostdata *	host,
		const struct sockaddr_storage *	sockaddr,
		int	timeout,
		struct netconn **	ret_conn
	)

Definition at line 212 of file net.c.

{
    struct netconn *conn;
    unsigned int addr_len;
    DWORD ret;
 
#ifndef __REACTOS__
    winsock_init();
#endif
 
    if (!(conn = calloc( 1, sizeof(*conn) ))) return ERROR_OUTOFMEMORY;
    conn->refs = 1;
    conn->host = host;
    conn->sockaddr = *sockaddr;
    if ((conn->socket = WSASocketW( sockaddr->ss_family, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED )) == -1)
    {
        ret = WSAGetLastError();
        WARN( "unable to create socket (%lu)\n", ret );
        free( conn );
        return ret;
    }
    if (!SetFileCompletionNotificationModes( (HANDLE)(UINT_PTR)conn->socket, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS ))
        ERR( "SetFileCompletionNotificationModes failed.\n" );
 
    switch (conn->sockaddr.ss_family)
    {
    case AF_INET:
        addr_len = sizeof(struct sockaddr_in);
        break;
    case AF_INET6:
        addr_len = sizeof(struct sockaddr_in6);
        break;
    default:
        ERR( "unhandled family %u\n", conn->sockaddr.ss_family );
        free( conn );
        return ERROR_INVALID_PARAMETER;
    }
 
    if (timeout > 0) set_blocking( conn, FALSE );
 
    if (!connect( conn->socket, (const struct sockaddr *)&conn->sockaddr, addr_len )) ret = ERROR_SUCCESS;
    else
    {
        ret = WSAGetLastError();
        if (ret == WSAEWOULDBLOCK || ret == WSAEINPROGRESS)
        {
            TIMEVAL timeval = { timeout / 1000, (timeout % 1000) * 1000 };
            FD_SET set_read, set_error;
            int res;
 
            FD_ZERO( &set_read );
            FD_SET( conn->socket, &set_read );
            FD_ZERO( &set_error );
            FD_SET( conn->socket, &set_error );
            if ((res = select( conn->socket + 1, NULL, &set_read, &set_error, &timeval )) > 0)
            {
                if (FD_ISSET(conn->socket, &set_read)) ret = ERROR_SUCCESS;
                else                                   assert( FD_ISSET(conn->socket, &set_error) );
            }
            else if (!res) ret = ERROR_WINHTTP_TIMEOUT;
        }
    }
 
    if (timeout > 0) set_blocking( conn, TRUE );
 
    if (ret)
    {
        WARN( "unable to connect to host (%lu)\n", ret );
        closesocket( conn->socket );
        free( conn );
        return ret == ERROR_WINHTTP_TIMEOUT ? ERROR_WINHTTP_TIMEOUT : ERROR_WINHTTP_CANNOT_CONNECT;
    }
 
    *ret_conn = conn;
    return ERROR_SUCCESS;
}

Referenced by open_connection().

netconn_get_certificate()

const void * netconn_get_certificate

(

struct netconn *

conn

)

Definition at line 850 of file net.c.

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

Referenced by open_connection().

netconn_get_cipher_strength()

int netconn_get_cipher_strength

(

struct netconn *

conn

)

Definition at line 860 of file net.c.

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

Referenced by request_query_option().

netconn_is_alive()

BOOL netconn_is_alive

(

struct netconn *

netconn

)

Definition at line 698 of file net.c.

{
    SIZE_T size;
    int len;
    char b;
    DWORD err;
    BOOL eof;
 
    set_blocking( netconn, FALSE );
    if (netconn->secure)
    {
        while (!netconn->peek_msg && !(err = read_ssl_chunk( netconn, NULL, 0, &size, &eof )) && !eof)
            ;
 
        TRACE( "checking secure connection, err %lu\n", err );
 
        if (netconn->peek_msg || err == WSAEWOULDBLOCK)
        {
            set_blocking( netconn, TRUE );
            return TRUE;
        }
        if (err != SEC_E_OK && err != SEC_E_INCOMPLETE_MESSAGE)
        {
            set_blocking( netconn, TRUE );
            return FALSE;
        }
    }
    len = sock_recv( netconn->socket, &b, 1, MSG_PEEK );
    err = WSAGetLastError();
    set_blocking( netconn, TRUE );
 
    return len == 1 || (len == -1 && err == WSAEWOULDBLOCK);
}

Referenced by open_connection().

netconn_query_data_available()

ULONG netconn_query_data_available

(

struct netconn *

conn

)

Definition at line 681 of file net.c.

{
    return conn->secure ? conn->peek_len : 0;
}

Referenced by query_data_ready().

netconn_recv()

DWORD netconn_recv	(	struct netconn *	conn,
		void *	buf,
		size_t	len,
		int	flags,
		int *	recvd
	)

Definition at line 618 of file net.c.

{
    *recvd = 0;
    if (!len) return ERROR_SUCCESS;
 
    if (conn->secure)
    {
        SIZE_T size;
        DWORD res;
        BOOL eof;
 
        if (conn->peek_msg)
        {
            *recvd = min( len, conn->peek_len );
            memcpy( buf, conn->peek_msg, *recvd );
            conn->peek_len -= *recvd;
            conn->peek_msg += *recvd;
 
            if (conn->peek_len == 0)
            {
                free( conn->peek_msg_mem );
                conn->peek_msg_mem = NULL;
                conn->peek_msg = NULL;
            }
            /* check if we have enough data from the peek buffer */
            if (!(flags & MSG_WAITALL) || *recvd == len) return ERROR_SUCCESS;
        }
        size = *recvd;
 
        do
        {
            SIZE_T cread = 0;
            if ((res = read_ssl_chunk( conn, (BYTE *)buf + size, len - size, &cread, &eof )))
            {
                WARN( "read_ssl_chunk failed: %lu\n", res );
                if (!size) return res;
                break;
            }
            if (eof)
            {
                TRACE("EOF\n");
                break;
            }
            size += cread;
 
        } while (!size || ((flags & MSG_WAITALL) && size < len));
 
        TRACE( "received %Iu bytes\n", size );
        *recvd = size;
        return ERROR_SUCCESS;
    }
 
    if ((*recvd = sock_recv( conn->socket, buf, len, flags )) < 0) return WSAGetLastError();
    return ERROR_SUCCESS;
}

Referenced by read_more_data(), and receive_bytes().

netconn_release()

void netconn_release

(

struct netconn *

conn

)

Definition at line 295 of file net.c.

{
    if (InterlockedDecrement( &conn->refs )) return;
    TRACE( "Closing connection %p.\n", conn );
    if (conn->secure)
    {
        free( conn->peek_msg_mem );
        free(conn->ssl_read_buf);
        free(conn->ssl_write_buf);
        free(conn->extra_buf);
        DeleteSecurityContext(&conn->ssl_ctx);
    }
    if (conn->socket != -1)
        closesocket( conn->socket );
    release_host( conn->host );
    if (conn->port)
        CloseHandle( conn->port );
    free(conn);
}

Referenced by close_connection(), connection_collector(), finished_reading(), handle_redirect(), open_connection(), and socket_destroy().

netconn_resolve()

DWORD netconn_resolve	(	WCHAR *	hostname,
		INTERNET_PORT	port,
		struct sockaddr_storage *	addr,
		int	timeout
	)

Definition at line 819 of file net.c.

{
    DWORD ret;
 
    if (!timeout) ret = resolve_hostname( hostname, port, addr );
    else
    {
        struct async_resolve *async;
 
        if (!(async = create_async_resolve( hostname, port )))
            return ERROR_OUTOFMEMORY;
 
        InterlockedIncrement( &async->ref );
        if (!TrySubmitThreadpoolCallback( resolve_proc, async, NULL ))
        {
            InterlockedDecrement( &async->ref );
            async_resolve_release( async );
            return GetLastError();
        }
        if (WaitForSingleObject( async->done, timeout ) != WAIT_OBJECT_0) ret = ERROR_WINHTTP_TIMEOUT;
        else
        {
            *addr = async->addr;
            ret = async->result;
        }
        async_resolve_release( async );
    }
 
    return ret;
}

Referenced by open_connection().

netconn_secure_connect()

DWORD netconn_secure_connect	(	struct netconn *	conn,
		WCHAR *	hostname,
		DWORD	security_flags,
		CredHandle *	cred_handle,
		BOOL	check_revocation
	)

Definition at line 315 of file net.c.

{
    SecBuffer out_buf = {0, SECBUFFER_TOKEN, NULL}, in_bufs[2] = {{0, SECBUFFER_TOKEN}, {0, SECBUFFER_EMPTY}};
    SecBufferDesc out_desc = {SECBUFFER_VERSION, 1, &out_buf}, in_desc = {SECBUFFER_VERSION, 2, in_bufs};
    BYTE *read_buf;
    SIZE_T read_buf_size = 2048;
    ULONG attrs = 0;
    CtxtHandle ctx;
    SSIZE_T size;
    const CERT_CONTEXT *cert;
    SECURITY_STATUS status;
    DWORD res = ERROR_SUCCESS;
 
    const DWORD isc_req_flags = ISC_REQ_ALLOCATE_MEMORY|ISC_REQ_USE_SESSION_KEY|ISC_REQ_CONFIDENTIALITY
        |ISC_REQ_SEQUENCE_DETECT|ISC_REQ_REPLAY_DETECT|ISC_REQ_MANUAL_CRED_VALIDATION;
 
    if (!(read_buf = malloc( read_buf_size ))) return ERROR_OUTOFMEMORY;
 
    memset( &ctx, 0, sizeof(ctx) );
    status = InitializeSecurityContextW(cred_handle, NULL, hostname, isc_req_flags, 0, 0, NULL, 0,
            &ctx, &out_desc, &attrs, NULL);
 
    assert(status != SEC_E_OK);
 
    while(status == SEC_I_CONTINUE_NEEDED || status == SEC_E_INCOMPLETE_MESSAGE) {
        if(out_buf.cbBuffer) {
            assert(status == SEC_I_CONTINUE_NEEDED);
 
            TRACE( "sending %lu bytes\n", out_buf.cbBuffer );
 
            size = sock_send(conn->socket, out_buf.pvBuffer, out_buf.cbBuffer, NULL);
            if(size != out_buf.cbBuffer) {
                ERR("send failed\n");
                res = ERROR_WINHTTP_SECURE_CHANNEL_ERROR;
                break;
            }
 
            FreeContextBuffer(out_buf.pvBuffer);
            out_buf.pvBuffer = NULL;
            out_buf.cbBuffer = 0;
        }
 
        if(status == SEC_I_CONTINUE_NEEDED) {
            assert(in_bufs[1].cbBuffer < read_buf_size);
 
            memmove(read_buf, (BYTE*)in_bufs[0].pvBuffer+in_bufs[0].cbBuffer-in_bufs[1].cbBuffer, in_bufs[1].cbBuffer);
            in_bufs[0].cbBuffer = in_bufs[1].cbBuffer;
        }
 
        assert(in_bufs[0].BufferType == SECBUFFER_TOKEN);
        in_bufs[1].BufferType = SECBUFFER_EMPTY;
        in_bufs[1].cbBuffer = 0;
        in_bufs[1].pvBuffer = NULL;
 
        if(in_bufs[0].cbBuffer + 1024 > read_buf_size) {
            BYTE *new_read_buf;
 
            new_read_buf = realloc(read_buf, read_buf_size + 1024);
            if(!new_read_buf) {
                status = E_OUTOFMEMORY;
                break;
            }
 
            in_bufs[0].pvBuffer = read_buf = new_read_buf;
            read_buf_size += 1024;
        }
 
        size = sock_recv(conn->socket, read_buf+in_bufs[0].cbBuffer, read_buf_size-in_bufs[0].cbBuffer, 0);
        if(size < 1) {
            status = ERROR_WINHTTP_SECURE_CHANNEL_ERROR;
            break;
        }
 
        TRACE( "recv %Iu bytes\n", size );
 
        in_bufs[0].cbBuffer += size;
        in_bufs[0].pvBuffer = read_buf;
        status = InitializeSecurityContextW(cred_handle, &ctx, hostname,  isc_req_flags, 0, 0, &in_desc,
                0, NULL, &out_desc, &attrs, NULL);
        TRACE( "InitializeSecurityContext ret %#lx\n", status );
 
        if(status == SEC_E_OK) {
            if(in_bufs[1].BufferType == SECBUFFER_EXTRA)
                FIXME("SECBUFFER_EXTRA not supported\n");
 
            status = QueryContextAttributesW(&ctx, SECPKG_ATTR_STREAM_SIZES, &conn->ssl_sizes);
            if(status != SEC_E_OK) {
                WARN("Could not get sizes\n");
                break;
            }
 
            status = QueryContextAttributesW(&ctx, SECPKG_ATTR_REMOTE_CERT_CONTEXT, (void*)&cert);
            if(status == SEC_E_OK) {
                res = netconn_verify_cert(cert, hostname, security_flags, check_revocation);
                CertFreeCertificateContext(cert);
                if(res != ERROR_SUCCESS) {
                    WARN( "cert verify failed: %lu\n", res );
                    break;
                }
            }else {
                WARN("Could not get cert\n");
                break;
            }
 
            conn->ssl_read_buf = malloc(conn->ssl_sizes.cbHeader + conn->ssl_sizes.cbMaximumMessage + conn->ssl_sizes.cbTrailer);
            if(!conn->ssl_read_buf) {
                res = ERROR_OUTOFMEMORY;
                break;
            }
            conn->ssl_write_buf = malloc(conn->ssl_sizes.cbHeader + conn->ssl_sizes.cbMaximumMessage + conn->ssl_sizes.cbTrailer);
            if(!conn->ssl_write_buf) {
                res = ERROR_OUTOFMEMORY;
                break;
            }
        }
    }
 
    free(read_buf);
 
    if(status != SEC_E_OK || res != ERROR_SUCCESS) {
        WARN( "Failed to initialize security context: %#lx\n", status );
        free(conn->ssl_read_buf);
        conn->ssl_read_buf = NULL;
        free(conn->ssl_write_buf);
        conn->ssl_write_buf = NULL;
        DeleteSecurityContext(&ctx);
        return ERROR_WINHTTP_SECURE_CHANNEL_ERROR;
    }
 
 
    TRACE("established SSL connection\n");
    conn->secure = TRUE;
    conn->ssl_ctx = ctx;
    return ERROR_SUCCESS;
}

Referenced by open_connection().

netconn_send()

DWORD netconn_send	(	struct netconn *	conn,
		const void *	msg,
		size_t	len,
		int *	sent,
		WSAOVERLAPPED *	ovr
	)

Definition at line 479 of file net.c.

{
    DWORD err;
 
    if (ovr && !conn->port)
    {
        if (!(conn->port = CreateIoCompletionPort( (HANDLE)(SOCKET)conn->socket, NULL, (ULONG_PTR)conn->socket, 0 )))
            ERR( "Failed to create port.\n" );
    }
 
    if (conn->secure)
    {
        const BYTE *ptr = msg;
        size_t chunk_size;
        DWORD res;
 
        *sent = 0;
        while (len)
        {
            chunk_size = min( len, conn->ssl_sizes.cbMaximumMessage );
            if ((res = send_ssl_chunk( conn, ptr, chunk_size, ovr )))
            {
                if (res == WSA_IO_PENDING) *sent += chunk_size;
                return res;
            }
            *sent += chunk_size;
            ptr += chunk_size;
            len -= chunk_size;
        }
 
        return ERROR_SUCCESS;
    }
 
    if ((*sent = sock_send( conn->socket, msg, len, ovr )) < 0)
    {
        err = WSAGetLastError();
        *sent = (err == WSA_IO_PENDING) ? len : 0;
        return err;
    }
    return ERROR_SUCCESS;
}

Referenced by secure_proxy_connect(), send_bytes(), send_request(), and write_data().

netconn_set_timeout()

DWORD netconn_set_timeout	(	struct netconn *	netconn,
		BOOL	send,
		int	value
	)

Definition at line 686 of file net.c.

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

Referenced by open_connection(), receive_response(), send_request(), socket_set_option(), WinHttpSetTimeouts(), and WinHttpWebSocketCompleteUpgrade().

netconn_unload()

void netconn_unload

(

void

)

Definition at line 182 of file net.c.

{
    if (winsock_loaded) WSACleanup();
}

Referenced by DllMain().

netconn_wait_overlapped_result()

BOOL netconn_wait_overlapped_result	(	struct netconn *	conn,
		WSAOVERLAPPED *	ovr,
		DWORD *	len
	)

Definition at line 54 of file net.c.

{
    OVERLAPPED *completion_ovr;
    ULONG_PTR key;
 
    while (1)
    {
        if (!GetQueuedCompletionStatus( conn->port, len, &key, &completion_ovr, INFINITE ))
        {
            WARN( "GetQueuedCompletionStatus failed, err %lu.\n", GetLastError() );
            return FALSE;
        }
        if (completion_ovr == (OVERLAPPED *)ovr && (key == conn->socket || conn->socket == -1))
            break;
        ERR( "Unexpected completion key %Ix, completion ovr %p, ovr %p.\n", key, completion_ovr, ovr );
    }
    return TRUE;
}

Referenced by complete_send_frame().

process_header()

DWORD process_header	(	struct request *	request,
		const WCHAR *	field,
		const WCHAR *	value,
		DWORD	flags,
		BOOL	request_only
	)

Definition at line 424 of file request.c.

{
    int index;
    struct header hdr;
 
    TRACE( "%s: %s %#lx\n", debugstr_w(field), debugstr_w(value), flags );
 
    if ((index = get_header_index( request, field, 0, request_only )) >= 0)
    {
        if (flags & WINHTTP_ADDREQ_FLAG_ADD_IF_NEW) return ERROR_WINHTTP_HEADER_ALREADY_EXISTS;
    }
 
    if (flags & WINHTTP_ADDREQ_FLAG_REPLACE)
    {
        if (index >= 0)
        {
            delete_header( request, index );
            if (!value || !value[0]) return ERROR_SUCCESS;
        }
        else if (!(flags & WINHTTP_ADDREQ_FLAG_ADD)) return ERROR_WINHTTP_HEADER_NOT_FOUND;
 
        hdr.field = (LPWSTR)field;
        hdr.value = (LPWSTR)value;
        hdr.is_request = request_only;
        return insert_header( request, &hdr );
    }
    else if (value)
    {
 
        if ((flags & (WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON)) &&
            index >= 0)
        {
            WCHAR *tmp;
            int len, len_orig, len_value;
            struct header *header = &request->headers[index];
 
            len_orig = lstrlenW( header->value );
            len_value = lstrlenW( value );
 
            len = len_orig + len_value + 2;
            if (!(tmp = realloc( header->value, (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
            header->value = tmp;
            header->value[len_orig++] = (flags & WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA) ? ',' : ';';
            header->value[len_orig++] = ' ';
 
            memcpy( &header->value[len_orig], value, len_value * sizeof(WCHAR) );
            header->value[len] = 0;
            return ERROR_SUCCESS;
        }
        else
        {
            hdr.field = (LPWSTR)field;
            hdr.value = (LPWSTR)value;
            hdr.is_request = request_only;
            return insert_header( request, &hdr );
        }
    }
 
    return ERROR_SUCCESS;
}

Referenced by add_accept_types_header(), add_host_header(), add_request_headers(), add_websocket_key_header(), do_authorization(), handle_passport_redirect(), read_reply(), and send_request().

release_host()

void release_host

(

struct hostdata *

host

)

Definition at line 1449 of file request.c.

{
    LONG ref;
 
    EnterCriticalSection( &connection_pool_cs );
    if (!(ref = --host->ref)) list_remove( &host->entry );
    LeaveCriticalSection( &connection_pool_cs );
    if (ref) return;
 
    assert( list_empty( &host->connections ) );
    free( host->hostname );
    free( host );
}

Referenced by netconn_release(), and open_connection().

release_object()

void release_object

(

struct object_header *

hdr

)

Definition at line 71 of file handle.c.

{
    ULONG refs = InterlockedDecrement( &hdr->refs );
    TRACE( "object %p refcount = %lu\n", hdr, refs );
    if (!refs)
    {
        if (hdr->type == WINHTTP_HANDLE_TYPE_REQUEST) close_connection( (struct request *)hdr );
 
        send_callback( hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, &hdr->handle, sizeof(HINTERNET) );
 
        TRACE( "destroying object %p\n", hdr );
        hdr->vtbl->destroy( hdr );
    }
}

Referenced by connect_destroy(), free_handle(), queue_task(), request_destroy(), task_callback(), WinHttpAddRequestHeaders(), WinHttpCloseHandle(), WinHttpConnect(), WinHttpGetProxyForUrl(), WinHttpOpen(), WinHttpOpenRequest(), WinHttpQueryAuthSchemes(), WinHttpQueryDataAvailable(), WinHttpQueryHeaders(), WinHttpQueryOption(), WinHttpReadData(), WinHttpReceiveResponse(), WinHttpSendRequest(), WinHttpSetCredentials(), WinHttpSetOption(), WinHttpSetStatusCallback(), WinHttpSetTimeouts(), WinHttpWebSocketClose(), WinHttpWebSocketCompleteUpgrade(), WinHttpWebSocketQueryCloseStatus(), WinHttpWebSocketReceive(), WinHttpWebSocketSend(), WinHttpWebSocketShutdown(), and WinHttpWriteData().

release_typelib()

void release_typelib

(

void

)

Definition at line 159 of file apps.c.

{
    unsigned i;
 
    for (i = 0; i < ARRAY_SIZE(typeinfo); i++)
        if (typeinfo[i])
            ITypeInfo_Release(typeinfo[i]);
 
    if (typelib)
        ITypeLib_Release(typelib);
}

Referenced by DllMain(), and process_detach().

send_callback()

void send_callback	(	struct object_header *	,
		DWORD	,
		LPVOID	,
		DWORD
	)

set_cookies()

BOOL set_cookies	(	struct request *	request,
		const WCHAR *	cookies
	)

Definition at line 263 of file cookie.c.

{
    BOOL ret = FALSE;
    WCHAR *buffer, *p;
    WCHAR *cookie_domain = NULL, *cookie_path = NULL;
    struct attr *attr, *domain = NULL, *path = NULL;
    struct session *session = request->connect->session;
    struct cookie *cookie;
    int len, used;
 
    len = lstrlenW( cookies );
    if (!(buffer = malloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
    lstrcpyW( buffer, cookies );
 
    p = buffer;
    while (*p && *p != ';') p++;
    if (*p == ';') *p++ = 0;
    if (!(cookie = parse_cookie( buffer )))
    {
        free( buffer );
        return FALSE;
    }
    len = lstrlenW( p );
    while (len && (attr = parse_attr( p, &used )))
    {
        if (!wcsicmp( attr->name, L"domain" ))
        {
            domain = attr;
            cookie_domain = attr->value;
        }
        else if (!wcsicmp( attr->name, L"path" ))
        {
            path = attr;
            cookie_path = attr->value;
        }
        else
        {
            FIXME( "unhandled attribute %s\n", debugstr_w(attr->name) );
            free_attr( attr );
        }
        len -= used;
        p += used;
    }
    if (!cookie_domain && !(cookie_domain = wcsdup( request->connect->servername ))) goto end;
    if (!cookie_path && !(cookie_path = wcsdup( request->path ))) goto end;
 
    if ((p = wcsrchr( cookie_path, '/' )) && p != cookie_path) *p = 0;
    ret = add_cookie( session, cookie, cookie_domain, cookie_path );
 
end:
    if (!ret) free_cookie( cookie );
    if (domain) free_attr( domain );
    else free( cookie_domain );
    if (path) free_attr( path );
    else free( cookie_path );
    free( buffer );
    return ret;
}

Referenced by record_cookies().

set_server_for_hostname()

BOOL set_server_for_hostname	(	struct connect *	connect,
		const WCHAR *	server,
		INTERNET_PORT	port
	)

Definition at line 532 of file session.c.

{
    struct session *session = connect->session;
    BOOL ret = TRUE;
 
    if (session->proxy_server && !should_bypass_proxy(session, server))
    {
        LPCWSTR colon;
 
        if ((colon = wcschr( session->proxy_server, ':' )))
        {
            if (!connect->servername || wcsnicmp( connect->servername,
                session->proxy_server, colon - session->proxy_server - 1 ))
            {
                free( connect->servername );
                connect->resolved = FALSE;
                if (!(connect->servername = malloc( (colon - session->proxy_server + 1) * sizeof(WCHAR) )))
                {
                    ret = FALSE;
                    goto end;
                }
                memcpy( connect->servername, session->proxy_server, (colon - session->proxy_server) * sizeof(WCHAR) );
                connect->servername[colon - session->proxy_server] = 0;
                if (*(colon + 1))
                    connect->serverport = wcstol( colon + 1, NULL, 10 );
                else
                    connect->serverport = INTERNET_DEFAULT_PORT;
            }
        }
        else
        {
            if (!connect->servername || wcsicmp( connect->servername, session->proxy_server ))
            {
                free( connect->servername );
                connect->resolved = FALSE;
                if (!(connect->servername = wcsdup( session->proxy_server )))
                {
                    ret = FALSE;
                    goto end;
                }
                connect->serverport = INTERNET_DEFAULT_PORT;
            }
        }
    }
    else if (server)
    {
        free( connect->servername );
        connect->resolved = FALSE;
        if (!(connect->servername = wcsdup( server )))
        {
            ret = FALSE;
            goto end;
        }
        connect->serverport = port;
    }
end:
    return ret;
}

Referenced by handle_redirect(), and WinHttpConnect().

stop_queue()

void stop_queue

(

struct queue *

queue

)

Definition at line 144 of file request.c.

{
    assert( list_empty( &queue->queued_tasks ));
    TRACE("stopped %p\n", queue);
}

Referenced by request_destroy(), and socket_destroy().

strdupAW()

static WCHAR * strdupAW ( const char *  src )

inlinestatic

Definition at line 446 of file winhttp_private.h.

{
    WCHAR *dst = NULL;
    if (src)
    {
        int len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
        if ((dst = malloc( len * sizeof(WCHAR) )))
            MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
    }
    return dst;
}

strdupWA()

static char * strdupWA ( const WCHAR *  src )

inlinestatic

Definition at line 458 of file winhttp_private.h.

{
    char *dst = NULL;
    if (src)
    {
        int len = WideCharToMultiByte( CP_ACP, 0, src, -1, NULL, 0, NULL, NULL );
        if ((dst = malloc( len )))
            WideCharToMultiByte( CP_ACP, 0, src, -1, dst, len, NULL, NULL );
    }
    return dst;
}

WinHttpRequest_create()

HRESULT WinHttpRequest_create

(

void **

obj

)

Definition at line 6155 of file request.c.

{
    struct winhttp_request *request;
 
    TRACE("%p\n", obj);
 
    if (!(request = calloc( 1, sizeof(*request) ))) return E_OUTOFMEMORY;
    request->IWinHttpRequest_iface.lpVtbl = &winhttp_request_vtbl;
    request->refs = 1;
    InitializeCriticalSectionEx( &request->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO );
    request->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": winhttp_request.cs");
    initialize_request( request );
 
    *obj = &request->IWinHttpRequest_iface;
    TRACE("returning iface %p\n", *obj);
    return S_OK;
}

Variable Documentation

winhttp_instance

HINSTANCE winhttp_instance

extern

Definition at line 33 of file main.c.

Referenced by cache_connection(), connection_collector(), and DllMain().