winhttp_private.h 9.18 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * Copyright 2008 Hans Leidekker for CodeWeavers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef _WINE_WINHTTP_PRIVATE_H_
#define _WINE_WINHTTP_PRIVATE_H_

22 23 24 25
#ifndef __WINE_CONFIG_H
# error You must include config.h to use this header
#endif

26
#include "wine/list.h"
27
#include "wine/unicode.h"
28

29
#include <sys/types.h>
30 31 32
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
33 34 35
#ifdef HAVE_NETINET_IN_H
# include <netinet/in.h>
#endif
36 37 38
#ifdef HAVE_NETDB_H
# include <netdb.h>
#endif
39 40
#if defined(__MINGW32__) || defined (_MSC_VER)
# include <ws2tcpip.h>
41 42 43
#else
# define closesocket close
# define ioctlsocket ioctl
44
#endif
45

46
#include "ole2.h"
47
#include "sspi.h"
48

49 50
static const WCHAR getW[]    = {'G','E','T',0};
static const WCHAR postW[]   = {'P','O','S','T',0};
51
static const WCHAR headW[]   = {'H','E','A','D',0};
52
static const WCHAR slashW[]  = {'/',0};
53
static const WCHAR http1_0[] = {'H','T','T','P','/','1','.','0',0};
54
static const WCHAR http1_1[] = {'H','T','T','P','/','1','.','1',0};
55
static const WCHAR chunkedW[] = {'c','h','u','n','k','e','d',0};
56

57 58 59 60 61
typedef struct _object_header_t object_header_t;

typedef struct
{
    void (*destroy)( object_header_t * );
62
    BOOL (*query_option)( object_header_t *, DWORD, void *, DWORD * );
63 64 65 66 67 68 69 70 71
    BOOL (*set_option)( object_header_t *, DWORD, void *, DWORD );
} object_vtbl_t;

struct _object_header_t
{
    DWORD type;
    HINTERNET handle;
    const object_vtbl_t *vtbl;
    DWORD flags;
72 73 74
    DWORD disable_flags;
    DWORD logon_policy;
    DWORD redirect_policy;
75 76 77 78 79 80 81 82 83
    DWORD error;
    DWORD_PTR context;
    LONG refs;
    WINHTTP_STATUS_CALLBACK callback;
    DWORD notify_mask;
    struct list entry;
    struct list children;
};

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
typedef struct
{
    struct list entry;
    WCHAR *name;
    struct list cookies;
} domain_t;

typedef struct
{
    struct list entry;
    WCHAR *name;
    WCHAR *value;
    WCHAR *path;
} cookie_t;

99 100 101 102 103
typedef struct
{
    object_header_t hdr;
    LPWSTR agent;
    DWORD access;
104
    int resolve_timeout;
105 106 107
    int connect_timeout;
    int send_timeout;
    int recv_timeout;
108 109 110 111
    LPWSTR proxy_server;
    LPWSTR proxy_bypass;
    LPWSTR proxy_username;
    LPWSTR proxy_password;
112
    struct list cookie_cache;
113 114
} session_t;

115 116 117 118 119 120 121 122 123 124
typedef struct
{
    object_header_t hdr;
    session_t *session;
    LPWSTR hostname;    /* final destination of the request */
    LPWSTR servername;  /* name of the server we directly connect to */
    LPWSTR username;
    LPWSTR password;
    INTERNET_PORT hostport;
    INTERNET_PORT serverport;
125
    struct sockaddr_storage sockaddr;
126
    BOOL resolved;
127 128
} connect_t;

129 130 131
typedef struct
{
    int socket;
132
    BOOL secure; /* SSL active on connection? */
133 134
    CtxtHandle ssl_ctx;
    SecPkgContext_StreamSizes ssl_sizes;
135
    char *ssl_buf;
136 137
    char *extra_buf;
    size_t extra_len;
138 139 140
    char *peek_msg;
    char *peek_msg_mem;
    size_t peek_len;
141
    DWORD security_flags;
142 143 144 145 146 147
} netconn_t;

typedef struct
{
    LPWSTR field;
    LPWSTR value;
148
    BOOL is_request; /* part of request headers? */
149 150
} header_t;

151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
enum auth_scheme
{
    SCHEME_INVALID = -1,
    SCHEME_BASIC,
    SCHEME_NTLM,
    SCHEME_PASSPORT,
    SCHEME_DIGEST,
    SCHEME_NEGOTIATE
};

struct authinfo
{
    enum auth_scheme scheme;
    CredHandle cred;
    CtxtHandle ctx;
    TimeStamp exp;
    ULONG attr;
    ULONG max_token;
    char *data;
    unsigned int data_len;
    BOOL finished; /* finished authenticating */
};

174 175 176 177 178 179 180 181
typedef struct
{
    object_header_t hdr;
    connect_t *connect;
    LPWSTR verb;
    LPWSTR path;
    LPWSTR version;
    LPWSTR raw_headers;
182 183
    void *optional;
    DWORD optional_len;
184
    netconn_t netconn;
185
    int resolve_timeout;
186
    int connect_timeout;
187 188
    int send_timeout;
    int recv_timeout;
189
    LPWSTR status_text;
190
    DWORD content_length; /* total number of bytes to be read */
191
    DWORD content_read;   /* bytes read so far */
192
    BOOL  read_chunked;   /* are we reading in chunked mode? */
193 194
    BOOL  read_chunked_eof;  /* end of stream in chunked mode */
    BOOL  read_chunked_size; /* chunk size remaining */
195 196
    DWORD read_pos;       /* current read position in read_buf */
    DWORD read_size;      /* valid data size in read_buf */
197
    char  read_buf[8192]; /* buffer for already read but not returned data */
198 199
    header_t *headers;
    DWORD num_headers;
200 201
    WCHAR **accept_types;
    DWORD num_accept_types;
202 203
    struct authinfo *authinfo;
    struct authinfo *proxy_authinfo;
204 205 206 207 208
    HANDLE task_wait;
    HANDLE task_cancel;
    HANDLE task_thread;
    struct list task_queue;
    CRITICAL_SECTION task_cs;
209 210
} request_t;

211 212 213 214
typedef struct _task_header_t task_header_t;

struct _task_header_t
{
215
    struct list entry;
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
    request_t *request;
    void (*proc)( task_header_t * );
};

typedef struct
{
    task_header_t hdr;
    LPWSTR headers;
    DWORD headers_len;
    LPVOID optional;
    DWORD optional_len;
    DWORD total_len;
    DWORD_PTR context;
} send_request_t;

typedef struct
{
    task_header_t hdr;
} receive_response_t;

typedef struct
{
    task_header_t hdr;
    LPDWORD available;
} query_data_t;

typedef struct
{
    task_header_t hdr;
    LPVOID buffer;
    DWORD to_read;
    LPDWORD read;
} read_data_t;

typedef struct
{
    task_header_t hdr;
    LPCVOID buffer;
    DWORD to_write;
    LPDWORD written;
} write_data_t;

258 259 260 261 262
object_header_t *addref_object( object_header_t * ) DECLSPEC_HIDDEN;
object_header_t *grab_object( HINTERNET ) DECLSPEC_HIDDEN;
void release_object( object_header_t * ) DECLSPEC_HIDDEN;
HINTERNET alloc_handle( object_header_t * ) DECLSPEC_HIDDEN;
BOOL free_handle( HINTERNET ) DECLSPEC_HIDDEN;
263

264 265 266 267
void set_last_error( DWORD ) DECLSPEC_HIDDEN;
DWORD get_last_error( void ) DECLSPEC_HIDDEN;
void send_callback( object_header_t *, DWORD, LPVOID, DWORD ) DECLSPEC_HIDDEN;
void close_connection( request_t * ) DECLSPEC_HIDDEN;
268

269 270 271 272
BOOL netconn_close( netconn_t * ) DECLSPEC_HIDDEN;
BOOL netconn_connect( netconn_t *, const struct sockaddr *, unsigned int, int ) DECLSPEC_HIDDEN;
BOOL netconn_connected( netconn_t * ) DECLSPEC_HIDDEN;
BOOL netconn_create( netconn_t *, int, int, int ) DECLSPEC_HIDDEN;
273
BOOL netconn_init( netconn_t * ) DECLSPEC_HIDDEN;
274
void netconn_unload( void ) DECLSPEC_HIDDEN;
275
ULONG netconn_query_data_available( netconn_t * ) DECLSPEC_HIDDEN;
276 277 278
BOOL netconn_recv( netconn_t *, void *, size_t, int, int * ) DECLSPEC_HIDDEN;
BOOL netconn_resolve( WCHAR *, INTERNET_PORT, struct sockaddr *, socklen_t *, int ) DECLSPEC_HIDDEN;
BOOL netconn_secure_connect( netconn_t *, WCHAR * ) DECLSPEC_HIDDEN;
279
BOOL netconn_send( netconn_t *, const void *, size_t, int * ) DECLSPEC_HIDDEN;
280 281 282
DWORD netconn_set_timeout( netconn_t *, BOOL, int ) DECLSPEC_HIDDEN;
const void *netconn_get_certificate( netconn_t * ) DECLSPEC_HIDDEN;
int netconn_get_cipher_strength( netconn_t * ) DECLSPEC_HIDDEN;
283

284 285 286 287
BOOL set_cookies( request_t *, const WCHAR * ) DECLSPEC_HIDDEN;
BOOL add_cookie_headers( request_t * ) DECLSPEC_HIDDEN;
BOOL add_request_headers( request_t *, LPCWSTR, DWORD, DWORD ) DECLSPEC_HIDDEN;
void delete_domain( domain_t * ) DECLSPEC_HIDDEN;
288 289
BOOL set_server_for_hostname( connect_t *, LPCWSTR, INTERNET_PORT ) DECLSPEC_HIDDEN;
void destroy_authinfo( struct authinfo * ) DECLSPEC_HIDDEN;
290

291
extern HRESULT WinHttpRequest_create( void ** ) DECLSPEC_HIDDEN;
292
void release_typelib( void ) DECLSPEC_HIDDEN;
293

294 295 296 297 298 299 300 301 302 303
static inline void *heap_alloc( SIZE_T size )
{
    return HeapAlloc( GetProcessHeap(), 0, size );
}

static inline void *heap_alloc_zero( SIZE_T size )
{
    return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
}

304 305 306 307 308
static inline void *heap_realloc( LPVOID mem, SIZE_T size )
{
    return HeapReAlloc( GetProcessHeap(), 0, mem, size );
}

309 310 311 312 313 314 315 316 317 318
static inline void *heap_realloc_zero( LPVOID mem, SIZE_T size )
{
    return HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size );
}

static inline BOOL heap_free( LPVOID mem )
{
    return HeapFree( GetProcessHeap(), 0, mem );
}

319 320 321 322 323 324 325 326 327 328
static inline WCHAR *strdupW( const WCHAR *src )
{
    WCHAR *dst;

    if (!src) return NULL;
    dst = heap_alloc( (strlenW( src ) + 1) * sizeof(WCHAR) );
    if (dst) strcpyW( dst, src );
    return dst;
}

329 330 331 332 333 334 335 336 337 338 339 340
static inline WCHAR *strdupAW( const char *src )
{
    WCHAR *dst = NULL;
    if (src)
    {
        DWORD len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
        if ((dst = heap_alloc( len * sizeof(WCHAR) )))
            MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
    }
    return dst;
}

341 342 343 344 345 346 347 348 349 350 351 352
static inline char *strdupWA( const WCHAR *src )
{
    char *dst = NULL;
    if (src)
    {
        int len = WideCharToMultiByte( CP_ACP, 0, src, -1, NULL, 0, NULL, NULL );
        if ((dst = heap_alloc( len )))
            WideCharToMultiByte( CP_ACP, 0, src, -1, dst, len, NULL, NULL );
    }
    return dst;
}

353
#endif /* _WINE_WINHTTP_PRIVATE_H_ */