[URLMON]
[reactos.git] / reactos / dll / win32 / urlmon / http.c
1 /*
2 * Copyright 2005 Jacek Caban
3 * Copyright 2007 Misha Koshelev
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 typedef struct {
23 Protocol base;
24
25 IInternetProtocolEx IInternetProtocolEx_iface;
26 IInternetPriority IInternetPriority_iface;
27 IWinInetHttpInfo IWinInetHttpInfo_iface;
28
29 BOOL https;
30 IHttpNegotiate *http_negotiate;
31 WCHAR *full_header;
32
33 LONG ref;
34 } HttpProtocol;
35
36 static inline HttpProtocol *impl_from_IInternetProtocolEx(IInternetProtocolEx *iface)
37 {
38 return CONTAINING_RECORD(iface, HttpProtocol, IInternetProtocolEx_iface);
39 }
40
41 static inline HttpProtocol *impl_from_IInternetPriority(IInternetPriority *iface)
42 {
43 return CONTAINING_RECORD(iface, HttpProtocol, IInternetPriority_iface);
44 }
45
46 static inline HttpProtocol *impl_from_IWinInetHttpInfo(IWinInetHttpInfo *iface)
47 {
48 return CONTAINING_RECORD(iface, HttpProtocol, IWinInetHttpInfo_iface);
49 }
50
51 static const WCHAR default_headersW[] = {
52 'A','c','c','e','p','t','-','E','n','c','o','d','i','n','g',':',' ','g','z','i','p',',',' ','d','e','f','l','a','t','e',0};
53
54 static LPWSTR query_http_info(HttpProtocol *This, DWORD option)
55 {
56 LPWSTR ret = NULL;
57 DWORD len = 0;
58 BOOL res;
59
60 res = HttpQueryInfoW(This->base.request, option, NULL, &len, NULL);
61 if (!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
62 ret = heap_alloc(len);
63 res = HttpQueryInfoW(This->base.request, option, ret, &len, NULL);
64 }
65 if(!res) {
66 TRACE("HttpQueryInfoW(%d) failed: %08x\n", option, GetLastError());
67 heap_free(ret);
68 return NULL;
69 }
70
71 return ret;
72 }
73
74 static inline BOOL set_security_flag(HttpProtocol *This, DWORD flags)
75 {
76 BOOL res;
77
78 res = InternetSetOptionW(This->base.request, INTERNET_OPTION_SECURITY_FLAGS, &flags, sizeof(flags));
79 if(!res)
80 ERR("Failed to set security flags: %x\n", flags);
81
82 return res;
83 }
84
85 static inline HRESULT internet_error_to_hres(DWORD error)
86 {
87 switch(error)
88 {
89 case ERROR_INTERNET_SEC_CERT_DATE_INVALID:
90 case ERROR_INTERNET_SEC_CERT_CN_INVALID:
91 case ERROR_INTERNET_INVALID_CA:
92 case ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED:
93 case ERROR_INTERNET_SEC_INVALID_CERT:
94 case ERROR_INTERNET_SEC_CERT_ERRORS:
95 case ERROR_INTERNET_SEC_CERT_REV_FAILED:
96 case ERROR_INTERNET_SEC_CERT_NO_REV:
97 case ERROR_INTERNET_SEC_CERT_REVOKED:
98 return INET_E_INVALID_CERTIFICATE;
99 case ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR:
100 case ERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIR:
101 case ERROR_HTTP_REDIRECT_NEEDS_CONFIRMATION:
102 return INET_E_REDIRECT_FAILED;
103 default:
104 return INET_E_DOWNLOAD_FAILURE;
105 }
106 }
107
108 static HRESULT handle_http_error(HttpProtocol *This, DWORD error)
109 {
110 IServiceProvider *serv_prov;
111 IWindowForBindingUI *wfb_ui;
112 IHttpSecurity *http_security;
113 BOOL security_problem;
114 DWORD dlg_flags;
115 HWND hwnd;
116 DWORD res;
117 HRESULT hres;
118
119 TRACE("(%p %u)\n", This, error);
120
121 switch(error) {
122 case ERROR_INTERNET_SEC_CERT_DATE_INVALID:
123 case ERROR_INTERNET_SEC_CERT_CN_INVALID:
124 case ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR:
125 case ERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIR:
126 case ERROR_INTERNET_INVALID_CA:
127 case ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED:
128 case ERROR_INTERNET_SEC_INVALID_CERT:
129 case ERROR_INTERNET_SEC_CERT_ERRORS:
130 case ERROR_INTERNET_SEC_CERT_REV_FAILED:
131 case ERROR_INTERNET_SEC_CERT_NO_REV:
132 case ERROR_INTERNET_SEC_CERT_REVOKED:
133 case ERROR_HTTP_REDIRECT_NEEDS_CONFIRMATION:
134 security_problem = TRUE;
135 break;
136 default:
137 security_problem = FALSE;
138 }
139
140 hres = IInternetProtocolSink_QueryInterface(This->base.protocol_sink, &IID_IServiceProvider,
141 (void**)&serv_prov);
142 if(FAILED(hres)) {
143 ERR("Failed to get IServiceProvider.\n");
144 return E_ABORT;
145 }
146
147 if(security_problem) {
148 hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpSecurity, &IID_IHttpSecurity,
149 (void**)&http_security);
150 if(SUCCEEDED(hres)) {
151 hres = IHttpSecurity_OnSecurityProblem(http_security, error);
152 IHttpSecurity_Release(http_security);
153
154 TRACE("OnSecurityProblem returned %08x\n", hres);
155
156 if(hres != S_FALSE)
157 {
158 BOOL res = FALSE;
159
160 IServiceProvider_Release(serv_prov);
161
162 if(hres == S_OK) {
163 if(error == ERROR_INTERNET_SEC_CERT_DATE_INVALID)
164 res = set_security_flag(This, SECURITY_FLAG_IGNORE_CERT_DATE_INVALID);
165 else if(error == ERROR_INTERNET_SEC_CERT_CN_INVALID)
166 res = set_security_flag(This, SECURITY_FLAG_IGNORE_CERT_CN_INVALID);
167 else if(error == ERROR_INTERNET_INVALID_CA)
168 res = set_security_flag(This, SECURITY_FLAG_IGNORE_UNKNOWN_CA);
169
170 if(res)
171 return RPC_E_RETRY;
172
173 FIXME("Don't know how to ignore error %d\n", error);
174 return E_ABORT;
175 }
176
177 if(hres == E_ABORT)
178 return E_ABORT;
179 if(hres == RPC_E_RETRY)
180 return RPC_E_RETRY;
181
182 return internet_error_to_hres(error);
183 }
184 }
185 }
186
187 switch(error) {
188 case ERROR_INTERNET_SEC_CERT_REV_FAILED:
189 if(hres != S_FALSE) {
190 /* Silently ignore the error. We will get more detailed error from wininet anyway. */
191 set_security_flag(This, SECURITY_FLAG_IGNORE_REVOCATION);
192 hres = RPC_E_RETRY;
193 break;
194 }
195 /* fallthrough */
196 default:
197 hres = IServiceProvider_QueryService(serv_prov, &IID_IWindowForBindingUI, &IID_IWindowForBindingUI, (void**)&wfb_ui);
198 if(SUCCEEDED(hres)) {
199 const IID *iid_reason;
200
201 if(security_problem)
202 iid_reason = &IID_IHttpSecurity;
203 else if(error == ERROR_INTERNET_INCORRECT_PASSWORD)
204 iid_reason = &IID_IAuthenticate;
205 else
206 iid_reason = &IID_IWindowForBindingUI;
207
208 hres = IWindowForBindingUI_GetWindow(wfb_ui, iid_reason, &hwnd);
209 IWindowForBindingUI_Release(wfb_ui);
210 }
211
212 if(FAILED(hres)) hwnd = NULL;
213
214 dlg_flags = FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS | FLAGS_ERROR_UI_FLAGS_GENERATE_DATA;
215 if(This->base.bindf & BINDF_NO_UI)
216 dlg_flags |= FLAGS_ERROR_UI_FLAGS_NO_UI;
217
218 res = InternetErrorDlg(hwnd, This->base.request, error, dlg_flags, NULL);
219 hres = res == ERROR_INTERNET_FORCE_RETRY || res == ERROR_SUCCESS ? RPC_E_RETRY : internet_error_to_hres(error);
220 }
221
222 IServiceProvider_Release(serv_prov);
223 return hres;
224 }
225
226 static ULONG send_http_request(HttpProtocol *This)
227 {
228 INTERNET_BUFFERSW send_buffer = {sizeof(INTERNET_BUFFERSW)};
229 BOOL res;
230
231 send_buffer.lpcszHeader = This->full_header;
232 send_buffer.dwHeadersLength = send_buffer.dwHeadersTotal = strlenW(This->full_header);
233
234 if(This->base.bind_info.dwBindVerb != BINDVERB_GET) {
235 switch(This->base.bind_info.stgmedData.tymed) {
236 case TYMED_HGLOBAL:
237 /* Native does not use GlobalLock/GlobalUnlock, so we won't either */
238 send_buffer.lpvBuffer = This->base.bind_info.stgmedData.u.hGlobal;
239 send_buffer.dwBufferLength = send_buffer.dwBufferTotal = This->base.bind_info.cbstgmedData;
240 break;
241 case TYMED_ISTREAM: {
242 LARGE_INTEGER offset;
243
244 send_buffer.dwBufferTotal = This->base.bind_info.cbstgmedData;
245 if(!This->base.post_stream) {
246 This->base.post_stream = This->base.bind_info.stgmedData.u.pstm;
247 IStream_AddRef(This->base.post_stream);
248 }
249
250 offset.QuadPart = 0;
251 IStream_Seek(This->base.post_stream, offset, STREAM_SEEK_SET, NULL);
252 break;
253 }
254 default:
255 FIXME("Unsupported This->base.bind_info.stgmedData.tymed %d\n", This->base.bind_info.stgmedData.tymed);
256 }
257 }
258
259 if(This->base.post_stream)
260 res = HttpSendRequestExW(This->base.request, &send_buffer, NULL, 0, 0);
261 else
262 res = HttpSendRequestW(This->base.request, send_buffer.lpcszHeader, send_buffer.dwHeadersLength,
263 send_buffer.lpvBuffer, send_buffer.dwBufferLength);
264
265 return res ? 0 : GetLastError();
266 }
267
268 static inline HttpProtocol *impl_from_Protocol(Protocol *prot)
269 {
270 return CONTAINING_RECORD(prot, HttpProtocol, base);
271 }
272
273 static HRESULT HttpProtocol_open_request(Protocol *prot, IUri *uri, DWORD request_flags,
274 HINTERNET internet_session, IInternetBindInfo *bind_info)
275 {
276 HttpProtocol *This = impl_from_Protocol(prot);
277 WCHAR *addl_header = NULL, *post_cookie = NULL, *rootdoc_url = NULL;
278 IServiceProvider *service_provider = NULL;
279 IHttpNegotiate2 *http_negotiate2 = NULL;
280 BSTR url, host, user, pass, path;
281 LPOLESTR accept_mimes[257];
282 const WCHAR **accept_types;
283 BYTE security_id[512];
284 DWORD len, port, flags;
285 ULONG num, error;
286 BOOL res, b;
287 HRESULT hres;
288
289 static const WCHAR wszBindVerb[BINDVERB_CUSTOM][5] =
290 {{'G','E','T',0},
291 {'P','O','S','T',0},
292 {'P','U','T',0}};
293
294 hres = IUri_GetPort(uri, &port);
295 if(FAILED(hres))
296 return hres;
297
298 hres = IUri_GetHost(uri, &host);
299 if(FAILED(hres))
300 return hres;
301
302 hres = IUri_GetUserName(uri, &user);
303 if(SUCCEEDED(hres)) {
304 hres = IUri_GetPassword(uri, &pass);
305
306 if(SUCCEEDED(hres)) {
307 This->base.connection = InternetConnectW(internet_session, host, port, user, pass,
308 INTERNET_SERVICE_HTTP, This->https ? INTERNET_FLAG_SECURE : 0, (DWORD_PTR)&This->base);
309 SysFreeString(pass);
310 }
311 SysFreeString(user);
312 }
313 SysFreeString(host);
314 if(FAILED(hres))
315 return hres;
316 if(!This->base.connection) {
317 WARN("InternetConnect failed: %d\n", GetLastError());
318 return INET_E_CANNOT_CONNECT;
319 }
320
321 num = 0;
322 hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_ROOTDOC_URL, &rootdoc_url, 1, &num);
323 if(hres == S_OK && num) {
324 FIXME("Use root doc URL %s\n", debugstr_w(rootdoc_url));
325 CoTaskMemFree(rootdoc_url);
326 }
327
328 num = sizeof(accept_mimes)/sizeof(accept_mimes[0])-1;
329 hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_ACCEPT_MIMES, accept_mimes, num, &num);
330 if(hres == INET_E_USE_DEFAULT_SETTING) {
331 static const WCHAR default_accept_mimeW[] = {'*','/','*',0};
332 static const WCHAR *default_accept_mimes[] = {default_accept_mimeW, NULL};
333
334 accept_types = default_accept_mimes;
335 num = 0;
336 }else if(hres == S_OK) {
337 accept_types = (const WCHAR**)accept_mimes;
338 }else {
339 WARN("GetBindString BINDSTRING_ACCEPT_MIMES failed: %08x\n", hres);
340 return INET_E_NO_VALID_MEDIA;
341 }
342 accept_mimes[num] = 0;
343
344 if(This->https)
345 request_flags |= INTERNET_FLAG_SECURE;
346
347 hres = IUri_GetPathAndQuery(uri, &path);
348 if(SUCCEEDED(hres)) {
349 This->base.request = HttpOpenRequestW(This->base.connection,
350 This->base.bind_info.dwBindVerb < BINDVERB_CUSTOM
351 ? wszBindVerb[This->base.bind_info.dwBindVerb] : This->base.bind_info.szCustomVerb,
352 path, NULL, NULL, accept_types, request_flags, (DWORD_PTR)&This->base);
353 SysFreeString(path);
354 }
355 while(num--)
356 CoTaskMemFree(accept_mimes[num]);
357 if(FAILED(hres))
358 return hres;
359 if (!This->base.request) {
360 WARN("HttpOpenRequest failed: %d\n", GetLastError());
361 return INET_E_RESOURCE_NOT_FOUND;
362 }
363
364 hres = IInternetProtocolSink_QueryInterface(This->base.protocol_sink, &IID_IServiceProvider,
365 (void **)&service_provider);
366 if (hres != S_OK) {
367 WARN("IInternetProtocolSink_QueryInterface IID_IServiceProvider failed: %08x\n", hres);
368 return hres;
369 }
370
371 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
372 &IID_IHttpNegotiate, (void **)&This->http_negotiate);
373 if (hres != S_OK) {
374 WARN("IServiceProvider_QueryService IID_IHttpNegotiate failed: %08x\n", hres);
375 IServiceProvider_Release(service_provider);
376 return hres;
377 }
378
379 hres = IUri_GetAbsoluteUri(uri, &url);
380 if(FAILED(hres)) {
381 IServiceProvider_Release(service_provider);
382 return hres;
383 }
384
385 hres = IHttpNegotiate_BeginningTransaction(This->http_negotiate, url, default_headersW,
386 0, &addl_header);
387 SysFreeString(url);
388 if(hres != S_OK) {
389 WARN("IHttpNegotiate_BeginningTransaction failed: %08x\n", hres);
390 IServiceProvider_Release(service_provider);
391 return hres;
392 }
393
394 len = addl_header ? strlenW(addl_header) : 0;
395
396 This->full_header = heap_alloc(len*sizeof(WCHAR)+sizeof(default_headersW));
397 if(!This->full_header) {
398 IServiceProvider_Release(service_provider);
399 return E_OUTOFMEMORY;
400 }
401
402 if(len)
403 memcpy(This->full_header, addl_header, len*sizeof(WCHAR));
404 CoTaskMemFree(addl_header);
405 memcpy(This->full_header+len, default_headersW, sizeof(default_headersW));
406
407 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate2,
408 &IID_IHttpNegotiate2, (void **)&http_negotiate2);
409 IServiceProvider_Release(service_provider);
410 if(hres != S_OK) {
411 WARN("IServiceProvider_QueryService IID_IHttpNegotiate2 failed: %08x\n", hres);
412 /* No goto done as per native */
413 }else {
414 len = sizeof(security_id)/sizeof(security_id[0]);
415 hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, security_id, &len, 0);
416 IHttpNegotiate2_Release(http_negotiate2);
417 if (hres != S_OK)
418 WARN("IHttpNegotiate2_GetRootSecurityId failed: %08x\n", hres);
419 }
420
421 /* FIXME: Handle security_id. Native calls undocumented function IsHostInProxyBypassList. */
422
423 if(This->base.bind_info.dwBindVerb == BINDVERB_POST) {
424 num = 0;
425 hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_POST_COOKIE, &post_cookie, 1, &num);
426 if(hres == S_OK && num) {
427 if(!InternetSetOptionW(This->base.request, INTERNET_OPTION_SECONDARY_CACHE_KEY,
428 post_cookie, lstrlenW(post_cookie)))
429 WARN("InternetSetOption INTERNET_OPTION_SECONDARY_CACHE_KEY failed: %d\n", GetLastError());
430 CoTaskMemFree(post_cookie);
431 }
432 }
433
434 flags = INTERNET_ERROR_MASK_COMBINED_SEC_CERT;
435 res = InternetSetOptionW(This->base.request, INTERNET_OPTION_ERROR_MASK, &flags, sizeof(flags));
436 if(!res)
437 WARN("InternetSetOption(INTERNET_OPTION_ERROR_MASK) failed: %u\n", GetLastError());
438
439 b = TRUE;
440 res = InternetSetOptionW(This->base.request, INTERNET_OPTION_HTTP_DECODING, &b, sizeof(b));
441 if(!res)
442 WARN("InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %u\n", GetLastError());
443
444 do {
445 error = send_http_request(This);
446
447 switch(error) {
448 case ERROR_IO_PENDING:
449 return S_OK;
450 case ERROR_SUCCESS:
451 /*
452 * If sending response ended synchronously, it means that we have the whole data
453 * available locally (most likely in cache).
454 */
455 return protocol_syncbinding(&This->base);
456 default:
457 hres = handle_http_error(This, error);
458 }
459 } while(hres == RPC_E_RETRY);
460
461 WARN("HttpSendRequest failed: %d\n", error);
462 return hres;
463 }
464
465 static HRESULT HttpProtocol_end_request(Protocol *protocol)
466 {
467 BOOL res;
468
469 res = HttpEndRequestW(protocol->request, NULL, 0, 0);
470 if(!res && GetLastError() != ERROR_IO_PENDING) {
471 FIXME("HttpEndRequest failed: %u\n", GetLastError());
472 return E_FAIL;
473 }
474
475 return S_OK;
476 }
477
478 static HRESULT HttpProtocol_start_downloading(Protocol *prot)
479 {
480 HttpProtocol *This = impl_from_Protocol(prot);
481 LPWSTR content_type, content_length, ranges;
482 DWORD len = sizeof(DWORD);
483 DWORD status_code;
484 BOOL res;
485 HRESULT hres;
486
487 static const WCHAR wszDefaultContentType[] =
488 {'t','e','x','t','/','h','t','m','l',0};
489
490 if(!This->http_negotiate) {
491 WARN("Expected IHttpNegotiate pointer to be non-NULL\n");
492 return S_OK;
493 }
494
495 res = HttpQueryInfoW(This->base.request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
496 &status_code, &len, NULL);
497 if(res) {
498 LPWSTR response_headers = query_http_info(This, HTTP_QUERY_RAW_HEADERS_CRLF);
499 if(response_headers) {
500 hres = IHttpNegotiate_OnResponse(This->http_negotiate, status_code, response_headers,
501 NULL, NULL);
502 heap_free(response_headers);
503 if (hres != S_OK) {
504 WARN("IHttpNegotiate_OnResponse failed: %08x\n", hres);
505 return S_OK;
506 }
507 }
508 }else {
509 WARN("HttpQueryInfo failed: %d\n", GetLastError());
510 }
511
512 ranges = query_http_info(This, HTTP_QUERY_ACCEPT_RANGES);
513 if(ranges) {
514 IInternetProtocolSink_ReportProgress(This->base.protocol_sink, BINDSTATUS_ACCEPTRANGES, NULL);
515 heap_free(ranges);
516 }
517
518 content_type = query_http_info(This, HTTP_QUERY_CONTENT_TYPE);
519 if(content_type) {
520 /* remove the charset, if present */
521 LPWSTR p = strchrW(content_type, ';');
522 if (p) *p = '\0';
523
524 IInternetProtocolSink_ReportProgress(This->base.protocol_sink,
525 (This->base.bindf & BINDF_FROMURLMON)
526 ? BINDSTATUS_MIMETYPEAVAILABLE : BINDSTATUS_RAWMIMETYPE,
527 content_type);
528 heap_free(content_type);
529 }else {
530 WARN("HttpQueryInfo failed: %d\n", GetLastError());
531 IInternetProtocolSink_ReportProgress(This->base.protocol_sink,
532 (This->base.bindf & BINDF_FROMURLMON)
533 ? BINDSTATUS_MIMETYPEAVAILABLE : BINDSTATUS_RAWMIMETYPE,
534 wszDefaultContentType);
535 }
536
537 content_length = query_http_info(This, HTTP_QUERY_CONTENT_LENGTH);
538 if(content_length) {
539 This->base.content_length = atoiW(content_length);
540 heap_free(content_length);
541 }
542
543 return S_OK;
544 }
545
546 static void HttpProtocol_close_connection(Protocol *prot)
547 {
548 HttpProtocol *This = impl_from_Protocol(prot);
549
550 if(This->http_negotiate) {
551 IHttpNegotiate_Release(This->http_negotiate);
552 This->http_negotiate = NULL;
553 }
554
555 heap_free(This->full_header);
556 This->full_header = NULL;
557 }
558
559 static void HttpProtocol_on_error(Protocol *prot, DWORD error)
560 {
561 HttpProtocol *This = impl_from_Protocol(prot);
562 HRESULT hres;
563
564 TRACE("(%p) %d\n", prot, error);
565
566 if(prot->flags & FLAG_FIRST_CONTINUE_COMPLETE) {
567 FIXME("Not handling error %d\n", error);
568 return;
569 }
570
571 while((hres = handle_http_error(This, error)) == RPC_E_RETRY) {
572 error = send_http_request(This);
573
574 if(error == ERROR_IO_PENDING || error == ERROR_SUCCESS)
575 return;
576 }
577
578 protocol_abort(prot, hres);
579 protocol_close_connection(prot);
580 return;
581 }
582
583 static const ProtocolVtbl AsyncProtocolVtbl = {
584 HttpProtocol_open_request,
585 HttpProtocol_end_request,
586 HttpProtocol_start_downloading,
587 HttpProtocol_close_connection,
588 HttpProtocol_on_error
589 };
590
591 static HRESULT WINAPI HttpProtocol_QueryInterface(IInternetProtocolEx *iface, REFIID riid, void **ppv)
592 {
593 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
594
595 *ppv = NULL;
596 if(IsEqualGUID(&IID_IUnknown, riid)) {
597 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
598 *ppv = &This->IInternetProtocolEx_iface;
599 }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
600 TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
601 *ppv = &This->IInternetProtocolEx_iface;
602 }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
603 TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
604 *ppv = &This->IInternetProtocolEx_iface;
605 }else if(IsEqualGUID(&IID_IInternetProtocolEx, riid)) {
606 TRACE("(%p)->(IID_IInternetProtocolEx %p)\n", This, ppv);
607 *ppv = &This->IInternetProtocolEx_iface;
608 }else if(IsEqualGUID(&IID_IInternetPriority, riid)) {
609 TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv);
610 *ppv = &This->IInternetPriority_iface;
611 }else if(IsEqualGUID(&IID_IWinInetInfo, riid)) {
612 TRACE("(%p)->(IID_IWinInetInfo %p)\n", This, ppv);
613 *ppv = &This->IWinInetHttpInfo_iface;
614 }else if(IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
615 TRACE("(%p)->(IID_IWinInetHttpInfo %p)\n", This, ppv);
616 *ppv = &This->IWinInetHttpInfo_iface;
617 }
618
619 if(*ppv) {
620 IInternetProtocolEx_AddRef(iface);
621 return S_OK;
622 }
623
624 WARN("not supported interface %s\n", debugstr_guid(riid));
625 return E_NOINTERFACE;
626 }
627
628 static ULONG WINAPI HttpProtocol_AddRef(IInternetProtocolEx *iface)
629 {
630 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
631 LONG ref = InterlockedIncrement(&This->ref);
632 TRACE("(%p) ref=%d\n", This, ref);
633 return ref;
634 }
635
636 static ULONG WINAPI HttpProtocol_Release(IInternetProtocolEx *iface)
637 {
638 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
639 LONG ref = InterlockedDecrement(&This->ref);
640
641 TRACE("(%p) ref=%d\n", This, ref);
642
643 if(!ref) {
644 protocol_close_connection(&This->base);
645 heap_free(This);
646
647 URLMON_UnlockModule();
648 }
649
650 return ref;
651 }
652
653 static HRESULT WINAPI HttpProtocol_Start(IInternetProtocolEx *iface, LPCWSTR szUrl,
654 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
655 DWORD grfPI, HANDLE_PTR dwReserved)
656 {
657 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
658 IUri *uri;
659 HRESULT hres;
660
661 TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
662 pOIBindInfo, grfPI, dwReserved);
663
664 hres = CreateUri(szUrl, 0, 0, &uri);
665 if(FAILED(hres))
666 return hres;
667
668 hres = IInternetProtocolEx_StartEx(&This->IInternetProtocolEx_iface, uri, pOIProtSink,
669 pOIBindInfo, grfPI, (HANDLE*)dwReserved);
670
671 IUri_Release(uri);
672 return hres;
673 }
674
675 static HRESULT WINAPI HttpProtocol_Continue(IInternetProtocolEx *iface, PROTOCOLDATA *pProtocolData)
676 {
677 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
678
679 TRACE("(%p)->(%p)\n", This, pProtocolData);
680
681 return protocol_continue(&This->base, pProtocolData);
682 }
683
684 static HRESULT WINAPI HttpProtocol_Abort(IInternetProtocolEx *iface, HRESULT hrReason,
685 DWORD dwOptions)
686 {
687 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
688
689 TRACE("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
690
691 return protocol_abort(&This->base, hrReason);
692 }
693
694 static HRESULT WINAPI HttpProtocol_Terminate(IInternetProtocolEx *iface, DWORD dwOptions)
695 {
696 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
697
698 TRACE("(%p)->(%08x)\n", This, dwOptions);
699
700 protocol_close_connection(&This->base);
701 return S_OK;
702 }
703
704 static HRESULT WINAPI HttpProtocol_Suspend(IInternetProtocolEx *iface)
705 {
706 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
707 FIXME("(%p)\n", This);
708 return E_NOTIMPL;
709 }
710
711 static HRESULT WINAPI HttpProtocol_Resume(IInternetProtocolEx *iface)
712 {
713 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
714 FIXME("(%p)\n", This);
715 return E_NOTIMPL;
716 }
717
718 static HRESULT WINAPI HttpProtocol_Read(IInternetProtocolEx *iface, void *pv,
719 ULONG cb, ULONG *pcbRead)
720 {
721 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
722
723 TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
724
725 return protocol_read(&This->base, pv, cb, pcbRead);
726 }
727
728 static HRESULT WINAPI HttpProtocol_Seek(IInternetProtocolEx *iface, LARGE_INTEGER dlibMove,
729 DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
730 {
731 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
732 FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
733 return E_NOTIMPL;
734 }
735
736 static HRESULT WINAPI HttpProtocol_LockRequest(IInternetProtocolEx *iface, DWORD dwOptions)
737 {
738 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
739
740 TRACE("(%p)->(%08x)\n", This, dwOptions);
741
742 return protocol_lock_request(&This->base);
743 }
744
745 static HRESULT WINAPI HttpProtocol_UnlockRequest(IInternetProtocolEx *iface)
746 {
747 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
748
749 TRACE("(%p)\n", This);
750
751 return protocol_unlock_request(&This->base);
752 }
753
754 static HRESULT WINAPI HttpProtocol_StartEx(IInternetProtocolEx *iface, IUri *pUri,
755 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
756 DWORD grfPI, HANDLE *dwReserved)
757 {
758 HttpProtocol *This = impl_from_IInternetProtocolEx(iface);
759 DWORD scheme = 0;
760 HRESULT hres;
761
762 TRACE("(%p)->(%p %p %p %08x %p)\n", This, pUri, pOIProtSink,
763 pOIBindInfo, grfPI, dwReserved);
764
765 hres = IUri_GetScheme(pUri, &scheme);
766 if(FAILED(hres))
767 return hres;
768 if(scheme != (This->https ? URL_SCHEME_HTTPS : URL_SCHEME_HTTP))
769 return MK_E_SYNTAX;
770
771 return protocol_start(&This->base, (IInternetProtocol*)&This->IInternetProtocolEx_iface, pUri,
772 pOIProtSink, pOIBindInfo);
773 }
774
775 static const IInternetProtocolExVtbl HttpProtocolVtbl = {
776 HttpProtocol_QueryInterface,
777 HttpProtocol_AddRef,
778 HttpProtocol_Release,
779 HttpProtocol_Start,
780 HttpProtocol_Continue,
781 HttpProtocol_Abort,
782 HttpProtocol_Terminate,
783 HttpProtocol_Suspend,
784 HttpProtocol_Resume,
785 HttpProtocol_Read,
786 HttpProtocol_Seek,
787 HttpProtocol_LockRequest,
788 HttpProtocol_UnlockRequest,
789 HttpProtocol_StartEx
790 };
791
792 static HRESULT WINAPI HttpPriority_QueryInterface(IInternetPriority *iface, REFIID riid, void **ppv)
793 {
794 HttpProtocol *This = impl_from_IInternetPriority(iface);
795 return IInternetProtocolEx_QueryInterface(&This->IInternetProtocolEx_iface, riid, ppv);
796 }
797
798 static ULONG WINAPI HttpPriority_AddRef(IInternetPriority *iface)
799 {
800 HttpProtocol *This = impl_from_IInternetPriority(iface);
801 return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
802 }
803
804 static ULONG WINAPI HttpPriority_Release(IInternetPriority *iface)
805 {
806 HttpProtocol *This = impl_from_IInternetPriority(iface);
807 return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
808 }
809
810 static HRESULT WINAPI HttpPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
811 {
812 HttpProtocol *This = impl_from_IInternetPriority(iface);
813
814 TRACE("(%p)->(%d)\n", This, nPriority);
815
816 This->base.priority = nPriority;
817 return S_OK;
818 }
819
820 static HRESULT WINAPI HttpPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
821 {
822 HttpProtocol *This = impl_from_IInternetPriority(iface);
823
824 TRACE("(%p)->(%p)\n", This, pnPriority);
825
826 *pnPriority = This->base.priority;
827 return S_OK;
828 }
829
830 static const IInternetPriorityVtbl HttpPriorityVtbl = {
831 HttpPriority_QueryInterface,
832 HttpPriority_AddRef,
833 HttpPriority_Release,
834 HttpPriority_SetPriority,
835 HttpPriority_GetPriority
836 };
837
838 static HRESULT WINAPI HttpInfo_QueryInterface(IWinInetHttpInfo *iface, REFIID riid, void **ppv)
839 {
840 HttpProtocol *This = impl_from_IWinInetHttpInfo(iface);
841 return IInternetProtocolEx_QueryInterface(&This->IInternetProtocolEx_iface, riid, ppv);
842 }
843
844 static ULONG WINAPI HttpInfo_AddRef(IWinInetHttpInfo *iface)
845 {
846 HttpProtocol *This = impl_from_IWinInetHttpInfo(iface);
847 return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
848 }
849
850 static ULONG WINAPI HttpInfo_Release(IWinInetHttpInfo *iface)
851 {
852 HttpProtocol *This = impl_from_IWinInetHttpInfo(iface);
853 return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
854 }
855
856 static HRESULT WINAPI HttpInfo_QueryOption(IWinInetHttpInfo *iface, DWORD dwOption,
857 void *pBuffer, DWORD *pcbBuffer)
858 {
859 HttpProtocol *This = impl_from_IWinInetHttpInfo(iface);
860 TRACE("(%p)->(%x %p %p)\n", This, dwOption, pBuffer, pcbBuffer);
861
862 if(!This->base.request)
863 return E_FAIL;
864
865 if(!InternetQueryOptionW(This->base.request, dwOption, pBuffer, pcbBuffer))
866 return S_FALSE;
867 return S_OK;
868 }
869
870 static HRESULT WINAPI HttpInfo_QueryInfo(IWinInetHttpInfo *iface, DWORD dwOption,
871 void *pBuffer, DWORD *pcbBuffer, DWORD *pdwFlags, DWORD *pdwReserved)
872 {
873 HttpProtocol *This = impl_from_IWinInetHttpInfo(iface);
874 TRACE("(%p)->(%x %p %p %p %p)\n", This, dwOption, pBuffer, pcbBuffer, pdwFlags, pdwReserved);
875
876 if(!This->base.request)
877 return E_FAIL;
878
879 if(!HttpQueryInfoW(This->base.request, dwOption, pBuffer, pcbBuffer, pdwFlags)) {
880 if(pBuffer)
881 memset(pBuffer, 0, *pcbBuffer);
882 return S_OK;
883 }
884 return S_OK;
885 }
886
887 static const IWinInetHttpInfoVtbl WinInetHttpInfoVtbl = {
888 HttpInfo_QueryInterface,
889 HttpInfo_AddRef,
890 HttpInfo_Release,
891 HttpInfo_QueryOption,
892 HttpInfo_QueryInfo
893 };
894
895 static HRESULT create_http_protocol(BOOL https, void **ppobj)
896 {
897 HttpProtocol *ret;
898
899 ret = heap_alloc_zero(sizeof(HttpProtocol));
900 if(!ret)
901 return E_OUTOFMEMORY;
902
903 ret->base.vtbl = &AsyncProtocolVtbl;
904 ret->IInternetProtocolEx_iface.lpVtbl = &HttpProtocolVtbl;
905 ret->IInternetPriority_iface.lpVtbl = &HttpPriorityVtbl;
906 ret->IWinInetHttpInfo_iface.lpVtbl = &WinInetHttpInfoVtbl;
907
908 ret->https = https;
909 ret->ref = 1;
910
911 *ppobj = &ret->IInternetProtocolEx_iface;
912
913 URLMON_LockModule();
914 return S_OK;
915 }
916
917 HRESULT HttpProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
918 {
919 TRACE("(%p %p)\n", pUnkOuter, ppobj);
920
921 return create_http_protocol(FALSE, ppobj);
922 }
923
924 HRESULT HttpSProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
925 {
926 TRACE("(%p %p)\n", pUnkOuter, ppobj);
927
928 return create_http_protocol(TRUE, ppobj);
929 }