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