code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/platform/network/win/ResourceHandleWin.cpp

   1 /*
   2  * Copyright (C) 2004, 2006 Apple Computer, Inc.  All rights reserved.
   3  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "ResourceHandle.h"
  29
  30 #include "DataURL.h"
  31 #include "HTTPParsers.h"
  32 #include "MIMETypeRegistry.h"
  33 #include "MainThread.h"
  34 #include "NotImplemented.h"
  35 #include "ResourceError.h"
  36 #include "ResourceHandleClient.h"
  37 #include "ResourceHandleInternal.h"
  38 #include "SharedBuffer.h"
  39 #include "Timer.h"
  40 #include "UnusedParam.h"
  41 #include <wtf/text/CString.h>
  42 #include <windows.h>
  43 #include <wininet.h>
  44
  45 namespace WebCore {
  46
  47 static inline HINTERNET createInternetHandle(const String& userAgent, bool asynchronous)
  48 {
  49     String userAgentString = userAgent;
  50     HINTERNET internetHandle = InternetOpenW(userAgentString.charactersWithNullTermination(), INTERNET_OPEN_TYPE_PRECONFIG, 0, 0, asynchronous ? INTERNET_FLAG_ASYNC : 0);
  51
  52     if (asynchronous)
  53         InternetSetStatusCallback(internetHandle, &ResourceHandle::internetStatusCallback);
  54
  55     return internetHandle;
  56 }
  57
  58 static HINTERNET asynchronousInternetHandle(const String& userAgent)
  59 {
  60     static HINTERNET internetHandle = createInternetHandle(userAgent, true);
  61     return internetHandle;
  62 }
  63
  64 static String queryHTTPHeader(HINTERNET requestHandle, DWORD infoLevel)
  65 {
  66     DWORD bufferSize = 0;
  67     HttpQueryInfoW(requestHandle, infoLevel, 0, &bufferSize, 0);
  68
  69     Vector<UChar> characters(bufferSize / sizeof(UChar));
  70
  71     if (!HttpQueryInfoW(requestHandle, infoLevel, characters.data(), &bufferSize, 0))
  72         return String();
  73
  74     characters.removeLast(); // Remove NullTermination.
  75     return String::adopt(characters);
  76 }
  77
  78
  79 class WebCoreSynchronousLoader : public ResourceHandleClient {
  80     WTF_MAKE_NONCOPYABLE(WebCoreSynchronousLoader);
  81 public:
  82     WebCoreSynchronousLoader(ResourceError&, ResourceResponse&, Vector<char>&, const String& userAgent);
  83     ~WebCoreSynchronousLoader();
  84
  85     HINTERNET internetHandle() const { return m_internetHandle; }
  86
  87     virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
  88     virtual void didReceiveData(ResourceHandle*, const char*, int, int encodedDataLength);
  89     virtual void didFinishLoading(ResourceHandle*, double /*finishTime*/);
  90     virtual void didFail(ResourceHandle*, const ResourceError&);
  91
  92 private:
  93     ResourceError& m_error;
  94     ResourceResponse& m_response;
  95     Vector<char>& m_data;
  96     HINTERNET m_internetHandle;
  97 };
  98
  99 WebCoreSynchronousLoader::WebCoreSynchronousLoader(ResourceError& error, ResourceResponse& response, Vector<char>& data, const String& userAgent)
 100     : m_error(error)
 101     , m_response(response)
 102     , m_data(data)
 103     , m_internetHandle(createInternetHandle(userAgent, false))
 104 {
 105 }
 106
 107 WebCoreSynchronousLoader::~WebCoreSynchronousLoader()
 108 {
 109     InternetCloseHandle(m_internetHandle);
 110 }
 111
 112 void WebCoreSynchronousLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
 113 {
 114     m_response = response;
 115 }
 116
 117 void WebCoreSynchronousLoader::didReceiveData(ResourceHandle*, const char* data, int length, int)
 118 {
 119     m_data.append(data, length);
 120 }
 121
 122 void WebCoreSynchronousLoader::didFinishLoading(ResourceHandle*, double)
 123 {
 124 }
 125
 126 void WebCoreSynchronousLoader::didFail(ResourceHandle*, const ResourceError& error)
 127 {
 128     m_error = error;
 129 }
 130
 131
 132 ResourceHandleInternal::~ResourceHandleInternal()
 133 {
 134 }
 135
 136 ResourceHandle::~ResourceHandle()
 137 {
 138 }
 139
 140 static void callOnRedirect(void* context)
 141 {
 142     ResourceHandle* handle = static_cast<ResourceHandle*>(context);
 143     handle->onRedirect();
 144 }
 145
 146 static void callOnRequestComplete(void* context)
 147 {
 148     ResourceHandle* handle = static_cast<ResourceHandle*>(context);
 149     handle->onRequestComplete();
 150 }
 151
 152 void ResourceHandle::internetStatusCallback(HINTERNET internetHandle, DWORD_PTR context, DWORD internetStatus,
 153                                                      LPVOID statusInformation, DWORD statusInformationLength)
 154 {
 155     ResourceHandle* handle = reinterpret_cast<ResourceHandle*>(context);
 156
 157     switch (internetStatus) {
 158     case INTERNET_STATUS_REDIRECT:
 159         handle->d->m_redirectUrl = String(static_cast<UChar*>(statusInformation), statusInformationLength);
 160         callOnMainThread(callOnRedirect, handle);
 161         break;
 162
 163     case INTERNET_STATUS_REQUEST_COMPLETE:
 164         callOnMainThread(callOnRequestComplete, handle);
 165         break;
 166
 167     default:
 168         break;
 169     }
 170 }
 171
 172 void ResourceHandle::onRedirect()
 173 {
 174     ResourceRequest newRequest = firstRequest();
 175     newRequest.setURL(KURL(ParsedURLString, d->m_redirectUrl));
 176
 177     ResourceResponse response(firstRequest().url(), String(), 0, String(), String());
 178
 179     if (ResourceHandleClient* resourceHandleClient = client())
 180         resourceHandleClient->willSendRequest(this, newRequest, response);
 181 }
 182
 183 bool ResourceHandle::onRequestComplete()
 184 {
 185     if (!d->m_internetHandle) { // 0 if canceled.
 186         deref(); // balances ref in start
 187         return false;
 188     }
 189
 190     if (d->m_bytesRemainingToWrite) {
 191         DWORD bytesWritten;
 192         InternetWriteFile(d->m_requestHandle,
 193                           d->m_formData.data() + (d->m_formData.size() - d->m_bytesRemainingToWrite),
 194                           d->m_bytesRemainingToWrite,
 195                           &bytesWritten);
 196         d->m_bytesRemainingToWrite -= bytesWritten;
 197         if (d->m_bytesRemainingToWrite)
 198             return true;
 199         d->m_formData.clear();
 200     }
 201
 202     if (!d->m_sentEndRequest) {
 203         HttpEndRequestW(d->m_requestHandle, 0, 0, reinterpret_cast<DWORD_PTR>(this));
 204         d->m_sentEndRequest = true;
 205         return true;
 206     }
 207
 208     static const int bufferSize = 32768;
 209     char buffer[bufferSize];
 210     INTERNET_BUFFERSA buffers;
 211     buffers.dwStructSize = sizeof(INTERNET_BUFFERSA);
 212     buffers.lpvBuffer = buffer;
 213     buffers.dwBufferLength = bufferSize;
 214
 215     BOOL ok = FALSE;
 216     while ((ok = InternetReadFileExA(d->m_requestHandle, &buffers, d->m_loadSynchronously ? 0 : IRF_NO_WAIT, reinterpret_cast<DWORD_PTR>(this))) && buffers.dwBufferLength) {
 217         if (!d->m_hasReceivedResponse) {
 218             d->m_hasReceivedResponse = true;
 219
 220             ResourceResponse response;
 221             response.setURL(firstRequest().url());
 222
 223             String httpStatusText = queryHTTPHeader(d->m_requestHandle, HTTP_QUERY_STATUS_TEXT);
 224             if (!httpStatusText.isNull())
 225                 response.setHTTPStatusText(httpStatusText);
 226
 227             String httpStatusCode = queryHTTPHeader(d->m_requestHandle, HTTP_QUERY_STATUS_CODE);
 228             if (!httpStatusCode.isNull())
 229                 response.setHTTPStatusCode(httpStatusCode.toInt());
 230
 231             String httpContentLength = queryHTTPHeader(d->m_requestHandle, HTTP_QUERY_CONTENT_LENGTH);
 232             if (!httpContentLength.isNull())
 233                 response.setExpectedContentLength(httpContentLength.toInt());
 234
 235             String httpContentType = queryHTTPHeader(d->m_requestHandle, HTTP_QUERY_CONTENT_TYPE);
 236             if (!httpContentType.isNull()) {
 237                 response.setMimeType(extractMIMETypeFromMediaType(httpContentType));
 238                 response.setTextEncodingName(extractCharsetFromMediaType(httpContentType));
 239             }
 240
 241             if (ResourceHandleClient* resourceHandleClient = client())
 242                 resourceHandleClient->didReceiveResponse(this, response);
 243         }
 244
 245         // FIXME: https://bugs.webkit.org/show_bug.cgi?id=19793
 246         // -1 means we do not provide any data about transfer size to inspector so it would use
 247         // Content-Length headers or content size to show transfer size.
 248         if (ResourceHandleClient* resourceHandleClient = client())
 249             resourceHandleClient->didReceiveData(this, buffer, buffers.dwBufferLength, -1);
 250         buffers.dwBufferLength = bufferSize;
 251     }
 252
 253     if (!ok && GetLastError() == ERROR_IO_PENDING)
 254         return true;
 255
 256     if (ResourceHandleClient* resourceHandleClient = client())
 257         resourceHandleClient->didFinishLoading(this, 0);
 258
 259     InternetCloseHandle(d->m_requestHandle);
 260     InternetCloseHandle(d->m_connectHandle);
 261     deref(); // balances ref in start
 262     return false;
 263 }
 264
 265 bool ResourceHandle::start(NetworkingContext* context)
 266 {
 267     if (firstRequest().url().isLocalFile() || firstRequest().url().protocolIsData()) {
 268         ref(); // balanced by deref in fileLoadTimer
 269         if (d->m_loadSynchronously)
 270             fileLoadTimer(0);
 271         else
 272             d->m_fileLoadTimer.startOneShot(0.0);
 273         return true;
 274     }
 275
 276     if (!d->m_internetHandle)
 277         d->m_internetHandle = asynchronousInternetHandle(context->userAgent());
 278
 279     if (!d->m_internetHandle)
 280         return false;
 281
 282     DWORD flags = INTERNET_FLAG_KEEP_CONNECTION
 283         | INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS
 284         | INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP
 285         | INTERNET_FLAG_DONT_CACHE
 286         | INTERNET_FLAG_RELOAD;
 287
 288     d->m_connectHandle = InternetConnectW(d->m_internetHandle, firstRequest().url().host().charactersWithNullTermination(), firstRequest().url().port(),
 289                                           0, 0, INTERNET_SERVICE_HTTP, flags, reinterpret_cast<DWORD_PTR>(this));
 290
 291     if (!d->m_connectHandle)
 292         return false;
 293
 294     String urlStr = firstRequest().url().path();
 295     String urlQuery = firstRequest().url().query();
 296
 297     if (!urlQuery.isEmpty()) {
 298         urlStr.append('?');
 299         urlStr.append(urlQuery);
 300     }
 301
 302     String httpMethod = firstRequest().httpMethod();
 303     String httpReferrer = firstRequest().httpReferrer();
 304
 305     LPCWSTR httpAccept[] = { L"*/*", 0 };
 306
 307     d->m_requestHandle = HttpOpenRequestW(d->m_connectHandle, httpMethod.charactersWithNullTermination(), urlStr.charactersWithNullTermination(),
 308                                           0, httpReferrer.charactersWithNullTermination(), httpAccept, flags, reinterpret_cast<DWORD_PTR>(this));
 309
 310     if (!d->m_requestHandle) {
 311         InternetCloseHandle(d->m_connectHandle);
 312         return false;
 313     }
 314
 315     if (firstRequest().httpBody()) {
 316         firstRequest().httpBody()->flatten(d->m_formData);
 317         d->m_bytesRemainingToWrite = d->m_formData.size();
 318     }
 319
 320     Vector<UChar> httpHeaders;
 321     const HTTPHeaderMap& httpHeaderFields = firstRequest().httpHeaderFields();
 322
 323     for (HTTPHeaderMap::const_iterator it = httpHeaderFields.begin(); it != httpHeaderFields.end(); ++it) {
 324         if (equalIgnoringCase(it->first, "Accept") || equalIgnoringCase(it->first, "Referer") || equalIgnoringCase(it->first, "User-Agent"))
 325             continue;
 326
 327         if (!httpHeaders.isEmpty())
 328             httpHeaders.append('\n');
 329
 330         httpHeaders.append(it->first.characters(), it->first.length());
 331         httpHeaders.append(':');
 332         httpHeaders.append(it->second.characters(), it->second.length());
 333     }
 334
 335     INTERNET_BUFFERSW internetBuffers;
 336     ZeroMemory(&internetBuffers, sizeof(internetBuffers));
 337     internetBuffers.dwStructSize = sizeof(internetBuffers);
 338     internetBuffers.lpcszHeader = httpHeaders.data();
 339     internetBuffers.dwHeadersLength = httpHeaders.size();
 340     internetBuffers.dwBufferTotal = d->m_bytesRemainingToWrite;
 341
 342     HttpSendRequestExW(d->m_requestHandle, &internetBuffers, 0, 0, reinterpret_cast<DWORD_PTR>(this));
 343
 344     ref(); // balanced by deref in onRequestComplete
 345
 346     if (d->m_loadSynchronously)
 347         while (onRequestComplete()) {
 348             // Loop until finished.
 349         }
 350
 351     return true;
 352 }
 353
 354 void ResourceHandle::fileLoadTimer(Timer<ResourceHandle>*)
 355 {
 356     RefPtr<ResourceHandle> protector(this);
 357     deref(); // balances ref in start
 358
 359     if (firstRequest().url().protocolIsData()) {
 360         handleDataURL(this);
 361         return;
 362     }
 363
 364     String fileName = firstRequest().url().fileSystemPath();
 365     HANDLE fileHandle = CreateFileW(fileName.charactersWithNullTermination(), GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
 366
 367     if (fileHandle == INVALID_HANDLE_VALUE) {
 368         client()->didFail(this, ResourceError());
 369         return;
 370     }
 371
 372     ResourceResponse response;
 373
 374     int dotPos = fileName.reverseFind('.');
 375     int slashPos = fileName.reverseFind('/');
 376
 377     if (slashPos < dotPos && dotPos != -1) {
 378         String ext = fileName.substring(dotPos + 1);
 379         response.setMimeType(MIMETypeRegistry::getMIMETypeForExtension(ext));
 380     }
 381
 382     client()->didReceiveResponse(this, response);
 383
 384     bool result = false;
 385     DWORD bytesRead = 0;
 386
 387     do {
 388         const int bufferSize = 8192;
 389         char buffer[bufferSize];
 390         result = ReadFile(fileHandle, &buffer, bufferSize, &bytesRead, 0);
 391         // FIXME: https://bugs.webkit.org/show_bug.cgi?id=19793
 392         // -1 means we do not provide any data about transfer size to inspector so it would use
 393         // Content-Length headers or content size to show transfer size.
 394         if (result && bytesRead)
 395             client()->didReceiveData(this, buffer, bytesRead, -1);
 396         // Check for end of file.
 397     } while (result && bytesRead);
 398
 399     CloseHandle(fileHandle);
 400
 401     client()->didFinishLoading(this, 0);
 402 }
 403
 404 void ResourceHandle::cancel()
 405 {
 406     if (d->m_requestHandle) {
 407         d->m_internetHandle = 0;
 408         InternetCloseHandle(d->m_requestHandle);
 409         InternetCloseHandle(d->m_connectHandle);
 410     } else
 411         d->m_fileLoadTimer.stop();
 412 }
 413
 414 void ResourceHandle::loadResourceSynchronously(NetworkingContext* context, const ResourceRequest& request, StoredCredentials storedCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& data)
 415 {
 416     UNUSED_PARAM(storedCredentials);
 417
 418     WebCoreSynchronousLoader syncLoader(error, response, data, request.httpUserAgent());
 419     ResourceHandle handle(request, &syncLoader, true, false);
 420
 421     handle.setSynchronousInternetHandle(syncLoader.internetHandle());
 422     handle.start(context);
 423 }
 424
 425 void ResourceHandle::setSynchronousInternetHandle(HINTERNET internetHandle)
 426 {
 427     d->m_internetHandle = internetHandle;
 428     d->m_loadSynchronously = true;
 429 }
 430
 431 bool ResourceHandle::willLoadFromCache(ResourceRequest&, Frame*)
 432 {
 433     notImplemented();
 434     return false;
 435 }
 436
 437 void prefetchDNS(const String&)
 438 {
 439     notImplemented();
 440 }
 441
 442 bool ResourceHandle::loadsBlocked()
 443 {
 444     return false;
 445 }
 446
 447 void ResourceHandle::platformSetDefersLoading(bool)
 448 {
 449     notImplemented();
 450 }
 451
 452 } // namespace WebCore