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