sync with trunk r46493
[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 #ifndef __WINE_CONFIG_H
27 # error You must include config.h to use this header
28 #endif
29
30 #include "wine/unicode.h"
31 #include "wine/list.h"
32
33 #include <time.h>
34 #ifdef HAVE_NETDB_H
35 # include <netdb.h>
36 #endif
37 #ifdef HAVE_NETINET_IN_H
38 # include <sys/types.h>
39 # include <netinet/in.h>
40 #endif
41 #ifdef HAVE_SYS_SOCKET_H
42 # include <sys/socket.h>
43 #endif
44
45 #if !defined(__MINGW32__) && !defined(_MSC_VER)
46 #define closesocket close
47 #define ioctlsocket ioctl
48 #endif /* __MINGW32__ */
49
50 /* ReactOS-specific definitions */
51 #undef CP_UNIXCP
52 #define CP_UNIXCP CP_THREAD_ACP
53
54 /* used for netconnection.c stuff */
55 typedef struct
56 {
57 BOOL useSSL;
58 int socketFD;
59 void *ssl_s;
60 } WININET_NETCONNECTION;
61
62 static inline LPWSTR heap_strdupW(LPCWSTR str)
63 {
64 LPWSTR ret = NULL;
65
66 if(str) {
67 DWORD size;
68
69 size = (strlenW(str)+1)*sizeof(WCHAR);
70 ret = HeapAlloc(GetProcessHeap(), 0, size);
71 if(ret)
72 memcpy(ret, str, size);
73 }
74
75 return ret;
76 }
77
78 static inline WCHAR *heap_strdupAtoW(const char *str)
79 {
80 LPWSTR ret = NULL;
81
82 if(str) {
83 DWORD len;
84
85 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
86 ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
87 if(ret)
88 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
89 }
90
91 return ret;
92 }
93
94 static inline char *heap_strdupWtoA(LPCWSTR str)
95 {
96 char *ret = NULL;
97
98 if(str) {
99 DWORD size = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
100 ret = HeapAlloc(GetProcessHeap(), 0, size);
101 if(ret)
102 WideCharToMultiByte(CP_ACP, 0, str, -1, ret, size, NULL, NULL);
103 }
104
105 return ret;
106 }
107
108 static inline void WININET_find_data_WtoA(LPWIN32_FIND_DATAW dataW, LPWIN32_FIND_DATAA dataA)
109 {
110 dataA->dwFileAttributes = dataW->dwFileAttributes;
111 dataA->ftCreationTime = dataW->ftCreationTime;
112 dataA->ftLastAccessTime = dataW->ftLastAccessTime;
113 dataA->ftLastWriteTime = dataW->ftLastWriteTime;
114 dataA->nFileSizeHigh = dataW->nFileSizeHigh;
115 dataA->nFileSizeLow = dataW->nFileSizeLow;
116 dataA->dwReserved0 = dataW->dwReserved0;
117 dataA->dwReserved1 = dataW->dwReserved1;
118 WideCharToMultiByte(CP_ACP, 0, dataW->cFileName, -1,
119 dataA->cFileName, sizeof(dataA->cFileName),
120 NULL, NULL);
121 WideCharToMultiByte(CP_ACP, 0, dataW->cAlternateFileName, -1,
122 dataA->cAlternateFileName, sizeof(dataA->cAlternateFileName),
123 NULL, NULL);
124 }
125
126 typedef enum
127 {
128 WH_HINIT = INTERNET_HANDLE_TYPE_INTERNET,
129 WH_HFTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_FTP,
130 WH_HGOPHERSESSION = INTERNET_HANDLE_TYPE_CONNECT_GOPHER,
131 WH_HHTTPSESSION = INTERNET_HANDLE_TYPE_CONNECT_HTTP,
132 WH_HFILE = INTERNET_HANDLE_TYPE_FTP_FILE,
133 WH_HFTPFINDNEXT = INTERNET_HANDLE_TYPE_FTP_FIND,
134 WH_HHTTPREQ = INTERNET_HANDLE_TYPE_HTTP_REQUEST,
135 } WH_TYPE;
136
137 #define INET_OPENURL 0x0001
138 #define INET_CALLBACKW 0x0002
139
140 typedef struct _object_header_t object_header_t;
141
142 typedef struct {
143 void (*Destroy)(object_header_t*);
144 void (*CloseConnection)(object_header_t*);
145 DWORD (*QueryOption)(object_header_t*,DWORD,void*,DWORD*,BOOL);
146 DWORD (*SetOption)(object_header_t*,DWORD,void*,DWORD);
147 DWORD (*ReadFile)(object_header_t*,void*,DWORD,DWORD*);
148 DWORD (*ReadFileExA)(object_header_t*,INTERNET_BUFFERSA*,DWORD,DWORD_PTR);
149 DWORD (*ReadFileExW)(object_header_t*,INTERNET_BUFFERSW*,DWORD,DWORD_PTR);
150 DWORD (*WriteFile)(object_header_t*,const void*,DWORD,DWORD*);
151 DWORD (*QueryDataAvailable)(object_header_t*,DWORD*,DWORD,DWORD_PTR);
152 DWORD (*FindNextFileW)(object_header_t*,void*);
153 } object_vtbl_t;
154
155 struct _object_header_t
156 {
157 WH_TYPE htype;
158 const object_vtbl_t *vtbl;
159 HINTERNET hInternet;
160 DWORD dwFlags;
161 DWORD_PTR dwContext;
162 DWORD dwError;
163 DWORD dwInternalFlags;
164 LONG refs;
165 INTERNET_STATUS_CALLBACK lpfnStatusCB;
166 struct list entry;
167 struct list children;
168 };
169
170
171 typedef struct
172 {
173 object_header_t hdr;
174 LPWSTR lpszAgent;
175 LPWSTR lpszProxy;
176 LPWSTR lpszProxyBypass;
177 LPWSTR lpszProxyUsername;
178 LPWSTR lpszProxyPassword;
179 DWORD dwAccessType;
180 } appinfo_t;
181
182
183 typedef struct
184 {
185 object_header_t hdr;
186 appinfo_t *lpAppInfo;
187 LPWSTR lpszHostName; /* the final destination of the request */
188 LPWSTR lpszServerName; /* the name of the server we directly connect to */
189 LPWSTR lpszUserName;
190 LPWSTR lpszPassword;
191 INTERNET_PORT nHostPort; /* the final destination port of the request */
192 INTERNET_PORT nServerPort; /* the port of the server we directly connect to */
193 struct sockaddr_storage socketAddress;
194 socklen_t sa_len;
195 } http_session_t;
196
197 #define HDR_ISREQUEST 0x0001
198 #define HDR_COMMADELIMITED 0x0002
199 #define HDR_SEMIDELIMITED 0x0004
200
201 typedef struct
202 {
203 LPWSTR lpszField;
204 LPWSTR lpszValue;
205 WORD wFlags;
206 WORD wCount;
207 } HTTPHEADERW, *LPHTTPHEADERW;
208
209
210 struct HttpAuthInfo;
211
212 typedef struct gzip_stream_t gzip_stream_t;
213
214 typedef struct
215 {
216 object_header_t hdr;
217 http_session_t *lpHttpSession;
218 LPWSTR lpszPath;
219 LPWSTR lpszVerb;
220 LPWSTR lpszRawHeaders;
221 WININET_NETCONNECTION netConnection;
222 LPWSTR lpszVersion;
223 LPWSTR lpszStatusText;
224 DWORD dwBytesToWrite;
225 DWORD dwBytesWritten;
226 HTTPHEADERW *pCustHeaders;
227 DWORD nCustHeaders;
228 HANDLE hCacheFile;
229 LPWSTR lpszCacheFile;
230 struct HttpAuthInfo *pAuthInfo;
231 struct HttpAuthInfo *pProxyAuthInfo;
232
233 CRITICAL_SECTION read_section; /* section to protect the following fields */
234 DWORD dwContentLength; /* total number of bytes to be read */
235 DWORD dwContentRead; /* bytes of the content read so far */
236 BOOL read_chunked; /* are we reading in chunked mode? */
237 DWORD read_pos; /* current read position in read_buf */
238 DWORD read_size; /* valid data size in read_buf */
239 BYTE read_buf[4096]; /* buffer for already read but not returned data */
240
241 BOOL decoding;
242 gzip_stream_t *gzip_stream;
243 } http_request_t;
244
245
246
247 struct WORKREQ_FTPPUTFILEW
248 {
249 LPWSTR lpszLocalFile;
250 LPWSTR lpszNewRemoteFile;
251 DWORD dwFlags;
252 DWORD_PTR dwContext;
253 };
254
255 struct WORKREQ_FTPSETCURRENTDIRECTORYW
256 {
257 LPWSTR lpszDirectory;
258 };
259
260 struct WORKREQ_FTPCREATEDIRECTORYW
261 {
262 LPWSTR lpszDirectory;
263 };
264
265 struct WORKREQ_FTPFINDFIRSTFILEW
266 {
267 LPWSTR lpszSearchFile;
268 LPWIN32_FIND_DATAW lpFindFileData;
269 DWORD dwFlags;
270 DWORD_PTR dwContext;
271 };
272
273 struct WORKREQ_FTPGETCURRENTDIRECTORYW
274 {
275 LPWSTR lpszDirectory;
276 DWORD *lpdwDirectory;
277 };
278
279 struct WORKREQ_FTPOPENFILEW
280 {
281 LPWSTR lpszFilename;
282 DWORD dwAccess;
283 DWORD dwFlags;
284 DWORD_PTR dwContext;
285 };
286
287 struct WORKREQ_FTPGETFILEW
288 {
289 LPWSTR lpszRemoteFile;
290 LPWSTR lpszNewFile;
291 BOOL fFailIfExists;
292 DWORD dwLocalFlagsAttribute;
293 DWORD dwFlags;
294 DWORD_PTR dwContext;
295 };
296
297 struct WORKREQ_FTPDELETEFILEW
298 {
299 LPWSTR lpszFilename;
300 };
301
302 struct WORKREQ_FTPREMOVEDIRECTORYW
303 {
304 LPWSTR lpszDirectory;
305 };
306
307 struct WORKREQ_FTPRENAMEFILEW
308 {
309 LPWSTR lpszSrcFile;
310 LPWSTR lpszDestFile;
311 };
312
313 struct WORKREQ_FTPFINDNEXTW
314 {
315 LPWIN32_FIND_DATAW lpFindFileData;
316 };
317
318 struct WORKREQ_HTTPSENDREQUESTW
319 {
320 LPWSTR lpszHeader;
321 DWORD dwHeaderLength;
322 LPVOID lpOptional;
323 DWORD dwOptionalLength;
324 DWORD dwContentLength;
325 BOOL bEndRequest;
326 };
327
328 struct WORKREQ_HTTPENDREQUESTW
329 {
330 DWORD dwFlags;
331 DWORD_PTR dwContext;
332 };
333
334 struct WORKREQ_SENDCALLBACK
335 {
336 DWORD_PTR dwContext;
337 DWORD dwInternetStatus;
338 LPVOID lpvStatusInfo;
339 DWORD dwStatusInfoLength;
340 };
341
342 struct WORKREQ_INTERNETOPENURLW
343 {
344 HINTERNET hInternet;
345 LPWSTR lpszUrl;
346 LPWSTR lpszHeaders;
347 DWORD dwHeadersLength;
348 DWORD dwFlags;
349 DWORD_PTR dwContext;
350 };
351
352 struct WORKREQ_INTERNETREADFILEEXA
353 {
354 LPINTERNET_BUFFERSA lpBuffersOut;
355 };
356
357 struct WORKREQ_INTERNETREADFILEEXW
358 {
359 LPINTERNET_BUFFERSW lpBuffersOut;
360 };
361
362 typedef struct WORKREQ
363 {
364 void (*asyncproc)(struct WORKREQ*);
365 object_header_t *hdr;
366
367 union {
368 struct WORKREQ_FTPPUTFILEW FtpPutFileW;
369 struct WORKREQ_FTPSETCURRENTDIRECTORYW FtpSetCurrentDirectoryW;
370 struct WORKREQ_FTPCREATEDIRECTORYW FtpCreateDirectoryW;
371 struct WORKREQ_FTPFINDFIRSTFILEW FtpFindFirstFileW;
372 struct WORKREQ_FTPGETCURRENTDIRECTORYW FtpGetCurrentDirectoryW;
373 struct WORKREQ_FTPOPENFILEW FtpOpenFileW;
374 struct WORKREQ_FTPGETFILEW FtpGetFileW;
375 struct WORKREQ_FTPDELETEFILEW FtpDeleteFileW;
376 struct WORKREQ_FTPREMOVEDIRECTORYW FtpRemoveDirectoryW;
377 struct WORKREQ_FTPRENAMEFILEW FtpRenameFileW;
378 struct WORKREQ_FTPFINDNEXTW FtpFindNextW;
379 struct WORKREQ_HTTPSENDREQUESTW HttpSendRequestW;
380 struct WORKREQ_HTTPENDREQUESTW HttpEndRequestW;
381 struct WORKREQ_SENDCALLBACK SendCallback;
382 struct WORKREQ_INTERNETOPENURLW InternetOpenUrlW;
383 struct WORKREQ_INTERNETREADFILEEXA InternetReadFileExA;
384 struct WORKREQ_INTERNETREADFILEEXW InternetReadFileExW;
385 } u;
386
387 } WORKREQUEST, *LPWORKREQUEST;
388
389 HINTERNET WININET_AllocHandle( object_header_t *info );
390 object_header_t *WININET_GetObject( HINTERNET hinternet );
391 object_header_t *WININET_AddRef( object_header_t *info );
392 BOOL WININET_Release( object_header_t *info );
393 BOOL WININET_FreeHandle( HINTERNET hinternet );
394
395 DWORD INET_QueryOption(DWORD,void*,DWORD*,BOOL);
396
397 time_t ConvertTimeString(LPCWSTR asctime);
398
399 HINTERNET FTP_Connect(appinfo_t *hIC, LPCWSTR lpszServerName,
400 INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
401 LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
402 DWORD dwInternalFlags);
403
404 DWORD HTTP_Connect(appinfo_t*,LPCWSTR,
405 INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
406 LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
407 DWORD dwInternalFlags, HINTERNET*);
408
409 BOOL GetAddress(LPCWSTR lpszServerName, INTERNET_PORT nServerPort,
410 struct sockaddr *psa, socklen_t *sa_len);
411
412 void INTERNET_SetLastError(DWORD dwError);
413 DWORD INTERNET_GetLastError(void);
414 DWORD INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest);
415 LPSTR INTERNET_GetResponseBuffer(void);
416 LPSTR INTERNET_GetNextLine(INT nSocket, LPDWORD dwLen);
417
418 VOID SendAsyncCallback(object_header_t *hdr, DWORD_PTR dwContext,
419 DWORD dwInternetStatus, LPVOID lpvStatusInfo,
420 DWORD dwStatusInfoLength);
421
422 VOID INTERNET_SendCallback(object_header_t *hdr, DWORD_PTR dwContext,
423 DWORD dwInternetStatus, LPVOID lpvStatusInfo,
424 DWORD dwStatusInfoLength);
425 BOOL INTERNET_FindProxyForProtocol(LPCWSTR szProxy, LPCWSTR proto, WCHAR *foundProxy, DWORD *foundProxyLen);
426
427 BOOL NETCON_connected(WININET_NETCONNECTION *connection);
428 DWORD NETCON_init(WININET_NETCONNECTION *connnection, BOOL useSSL);
429 void NETCON_unload(void);
430 DWORD NETCON_create(WININET_NETCONNECTION *connection, int domain,
431 int type, int protocol);
432 DWORD NETCON_close(WININET_NETCONNECTION *connection);
433 DWORD NETCON_connect(WININET_NETCONNECTION *connection, const struct sockaddr *serv_addr,
434 unsigned int addrlen);
435 DWORD NETCON_secure_connect(WININET_NETCONNECTION *connection, LPWSTR hostname);
436 DWORD NETCON_send(WININET_NETCONNECTION *connection, const void *msg, size_t len, int flags,
437 int *sent /* out */);
438 DWORD NETCON_recv(WININET_NETCONNECTION *connection, void *buf, size_t len, int flags,
439 int *recvd /* out */);
440 BOOL NETCON_query_data_available(WININET_NETCONNECTION *connection, DWORD *available);
441 LPCVOID NETCON_GetCert(WININET_NETCONNECTION *connection);
442 DWORD NETCON_set_timeout(WININET_NETCONNECTION *connection, BOOL send, int value);
443 int sock_get_error(int);
444
445 extern void URLCacheContainers_CreateDefaults(void);
446 extern void URLCacheContainers_DeleteAll(void);
447
448 #define MAX_REPLY_LEN 0x5B4
449
450 /* Used for debugging - maybe need to be shared in the Wine debugging code ? */
451 typedef struct
452 {
453 DWORD val;
454 const char* name;
455 } wininet_flag_info;
456
457 #endif /* _WINE_INTERNET_H_ */