[WININET] Sync with Wine Staging 4.18. CORE-16441
[reactos.git] / dll / win32 / wininet / internet.h
1 /*
2 * Wininet
3 *
4 * Copyright 1999 Corel Corporation
5 *
6 * Ulrich Czekalla
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #ifndef _WINE_INTERNET_H_
24 #define _WINE_INTERNET_H_
25
26 #include "wine/unicode.h"
27 #include "wine/heap.h"
28 #include "wine/list.h"
29
30 #include <time.h>
31
32 #include "winineti.h"
33
34 extern HMODULE WININET_hModule DECLSPEC_HIDDEN;
35
36 typedef struct {
37 WCHAR *name;
38 INTERNET_PORT port;
39 BOOL is_https;
40 struct sockaddr_storage addr;
41 int addr_len;
42 char addr_str[INET6_ADDRSTRLEN];
43
44 WCHAR *scheme_host_port;
45 const WCHAR *host_port;
46 const WCHAR *canon_host_port;
47
48 LONG ref;
49
50 DWORD security_flags;
51 const CERT_CHAIN_CONTEXT *cert_chain;
52
53 struct list entry;
54 struct list conn_pool;
55 } server_t;
56
57 void server_addref(server_t*) DECLSPEC_HIDDEN;
58 void server_release(server_t*) DECLSPEC_HIDDEN;
59
60 typedef enum {
61 COLLECT_TIMEOUT,
62 COLLECT_CONNECTIONS,
63 COLLECT_CLEANUP
64 } collect_type_t;
65 BOOL collect_connections(collect_type_t) DECLSPEC_HIDDEN;
66
67 /* used for netconnection.c stuff */
68 typedef struct
69 {
70 int socket;
71 BOOL secure;
72 BOOL is_blocking;
73 CtxtHandle ssl_ctx;
74 SecPkgContext_StreamSizes ssl_sizes;
75 server_t *server;
76 char *ssl_buf;
77 char *extra_buf;
78 size_t extra_len;
79 char *peek_msg;
80 char *peek_msg_mem;
81 size_t peek_len;
82 DWORD security_flags;
83 BOOL mask_errors;
84
85 BOOL keep_alive;
86 DWORD64 keep_until;
87 struct list pool_entry;
88 } netconn_t;
89
90 BOOL is_valid_netconn(netconn_t *) DECLSPEC_HIDDEN;
91 void close_netconn(netconn_t *) DECLSPEC_HIDDEN;
92
93 static inline void * __WINE_ALLOC_SIZE(2) heap_realloc_zero(void *mem, size_t len)
94 {
95 return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, len);
96 }
97
98 static inline LPWSTR heap_strdupW(LPCWSTR str)
99 {
100 LPWSTR ret = NULL;
101
102 if(str) {
103 DWORD size;
104
105 size = (strlenW(str)+1)*sizeof(WCHAR);
106 ret = heap_alloc(size);
107 if(ret)
108 memcpy(ret, str, size);
109 }
110
111 return ret;
112 }
113
114 static inline char *heap_strdupA(const char *str)
115 {
116 char *ret = NULL;
117
118 if(str) {
119 DWORD size = strlen(str)+1;
120
121 ret = heap_alloc(size);
122 if(ret)
123 memcpy(ret, str, size);
124 }
125
126 return ret;
127 }
128
129 static inline LPWSTR heap_strndupW(LPCWSTR str, UINT max_len)
130 {
131 LPWSTR ret;
132 UINT len;
133
134 if(!str)
135 return NULL;
136
137 for(len=0; len<max_len; len++)
138 if(str[len] == '\0')
139 break;
140
141 ret = heap_alloc(sizeof(WCHAR)*(len+1));
142 if(ret) {
143 memcpy(ret, str, sizeof(WCHAR)*len);
144 ret[len] = '\0';
145 }
146
147 return ret;
148 }
149
150 static inline WCHAR *heap_strndupAtoW(const char *str, int len_a, DWORD *len_w)
151 {
152 WCHAR *ret = NULL;
153
154 if(str) {
155 size_t len;
156 if(len_a < 0) len_a = strlen(str);
157 len = MultiByteToWideChar(CP_ACP, 0, str, len_a, NULL, 0);
158 ret = heap_alloc((len+1)*sizeof(WCHAR));
159 if(ret) {
160 MultiByteToWideChar(CP_ACP, 0, str, len_a, ret, len);
161 ret[len] = 0;
162 *len_w = len;
163 }
164 }
165
166 return ret;
167 }
168
169 static inline WCHAR *heap_strdupAtoW(const char *str)
170 {
171 LPWSTR ret = NULL;
172
173 if(str) {
174 DWORD len;
175
176 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
177 ret = heap_alloc(len*sizeof(WCHAR));
178 if(ret)
179 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
180 }
181
182 return ret;
183 }
184
185 static inline char *heap_strdupWtoA(LPCWSTR str)
186 {
187 char *ret = NULL;
188
189 if(str) {
190 DWORD size = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
191 ret = heap_alloc(size);
192 if(ret)
193 WideCharToMultiByte(CP_ACP, 0, str, -1, ret, size, NULL, NULL);
194 }
195
196 return ret;
197 }
198
199 typedef struct {
200 const WCHAR *str;
201 size_t len;
202 } substr_t;
203
204 static inline substr_t substr(const WCHAR *str, size_t len)
205 {
206 substr_t r = {str, len};
207 return r;
208 }
209
210 static inline substr_t substrz(const WCHAR *str)
211 {
212 return substr(str, strlenW(str));
213 }
214
215 static inline void WININET_find_data_WtoA(LPWIN32_FIND_DATAW dataW, LPWIN32_FIND_DATAA dataA)
216 {
217 dataA->dwFileAttributes = dataW->dwFileAttributes;
218 dataA->ftCreationTime = dataW->ftCreationTime;
219 dataA->ftLastAccessTime = dataW->ftLastAccessTime;
220 dataA->ftLastWriteTime = dataW->ftLastWriteTime;
221 dataA->nFileSizeHigh = dataW->nFileSizeHigh;
222 dataA->nFileSizeLow = dataW->nFileSizeLow;
223 dataA->dwReserved0 = dataW->dwReserved0;
224 dataA->dwReserved1 = dataW->dwReserved1;
225 WideCharToMultiByte(CP_ACP, 0, dataW->cFileName, -1,
226 dataA->cFileName, sizeof(dataA->cFileName),
227 NULL, NULL);
228 WideCharToMultiByte(CP_ACP, 0, dataW->cAlternateFileName, -1,
229 dataA->cAlternateFileName, sizeof(dataA->cAlternateFileName),
230 NULL, NULL);
231 }
232
233 typedef enum
234 {
235 WH_HINIT = INTERNET_HANDLE_TYPE_INTERNET,
236 WH_HFTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_FTP,
237 WH_HGOPHERSESSION = INTERNET_HANDLE_TYPE_CONNECT_GOPHER,
238 WH_HHTTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_HTTP,
239 WH_HFILE = INTERNET_HANDLE_TYPE_FTP_FILE,
240 WH_HFTPFINDNEXT = INTERNET_HANDLE_TYPE_FTP_FIND,
241 WH_HHTTPREQ = INTERNET_HANDLE_TYPE_HTTP_REQUEST,
242 } WH_TYPE;
243
244 #define INET_OPENURL 0x0001
245 #define INET_CALLBACKW 0x0002
246
247 typedef struct
248 {
249 LONG ref;
250 HANDLE file_handle;
251 WCHAR *file_name;
252 WCHAR *url;
253 BOOL is_committed;
254 } req_file_t;
255
256 typedef struct _object_header_t object_header_t;
257
258 typedef struct {
259 void (*Destroy)(object_header_t*);
260 void (*CloseConnection)(object_header_t*);
261 DWORD (*QueryOption)(object_header_t*,DWORD,void*,DWORD*,BOOL);
262 DWORD (*SetOption)(object_header_t*,DWORD,void*,DWORD);
263 DWORD (*ReadFile)(object_header_t*,void*,DWORD,DWORD*,DWORD,DWORD_PTR);
264 DWORD (*WriteFile)(object_header_t*,const void*,DWORD,DWORD*);
265 DWORD (*QueryDataAvailable)(object_header_t*,DWORD*,DWORD,DWORD_PTR);
266 DWORD (*FindNextFileW)(object_header_t*,void*);
267 DWORD (*LockRequestFile)(object_header_t*,req_file_t**);
268 } object_vtbl_t;
269
270 #define INTERNET_HANDLE_IN_USE 1
271
272 struct _object_header_t
273 {
274 WH_TYPE htype;
275 const object_vtbl_t *vtbl;
276 HINTERNET hInternet;
277 BOOL valid_handle;
278 DWORD dwFlags;
279 DWORD_PTR dwContext;
280 DWORD dwError;
281 ULONG ErrorMask;
282 DWORD dwInternalFlags;
283 LONG refs;
284 BOOL decoding;
285 INTERNET_STATUS_CALLBACK lpfnStatusCB;
286 struct list entry;
287 struct list children;
288 };
289
290 typedef struct
291 {
292 object_header_t hdr;
293 LPWSTR agent;
294 LPWSTR proxy;
295 LPWSTR proxyBypass;
296 LPWSTR proxyUsername;
297 LPWSTR proxyPassword;
298 DWORD accessType;
299 DWORD connect_timeout;
300 } appinfo_t;
301
302 typedef struct
303 {
304 object_header_t hdr;
305 appinfo_t *appInfo;
306 LPWSTR hostName; /* the final destination of the request */
307 LPWSTR userName;
308 LPWSTR password;
309 INTERNET_PORT hostPort; /* the final destination port of the request */
310 DWORD connect_timeout;
311 DWORD send_timeout;
312 DWORD receive_timeout;
313 } http_session_t;
314
315 #define HDR_ISREQUEST 0x0001
316 #define HDR_COMMADELIMITED 0x0002
317 #define HDR_SEMIDELIMITED 0x0004
318
319 typedef struct
320 {
321 LPWSTR lpszField;
322 LPWSTR lpszValue;
323 WORD wFlags;
324 WORD wCount;
325 } HTTPHEADERW, *LPHTTPHEADERW;
326
327
328 struct HttpAuthInfo;
329
330 typedef struct data_stream_vtbl_t data_stream_vtbl_t;
331
332 typedef struct {
333 const data_stream_vtbl_t *vtbl;
334 } data_stream_t;
335
336 typedef struct {
337 data_stream_t data_stream;
338 ULONGLONG content_length;
339 ULONGLONG content_read;
340 } netconn_stream_t;
341
342 #define READ_BUFFER_SIZE 8192
343
344 typedef struct
345 {
346 object_header_t hdr;
347 http_session_t *session;
348 server_t *server;
349 server_t *proxy;
350 LPWSTR path;
351 LPWSTR verb;
352 netconn_t *netconn;
353 DWORD security_flags;
354 DWORD connect_timeout;
355 DWORD send_timeout;
356 DWORD receive_timeout;
357 LPWSTR version;
358 DWORD status_code;
359 LPWSTR statusText;
360 DWORD bytesToWrite;
361 DWORD bytesWritten;
362
363 CRITICAL_SECTION headers_section; /* section to protect the headers array */
364 HTTPHEADERW *custHeaders;
365 DWORD nCustHeaders;
366
367 FILETIME last_modified;
368 HANDLE hCacheFile;
369 req_file_t *req_file;
370 FILETIME expires;
371 struct HttpAuthInfo *authInfo;
372 struct HttpAuthInfo *proxyAuthInfo;
373
374 CRITICAL_SECTION read_section; /* section to protect the following fields */
375 ULONGLONG contentLength; /* total number of bytes to be read */
376 BOOL read_gzip; /* are we reading in gzip mode? */
377 DWORD read_pos; /* current read position in read_buf */
378 DWORD read_size; /* valid data size in read_buf */
379 BYTE read_buf[READ_BUFFER_SIZE]; /* buffer for already read but not returned data */
380
381 data_stream_t *data_stream;
382 netconn_stream_t netconn_stream;
383 } http_request_t;
384
385 typedef struct task_header_t task_header_t;
386 typedef void (*async_task_proc_t)(task_header_t*);
387
388 struct task_header_t
389 {
390 async_task_proc_t proc;
391 object_header_t *hdr;
392 };
393
394 void *alloc_async_task(object_header_t*,async_task_proc_t,size_t) DECLSPEC_HIDDEN;
395
396 void *alloc_object(object_header_t*,const object_vtbl_t*,size_t) DECLSPEC_HIDDEN;
397 object_header_t *get_handle_object( HINTERNET hinternet ) DECLSPEC_HIDDEN;
398 object_header_t *WININET_AddRef( object_header_t *info ) DECLSPEC_HIDDEN;
399 BOOL WININET_Release( object_header_t *info ) DECLSPEC_HIDDEN;
400
401 DWORD INET_QueryOption(object_header_t*,DWORD,void*,DWORD*,BOOL) DECLSPEC_HIDDEN;
402 DWORD INET_SetOption(object_header_t*,DWORD,void*,DWORD) DECLSPEC_HIDDEN;
403
404 time_t ConvertTimeString(LPCWSTR asctime) DECLSPEC_HIDDEN;
405
406 HINTERNET FTP_Connect(appinfo_t *hIC, LPCWSTR lpszServerName,
407 INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
408 LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
409 DWORD dwInternalFlags) DECLSPEC_HIDDEN;
410
411 DWORD HTTP_Connect(appinfo_t*,LPCWSTR,
412 INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
413 LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
414 DWORD dwInternalFlags, HINTERNET*) DECLSPEC_HIDDEN;
415
416 BOOL GetAddress(const WCHAR*,INTERNET_PORT,SOCKADDR*,int*,char*) DECLSPEC_HIDDEN;
417
418 DWORD get_cookie_header(const WCHAR*,const WCHAR*,WCHAR**) DECLSPEC_HIDDEN;
419 DWORD set_cookie(substr_t,substr_t,substr_t,substr_t,DWORD) DECLSPEC_HIDDEN;
420
421 void INTERNET_SetLastError(DWORD dwError) DECLSPEC_HIDDEN;
422 DWORD INTERNET_GetLastError(void) DECLSPEC_HIDDEN;
423 DWORD INTERNET_AsyncCall(task_header_t*) DECLSPEC_HIDDEN;
424 LPSTR INTERNET_GetResponseBuffer(void) DECLSPEC_HIDDEN;
425
426 VOID INTERNET_SendCallback(object_header_t *hdr, DWORD_PTR dwContext,
427 DWORD dwInternetStatus, LPVOID lpvStatusInfo,
428 DWORD dwStatusInfoLength) DECLSPEC_HIDDEN;
429 WCHAR *INTERNET_FindProxyForProtocol(LPCWSTR szProxy, LPCWSTR proto) DECLSPEC_HIDDEN;
430
431 DWORD create_netconn(server_t*,DWORD,BOOL,DWORD,netconn_t**) DECLSPEC_HIDDEN;
432 void free_netconn(netconn_t*) DECLSPEC_HIDDEN;
433 void NETCON_unload(void) DECLSPEC_HIDDEN;
434 DWORD NETCON_secure_connect(netconn_t*,server_t*) DECLSPEC_HIDDEN;
435 DWORD NETCON_send(netconn_t *connection, const void *msg, size_t len, int flags,
436 int *sent /* out */) DECLSPEC_HIDDEN;
437 DWORD NETCON_recv(netconn_t*,void*,size_t,BOOL,int*) DECLSPEC_HIDDEN;
438 BOOL NETCON_is_alive(netconn_t*) DECLSPEC_HIDDEN;
439 LPCVOID NETCON_GetCert(netconn_t *connection) DECLSPEC_HIDDEN;
440 int NETCON_GetCipherStrength(netconn_t*) DECLSPEC_HIDDEN;
441 DWORD NETCON_set_timeout(netconn_t *connection, BOOL send, DWORD value) DECLSPEC_HIDDEN;
442 int sock_send(int fd, const void *msg, size_t len, int flags) DECLSPEC_HIDDEN;
443 int sock_recv(int fd, void *msg, size_t len, int flags) DECLSPEC_HIDDEN;
444
445 server_t *get_server(substr_t,INTERNET_PORT,BOOL,BOOL) DECLSPEC_HIDDEN;
446
447 DWORD create_req_file(const WCHAR*,req_file_t**) DECLSPEC_HIDDEN;
448 void req_file_release(req_file_t*) DECLSPEC_HIDDEN;
449
450 static inline req_file_t *req_file_addref(req_file_t *req_file)
451 {
452 InterlockedIncrement(&req_file->ref);
453 return req_file;
454 }
455
456 BOOL init_urlcache(void) DECLSPEC_HIDDEN;
457 void free_urlcache(void) DECLSPEC_HIDDEN;
458 void free_cookie(void) DECLSPEC_HIDDEN;
459 void free_authorization_cache(void) DECLSPEC_HIDDEN;
460
461 void init_winsock(void) DECLSPEC_HIDDEN;
462
463 #define MAX_REPLY_LEN 0x5B4
464
465 /* Used for debugging - maybe need to be shared in the Wine debugging code ? */
466 typedef struct
467 {
468 DWORD val;
469 const char* name;
470 } wininet_flag_info;
471
472 /* Undocumented security flags */
473 #define _SECURITY_FLAG_CERT_REV_FAILED 0x00800000
474 #define _SECURITY_FLAG_CERT_INVALID_CA 0x01000000
475 #define _SECURITY_FLAG_CERT_INVALID_CN 0x02000000
476 #define _SECURITY_FLAG_CERT_INVALID_DATE 0x04000000
477
478 #define _SECURITY_ERROR_FLAGS_MASK \
479 (_SECURITY_FLAG_CERT_REV_FAILED \
480 |_SECURITY_FLAG_CERT_INVALID_CA \
481 |_SECURITY_FLAG_CERT_INVALID_CN \
482 |_SECURITY_FLAG_CERT_INVALID_DATE)
483
484 #endif /* _WINE_INTERNET_H_ */