[WINHTTP] Sync with Wine Staging 3.9. CORE-14656
[reactos.git] / dll / win32 / winhttp / winhttp_private.h
1 /*
2 * Copyright 2008 Hans Leidekker for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #ifndef _WINE_WINHTTP_PRIVATE_H_
20 #define _WINE_WINHTTP_PRIVATE_H_
21
22 #ifndef __WINE_CONFIG_H
23 # error You must include config.h to use this header
24 #endif
25
26 #include "wine/heap.h"
27 #include "wine/list.h"
28 #include "wine/unicode.h"
29
30 #include <sys/types.h>
31 #ifdef HAVE_SYS_SOCKET_H
32 # include <sys/socket.h>
33 #endif
34 #ifdef HAVE_NETINET_IN_H
35 # include <netinet/in.h>
36 #endif
37 #ifdef HAVE_NETDB_H
38 # include <netdb.h>
39 #endif
40 #if defined(__MINGW32__) || defined (_MSC_VER)
41 # include <ws2tcpip.h>
42 #else
43 # define closesocket close
44 # define ioctlsocket ioctl
45 #endif
46
47 #include "ole2.h"
48 #include "sspi.h"
49
50 static const WCHAR getW[] = {'G','E','T',0};
51 static const WCHAR postW[] = {'P','O','S','T',0};
52 static const WCHAR headW[] = {'H','E','A','D',0};
53 static const WCHAR slashW[] = {'/',0};
54 static const WCHAR http1_0[] = {'H','T','T','P','/','1','.','0',0};
55 static const WCHAR http1_1[] = {'H','T','T','P','/','1','.','1',0};
56 static const WCHAR chunkedW[] = {'c','h','u','n','k','e','d',0};
57
58 typedef struct _object_header_t object_header_t;
59
60 typedef struct
61 {
62 void (*destroy)( object_header_t * );
63 BOOL (*query_option)( object_header_t *, DWORD, void *, DWORD * );
64 BOOL (*set_option)( object_header_t *, DWORD, void *, DWORD );
65 } object_vtbl_t;
66
67 struct _object_header_t
68 {
69 DWORD type;
70 HINTERNET handle;
71 const object_vtbl_t *vtbl;
72 DWORD flags;
73 DWORD disable_flags;
74 DWORD logon_policy;
75 DWORD redirect_policy;
76 DWORD error;
77 DWORD_PTR context;
78 LONG refs;
79 WINHTTP_STATUS_CALLBACK callback;
80 DWORD notify_mask;
81 struct list entry;
82 struct list children;
83 };
84
85 typedef struct
86 {
87 struct list entry;
88 WCHAR *name;
89 struct list cookies;
90 } domain_t;
91
92 typedef struct
93 {
94 struct list entry;
95 WCHAR *name;
96 WCHAR *value;
97 WCHAR *path;
98 } cookie_t;
99
100 typedef struct {
101 struct list entry;
102 LONG ref;
103 WCHAR *hostname;
104 INTERNET_PORT port;
105 BOOL secure;
106 struct list connections;
107 } hostdata_t;
108
109 typedef struct
110 {
111 object_header_t hdr;
112 LPWSTR agent;
113 DWORD access;
114 int resolve_timeout;
115 int connect_timeout;
116 int send_timeout;
117 int recv_timeout;
118 LPWSTR proxy_server;
119 LPWSTR proxy_bypass;
120 LPWSTR proxy_username;
121 LPWSTR proxy_password;
122 struct list cookie_cache;
123 HANDLE unload_event;
124 CredHandle cred_handle;
125 BOOL cred_handle_initialized;
126 DWORD secure_protocols;
127 } session_t;
128
129 typedef struct
130 {
131 object_header_t hdr;
132 session_t *session;
133 LPWSTR hostname; /* final destination of the request */
134 LPWSTR servername; /* name of the server we directly connect to */
135 LPWSTR username;
136 LPWSTR password;
137 INTERNET_PORT hostport;
138 INTERNET_PORT serverport;
139 struct sockaddr_storage sockaddr;
140 BOOL resolved;
141 } connect_t;
142
143 typedef struct
144 {
145 struct list entry;
146 int socket;
147 struct sockaddr_storage sockaddr;
148 BOOL secure; /* SSL active on connection? */
149 hostdata_t *host;
150 ULONGLONG keep_until;
151 CtxtHandle ssl_ctx;
152 SecPkgContext_StreamSizes ssl_sizes;
153 char *ssl_buf;
154 char *extra_buf;
155 size_t extra_len;
156 char *peek_msg;
157 char *peek_msg_mem;
158 size_t peek_len;
159 } netconn_t;
160
161 typedef struct
162 {
163 LPWSTR field;
164 LPWSTR value;
165 BOOL is_request; /* part of request headers? */
166 } header_t;
167
168 enum auth_target
169 {
170 TARGET_INVALID = -1,
171 TARGET_SERVER,
172 TARGET_PROXY,
173 TARGET_MAX
174 };
175
176 enum auth_scheme
177 {
178 SCHEME_INVALID = -1,
179 SCHEME_BASIC,
180 SCHEME_NTLM,
181 SCHEME_PASSPORT,
182 SCHEME_DIGEST,
183 SCHEME_NEGOTIATE,
184 SCHEME_MAX
185 };
186
187 struct authinfo
188 {
189 enum auth_scheme scheme;
190 CredHandle cred;
191 CtxtHandle ctx;
192 TimeStamp exp;
193 ULONG attr;
194 ULONG max_token;
195 char *data;
196 unsigned int data_len;
197 BOOL finished; /* finished authenticating */
198 };
199
200 typedef struct
201 {
202 object_header_t hdr;
203 connect_t *connect;
204 LPWSTR verb;
205 LPWSTR path;
206 LPWSTR version;
207 LPWSTR raw_headers;
208 void *optional;
209 DWORD optional_len;
210 netconn_t *netconn;
211 DWORD security_flags;
212 int resolve_timeout;
213 int connect_timeout;
214 int send_timeout;
215 int recv_timeout;
216 LPWSTR status_text;
217 DWORD content_length; /* total number of bytes to be read */
218 DWORD content_read; /* bytes read so far */
219 BOOL read_chunked; /* are we reading in chunked mode? */
220 BOOL read_chunked_eof; /* end of stream in chunked mode */
221 BOOL read_chunked_size; /* chunk size remaining */
222 DWORD read_pos; /* current read position in read_buf */
223 DWORD read_size; /* valid data size in read_buf */
224 char read_buf[8192]; /* buffer for already read but not returned data */
225 header_t *headers;
226 DWORD num_headers;
227 struct authinfo *authinfo;
228 struct authinfo *proxy_authinfo;
229 HANDLE task_wait;
230 HANDLE task_cancel;
231 HANDLE task_thread;
232 struct list task_queue;
233 CRITICAL_SECTION task_cs;
234 struct
235 {
236 WCHAR *username;
237 WCHAR *password;
238 } creds[TARGET_MAX][SCHEME_MAX];
239 } request_t;
240
241 typedef struct _task_header_t task_header_t;
242
243 struct _task_header_t
244 {
245 struct list entry;
246 request_t *request;
247 void (*proc)( task_header_t * );
248 };
249
250 typedef struct
251 {
252 task_header_t hdr;
253 LPWSTR headers;
254 DWORD headers_len;
255 LPVOID optional;
256 DWORD optional_len;
257 DWORD total_len;
258 DWORD_PTR context;
259 } send_request_t;
260
261 typedef struct
262 {
263 task_header_t hdr;
264 } receive_response_t;
265
266 typedef struct
267 {
268 task_header_t hdr;
269 LPDWORD available;
270 } query_data_t;
271
272 typedef struct
273 {
274 task_header_t hdr;
275 LPVOID buffer;
276 DWORD to_read;
277 LPDWORD read;
278 } read_data_t;
279
280 typedef struct
281 {
282 task_header_t hdr;
283 LPCVOID buffer;
284 DWORD to_write;
285 LPDWORD written;
286 } write_data_t;
287
288 object_header_t *addref_object( object_header_t * ) DECLSPEC_HIDDEN;
289 object_header_t *grab_object( HINTERNET ) DECLSPEC_HIDDEN;
290 void release_object( object_header_t * ) DECLSPEC_HIDDEN;
291 HINTERNET alloc_handle( object_header_t * ) DECLSPEC_HIDDEN;
292 BOOL free_handle( HINTERNET ) DECLSPEC_HIDDEN;
293
294 void set_last_error( DWORD ) DECLSPEC_HIDDEN;
295 DWORD get_last_error( void ) DECLSPEC_HIDDEN;
296 void send_callback( object_header_t *, DWORD, LPVOID, DWORD ) DECLSPEC_HIDDEN;
297 void close_connection( request_t * ) DECLSPEC_HIDDEN;
298
299 BOOL netconn_close( netconn_t * ) DECLSPEC_HIDDEN;
300 netconn_t *netconn_create( hostdata_t *, const struct sockaddr_storage *, int ) DECLSPEC_HIDDEN;
301 void netconn_unload( void ) DECLSPEC_HIDDEN;
302 ULONG netconn_query_data_available( netconn_t * ) DECLSPEC_HIDDEN;
303 BOOL netconn_recv( netconn_t *, void *, size_t, int, int * ) DECLSPEC_HIDDEN;
304 BOOL netconn_resolve( WCHAR *, INTERNET_PORT, struct sockaddr_storage *, int ) DECLSPEC_HIDDEN;
305 BOOL netconn_secure_connect( netconn_t *, WCHAR *, DWORD, CredHandle * ) DECLSPEC_HIDDEN;
306 BOOL netconn_send( netconn_t *, const void *, size_t, int * ) DECLSPEC_HIDDEN;
307 DWORD netconn_set_timeout( netconn_t *, BOOL, int ) DECLSPEC_HIDDEN;
308 BOOL netconn_is_alive( netconn_t * ) DECLSPEC_HIDDEN;
309 const void *netconn_get_certificate( netconn_t * ) DECLSPEC_HIDDEN;
310 int netconn_get_cipher_strength( netconn_t * ) DECLSPEC_HIDDEN;
311
312 BOOL set_cookies( request_t *, const WCHAR * ) DECLSPEC_HIDDEN;
313 BOOL add_cookie_headers( request_t * ) DECLSPEC_HIDDEN;
314 BOOL add_request_headers( request_t *, LPCWSTR, DWORD, DWORD ) DECLSPEC_HIDDEN;
315 void delete_domain( domain_t * ) DECLSPEC_HIDDEN;
316 BOOL set_server_for_hostname( connect_t *, LPCWSTR, INTERNET_PORT ) DECLSPEC_HIDDEN;
317 void destroy_authinfo( struct authinfo * ) DECLSPEC_HIDDEN;
318
319 void release_host( hostdata_t *host ) DECLSPEC_HIDDEN;
320
321 BOOL process_header( request_t *request, LPCWSTR field, LPCWSTR value, DWORD flags, BOOL request_only ) DECLSPEC_HIDDEN;
322
323 extern HRESULT WinHttpRequest_create( void ** ) DECLSPEC_HIDDEN;
324 void release_typelib( void ) DECLSPEC_HIDDEN;
325
326 static inline void* __WINE_ALLOC_SIZE(2) heap_realloc_zero( LPVOID mem, SIZE_T size )
327 {
328 return HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size );
329 }
330
331 static inline WCHAR *strdupW( const WCHAR *src )
332 {
333 WCHAR *dst;
334
335 if (!src) return NULL;
336 dst = heap_alloc( (strlenW( src ) + 1) * sizeof(WCHAR) );
337 if (dst) strcpyW( dst, src );
338 return dst;
339 }
340
341 static inline WCHAR *strdupAW( const char *src )
342 {
343 WCHAR *dst = NULL;
344 if (src)
345 {
346 DWORD len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
347 if ((dst = heap_alloc( len * sizeof(WCHAR) )))
348 MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
349 }
350 return dst;
351 }
352
353 static inline char *strdupWA( const WCHAR *src )
354 {
355 char *dst = NULL;
356 if (src)
357 {
358 int len = WideCharToMultiByte( CP_ACP, 0, src, -1, NULL, 0, NULL, NULL );
359 if ((dst = heap_alloc( len )))
360 WideCharToMultiByte( CP_ACP, 0, src, -1, dst, len, NULL, NULL );
361 }
362 return dst;
363 }
364
365 static inline char *strdupWA_sized( const WCHAR *src, DWORD size )
366 {
367 char *dst = NULL;
368 if (src)
369 {
370 int len = WideCharToMultiByte( CP_ACP, 0, src, size, NULL, 0, NULL, NULL ) + 1;
371 if ((dst = heap_alloc( len )))
372 {
373 WideCharToMultiByte( CP_ACP, 0, src, len, dst, size, NULL, NULL );
374 dst[len - 1] = 0;
375 }
376 }
377 return dst;
378 }
379
380 extern HINSTANCE winhttp_instance DECLSPEC_HIDDEN;
381
382 #endif /* _WINE_WINHTTP_PRIVATE_H_ */