include: Add definition of IKsControl interface in dmksctrl.h.
[wine] / dlls / urlmon / protocol.c
1 /*
2  * Copyright 2007 Misha Koshelev
3  * Copyright 2009 Jacek Caban for CodeWeavers
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19
20 #include "urlmon_main.h"
21
22 #include "wine/debug.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
25
26 static inline HRESULT report_progress(Protocol *protocol, ULONG status_code, LPCWSTR status_text)
27 {
28     return IInternetProtocolSink_ReportProgress(protocol->protocol_sink, status_code, status_text);
29 }
30
31 static inline HRESULT report_result(Protocol *protocol, HRESULT hres)
32 {
33     if (!(protocol->flags & FLAG_RESULT_REPORTED) && protocol->protocol_sink) {
34         protocol->flags |= FLAG_RESULT_REPORTED;
35         IInternetProtocolSink_ReportResult(protocol->protocol_sink, hres, 0, NULL);
36     }
37
38     return hres;
39 }
40
41 static void report_data(Protocol *protocol)
42 {
43     DWORD bscf;
44
45     if((protocol->flags & FLAG_LAST_DATA_REPORTED) || !protocol->protocol_sink)
46         return;
47
48     if(protocol->flags & FLAG_FIRST_DATA_REPORTED) {
49         bscf = BSCF_INTERMEDIATEDATANOTIFICATION;
50     }else {
51         protocol->flags |= FLAG_FIRST_DATA_REPORTED;
52         bscf = BSCF_FIRSTDATANOTIFICATION;
53     }
54
55     if(protocol->flags & FLAG_ALL_DATA_READ && !(protocol->flags & FLAG_LAST_DATA_REPORTED)) {
56         protocol->flags |= FLAG_LAST_DATA_REPORTED;
57         bscf |= BSCF_LASTDATANOTIFICATION;
58     }
59
60     IInternetProtocolSink_ReportData(protocol->protocol_sink, bscf,
61             protocol->current_position+protocol->available_bytes,
62             protocol->content_length);
63 }
64
65 static void all_data_read(Protocol *protocol)
66 {
67     protocol->flags |= FLAG_ALL_DATA_READ;
68
69     report_data(protocol);
70     report_result(protocol, S_OK);
71 }
72
73 static void request_complete(Protocol *protocol, INTERNET_ASYNC_RESULT *ar)
74 {
75     PROTOCOLDATA data;
76
77     TRACE("(%p)->(%p)\n", protocol, ar);
78
79     /* PROTOCOLDATA same as native */
80     memset(&data, 0, sizeof(data));
81     data.dwState = 0xf1000000;
82
83     if(ar->dwResult) {
84         protocol->flags |= FLAG_REQUEST_COMPLETE;
85
86         if(!protocol->request) {
87             TRACE("setting request handle %p\n", (HINTERNET)ar->dwResult);
88             protocol->request = (HINTERNET)ar->dwResult;
89         }
90
91         if(protocol->flags & FLAG_FIRST_CONTINUE_COMPLETE)
92             data.pData = UlongToPtr(BINDSTATUS_ENDDOWNLOADCOMPONENTS);
93         else
94             data.pData = UlongToPtr(BINDSTATUS_DOWNLOADINGDATA);
95
96     }else {
97         protocol->flags |= FLAG_ERROR;
98         data.pData = UlongToPtr(ar->dwError);
99     }
100
101     if (protocol->bindf & BINDF_FROMURLMON)
102         IInternetProtocolSink_Switch(protocol->protocol_sink, &data);
103     else
104         protocol_continue(protocol, &data);
105 }
106
107 static void WINAPI internet_status_callback(HINTERNET internet, DWORD_PTR context,
108         DWORD internet_status, LPVOID status_info, DWORD status_info_len)
109 {
110     Protocol *protocol = (Protocol*)context;
111
112     switch(internet_status) {
113     case INTERNET_STATUS_RESOLVING_NAME:
114         TRACE("%p INTERNET_STATUS_RESOLVING_NAME\n", protocol);
115         report_progress(protocol, BINDSTATUS_FINDINGRESOURCE, (LPWSTR)status_info);
116         break;
117
118     case INTERNET_STATUS_CONNECTING_TO_SERVER:
119         TRACE("%p INTERNET_STATUS_CONNECTING_TO_SERVER\n", protocol);
120         report_progress(protocol, BINDSTATUS_CONNECTING, (LPWSTR)status_info);
121         break;
122
123     case INTERNET_STATUS_SENDING_REQUEST:
124         TRACE("%p INTERNET_STATUS_SENDING_REQUEST\n", protocol);
125         report_progress(protocol, BINDSTATUS_SENDINGREQUEST, (LPWSTR)status_info);
126         break;
127
128     case INTERNET_STATUS_REDIRECT:
129         TRACE("%p INTERNET_STATUS_REDIRECT\n", protocol);
130         report_progress(protocol, BINDSTATUS_REDIRECTING, (LPWSTR)status_info);
131         break;
132
133     case INTERNET_STATUS_REQUEST_COMPLETE:
134         request_complete(protocol, status_info);
135         break;
136
137     case INTERNET_STATUS_HANDLE_CREATED:
138         TRACE("%p INTERNET_STATUS_HANDLE_CREATED\n", protocol);
139         IInternetProtocol_AddRef(protocol->protocol);
140         break;
141
142     case INTERNET_STATUS_HANDLE_CLOSING:
143         TRACE("%p INTERNET_STATUS_HANDLE_CLOSING\n", protocol);
144
145         if(*(HINTERNET *)status_info == protocol->request) {
146             protocol->request = NULL;
147             if(protocol->protocol_sink) {
148                 IInternetProtocolSink_Release(protocol->protocol_sink);
149                 protocol->protocol_sink = NULL;
150             }
151
152             if(protocol->bind_info.cbSize) {
153                 ReleaseBindInfo(&protocol->bind_info);
154                 memset(&protocol->bind_info, 0, sizeof(protocol->bind_info));
155             }
156         }else if(*(HINTERNET *)status_info == protocol->connection) {
157             protocol->connection = NULL;
158         }
159
160         IInternetProtocol_Release(protocol->protocol);
161         break;
162
163     default:
164         WARN("Unhandled Internet status callback %d\n", internet_status);
165     }
166 }
167
168 static HRESULT write_post_stream(Protocol *protocol)
169 {
170     BYTE buf[0x20000];
171     DWORD written;
172     ULONG size;
173     BOOL res;
174     HRESULT hres;
175
176     protocol->flags &= ~FLAG_REQUEST_COMPLETE;
177
178     while(1) {
179         size = 0;
180         hres = IStream_Read(protocol->post_stream, buf, sizeof(buf), &size);
181         if(FAILED(hres) || !size)
182             break;
183         res = InternetWriteFile(protocol->request, buf, size, &written);
184         if(!res) {
185             FIXME("InternetWriteFile failed: %u\n", GetLastError());
186             hres = E_FAIL;
187             break;
188         }
189     }
190
191     if(SUCCEEDED(hres)) {
192         IStream_Release(protocol->post_stream);
193         protocol->post_stream = NULL;
194
195         hres = protocol->vtbl->end_request(protocol);
196     }
197
198     if(FAILED(hres))
199         return report_result(protocol, hres);
200
201     return S_OK;
202 }
203
204 static HINTERNET create_internet_session(IInternetBindInfo *bind_info)
205 {
206     LPWSTR global_user_agent = NULL;
207     LPOLESTR user_agent = NULL;
208     ULONG size = 0;
209     HINTERNET ret;
210     HRESULT hres;
211
212     hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_USER_AGENT, &user_agent, 1, &size);
213     if(hres != S_OK || !size)
214         global_user_agent = get_useragent();
215
216     ret = InternetOpenW(user_agent ? user_agent : global_user_agent, 0, NULL, NULL, INTERNET_FLAG_ASYNC);
217     heap_free(global_user_agent);
218     CoTaskMemFree(user_agent);
219     if(!ret) {
220         WARN("InternetOpen failed: %d\n", GetLastError());
221         return NULL;
222     }
223
224     InternetSetStatusCallbackW(ret, internet_status_callback);
225     return ret;
226 }
227
228 static HINTERNET internet_session;
229
230 HINTERNET get_internet_session(IInternetBindInfo *bind_info)
231 {
232     HINTERNET new_session;
233
234     if(internet_session)
235         return internet_session;
236
237     if(!bind_info)
238         return NULL;
239
240     new_session = create_internet_session(bind_info);
241     if(new_session && InterlockedCompareExchangePointer((void**)&internet_session, new_session, NULL))
242         InternetCloseHandle(new_session);
243
244     return internet_session;
245 }
246
247 HRESULT protocol_start(Protocol *protocol, IInternetProtocol *prot, IUri *uri,
248         IInternetProtocolSink *protocol_sink, IInternetBindInfo *bind_info)
249 {
250     DWORD request_flags;
251     HRESULT hres;
252
253     protocol->protocol = prot;
254
255     IInternetProtocolSink_AddRef(protocol_sink);
256     protocol->protocol_sink = protocol_sink;
257
258     memset(&protocol->bind_info, 0, sizeof(protocol->bind_info));
259     protocol->bind_info.cbSize = sizeof(BINDINFO);
260     hres = IInternetBindInfo_GetBindInfo(bind_info, &protocol->bindf, &protocol->bind_info);
261     if(hres != S_OK) {
262         WARN("GetBindInfo failed: %08x\n", hres);
263         return report_result(protocol, hres);
264     }
265
266     if(!(protocol->bindf & BINDF_FROMURLMON))
267         report_progress(protocol, BINDSTATUS_DIRECTBIND, NULL);
268
269     if(!get_internet_session(bind_info))
270         return report_result(protocol, INET_E_NO_SESSION);
271
272     request_flags = INTERNET_FLAG_KEEP_CONNECTION;
273     if(protocol->bindf & BINDF_NOWRITECACHE)
274         request_flags |= INTERNET_FLAG_NO_CACHE_WRITE;
275     if(protocol->bindf & BINDF_NEEDFILE)
276         request_flags |= INTERNET_FLAG_NEED_FILE;
277
278     hres = protocol->vtbl->open_request(protocol, uri, request_flags, internet_session, bind_info);
279     if(FAILED(hres)) {
280         protocol_close_connection(protocol);
281         return report_result(protocol, hres);
282     }
283
284     return S_OK;
285 }
286
287 HRESULT protocol_continue(Protocol *protocol, PROTOCOLDATA *data)
288 {
289     BOOL is_start;
290     HRESULT hres;
291
292     if (!data) {
293         WARN("Expected pProtocolData to be non-NULL\n");
294         return S_OK;
295     }
296
297     is_start = data->pData == UlongToPtr(BINDSTATUS_DOWNLOADINGDATA);
298
299     if(!protocol->request) {
300         WARN("Expected request to be non-NULL\n");
301         return S_OK;
302     }
303
304     if(!protocol->protocol_sink) {
305         WARN("Expected IInternetProtocolSink pointer to be non-NULL\n");
306         return S_OK;
307     }
308
309     if(protocol->flags & FLAG_ERROR) {
310         protocol->flags &= ~FLAG_ERROR;
311         protocol->vtbl->on_error(protocol, PtrToUlong(data->pData));
312         return S_OK;
313     }
314
315     if(protocol->post_stream)
316         return write_post_stream(protocol);
317
318     if(is_start) {
319         hres = protocol->vtbl->start_downloading(protocol);
320         if(FAILED(hres)) {
321             protocol_close_connection(protocol);
322             report_result(protocol, hres);
323             return S_OK;
324         }
325
326         if(protocol->bindf & BINDF_NEEDFILE) {
327             WCHAR cache_file[MAX_PATH];
328             DWORD buflen = sizeof(cache_file);
329
330             if(InternetQueryOptionW(protocol->request, INTERNET_OPTION_DATAFILE_NAME,
331                     cache_file, &buflen)) {
332                 report_progress(protocol, BINDSTATUS_CACHEFILENAMEAVAILABLE, cache_file);
333             }else {
334                 FIXME("Could not get cache file\n");
335             }
336         }
337
338         protocol->flags |= FLAG_FIRST_CONTINUE_COMPLETE;
339     }
340
341     if(data->pData >= UlongToPtr(BINDSTATUS_DOWNLOADINGDATA) && !protocol->available_bytes) {
342         BOOL res;
343
344         /* InternetQueryDataAvailable may immediately fork and perform its asynchronous
345          * read, so clear the flag _before_ calling so it does not incorrectly get cleared
346          * after the status callback is called */
347         protocol->flags &= ~FLAG_REQUEST_COMPLETE;
348         res = InternetQueryDataAvailable(protocol->request, &protocol->available_bytes, 0, 0);
349         if(res) {
350             if(!protocol->available_bytes) {
351                 if(is_start) {
352                     TRACE("empty file\n");
353                     all_data_read(protocol);
354                 }else {
355                     WARN("unexpected end of file?\n");
356                     report_result(protocol, INET_E_DOWNLOAD_FAILURE);
357                 }
358                 return S_OK;
359             }
360             protocol->flags |= FLAG_REQUEST_COMPLETE;
361             report_data(protocol);
362         }else if(GetLastError() != ERROR_IO_PENDING) {
363             protocol->flags |= FLAG_REQUEST_COMPLETE;
364             WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
365             report_result(protocol, INET_E_DATA_NOT_AVAILABLE);
366         }
367     }
368
369     return S_OK;
370 }
371
372 HRESULT protocol_read(Protocol *protocol, void *buf, ULONG size, ULONG *read_ret)
373 {
374     ULONG read = 0;
375     BOOL res;
376     HRESULT hres = S_FALSE;
377
378     if(protocol->flags & FLAG_ALL_DATA_READ) {
379         *read_ret = 0;
380         return S_FALSE;
381     }
382
383     if(!(protocol->flags & FLAG_REQUEST_COMPLETE) || !protocol->available_bytes) {
384         *read_ret = 0;
385         return E_PENDING;
386     }
387
388     while(read < size && protocol->available_bytes) {
389         ULONG len;
390
391         res = InternetReadFile(protocol->request, ((BYTE *)buf)+read,
392                 protocol->available_bytes > size-read ? size-read : protocol->available_bytes, &len);
393         if(!res) {
394             WARN("InternetReadFile failed: %d\n", GetLastError());
395             hres = INET_E_DOWNLOAD_FAILURE;
396             report_result(protocol, hres);
397             break;
398         }
399
400         if(!len) {
401             all_data_read(protocol);
402             break;
403         }
404
405         read += len;
406         protocol->current_position += len;
407         protocol->available_bytes -= len;
408
409         if(!protocol->available_bytes) {
410             /* InternetQueryDataAvailable may immediately fork and perform its asynchronous
411              * read, so clear the flag _before_ calling so it does not incorrectly get cleared
412              * after the status callback is called */
413             protocol->flags &= ~FLAG_REQUEST_COMPLETE;
414             res = InternetQueryDataAvailable(protocol->request, &protocol->available_bytes, 0, 0);
415             if(!res) {
416                 if (GetLastError() == ERROR_IO_PENDING) {
417                     hres = E_PENDING;
418                 }else {
419                     WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
420                     hres = INET_E_DATA_NOT_AVAILABLE;
421                     report_result(protocol, hres);
422                 }
423                 break;
424             }
425
426             if(!protocol->available_bytes) {
427                 all_data_read(protocol);
428                 break;
429             }
430         }
431     }
432
433     *read_ret = read;
434
435     if (hres != E_PENDING)
436         protocol->flags |= FLAG_REQUEST_COMPLETE;
437     if(FAILED(hres))
438         return hres;
439
440     return read ? S_OK : S_FALSE;
441 }
442
443 HRESULT protocol_lock_request(Protocol *protocol)
444 {
445     if (!InternetLockRequestFile(protocol->request, &protocol->lock))
446         WARN("InternetLockRequest failed: %d\n", GetLastError());
447
448     return S_OK;
449 }
450
451 HRESULT protocol_unlock_request(Protocol *protocol)
452 {
453     if(!protocol->lock)
454         return S_OK;
455
456     if(!InternetUnlockRequestFile(protocol->lock))
457         WARN("InternetUnlockRequest failed: %d\n", GetLastError());
458     protocol->lock = 0;
459
460     return S_OK;
461 }
462
463 HRESULT protocol_abort(Protocol *protocol, HRESULT reason)
464 {
465     if(!protocol->protocol_sink)
466         return S_OK;
467
468     if(protocol->flags & FLAG_RESULT_REPORTED)
469         return INET_E_RESULT_DISPATCHED;
470
471     report_result(protocol, reason);
472     return S_OK;
473 }
474
475 void protocol_close_connection(Protocol *protocol)
476 {
477     protocol->vtbl->close_connection(protocol);
478
479     if(protocol->request)
480         InternetCloseHandle(protocol->request);
481
482     if(protocol->connection)
483         InternetCloseHandle(protocol->connection);
484
485     if(protocol->post_stream) {
486         IStream_Release(protocol->post_stream);
487         protocol->post_stream = NULL;
488     }
489
490     protocol->flags = 0;
491 }