1 /* 2 * Copyright (C) 2008 Alp Toker <alp (at) atoker.com> 3 * Copyright (C) 2008 Xan Lopez <xan (at) gnome.org> 4 * Copyright (C) 2008, 2010 Collabora Ltd. 5 * Copyright (C) 2009 Holger Hans Peter Freyther 6 * Copyright (C) 2009 Gustavo Noronha Silva <gns (at) gnome.org> 7 * Copyright (C) 2009 Christian Dywan <christian (at) imendio.com> 8 * Copyright (C) 2009 Igalia S.L. 9 * Copyright (C) 2009 John Kjellberg <john.kjellberg (at) power.alstom.com> 10 * 11 * This library is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU Library General Public 13 * License as published by the Free Software Foundation; either 14 * version 2 of the License, or (at your option) any later version. 15 * 16 * This library is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * Library General Public License for more details. 20 * 21 * You should have received a copy of the GNU Library General Public License 22 * along with this library; see the file COPYING.LIB. If not, write to 23 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 24 * Boston, MA 02110-1301, USA. 25 */ 26 27 #include "config.h" 28 #include "ResourceHandle.h" 29 30 #include "Base64.h" 31 #include "CString.h" 32 #include "ChromeClient.h" 33 #include "CookieJarSoup.h" 34 #include "CachedResourceLoader.h" 35 #include "FileSystem.h" 36 #include "Frame.h" 37 #include "GOwnPtrSoup.h" 38 #include "HTTPParsers.h" 39 #include "Logging.h" 40 #include "MIMETypeRegistry.h" 41 #include "NotImplemented.h" 42 #include "Page.h" 43 #include "ResourceError.h" 44 #include "ResourceHandleClient.h" 45 #include "ResourceHandleInternal.h" 46 #include "ResourceResponse.h" 47 #include "SharedBuffer.h" 48 #include "TextEncoding.h" 49 #include <errno.h> 50 #include <fcntl.h> 51 #include <gio/gio.h> 52 #include <glib.h> 53 #define LIBSOUP_USE_UNSTABLE_REQUEST_API 54 #include <libsoup/soup-request-http.h> 55 #include <libsoup/soup-requester.h> 56 #include <libsoup/soup.h> 57 #include <sys/stat.h> 58 #include <sys/types.h> 59 #include <unistd.h> 60 61 namespace WebCore { 62 63 #define READ_BUFFER_SIZE 8192 64 65 class WebCoreSynchronousLoader : public ResourceHandleClient { 66 WTF_MAKE_NONCOPYABLE(WebCoreSynchronousLoader); 67 public: 68 WebCoreSynchronousLoader(ResourceError&, ResourceResponse &, Vector<char>&); 69 ~WebCoreSynchronousLoader(); 70 71 virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&); 72 virtual void didReceiveData(ResourceHandle*, const char*, int, int encodedDataLength); 73 virtual void didFinishLoading(ResourceHandle*, double /*finishTime*/); 74 virtual void didFail(ResourceHandle*, const ResourceError&); 75 76 void run(); 77 78 private: 79 ResourceError& m_error; 80 ResourceResponse& m_response; 81 Vector<char>& m_data; 82 bool m_finished; 83 GMainLoop* m_mainLoop; 84 }; 85 86 WebCoreSynchronousLoader::WebCoreSynchronousLoader(ResourceError& error, ResourceResponse& response, Vector<char>& data) 87 : m_error(error) 88 , m_response(response) 89 , m_data(data) 90 , m_finished(false) 91 { 92 m_mainLoop = g_main_loop_new(0, false); 93 } 94 95 WebCoreSynchronousLoader::~WebCoreSynchronousLoader() 96 { 97 g_main_loop_unref(m_mainLoop); 98 } 99 100 void WebCoreSynchronousLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response) 101 { 102 m_response = response; 103 } 104 105 void WebCoreSynchronousLoader::didReceiveData(ResourceHandle*, const char* data, int length, int) 106 { 107 m_data.append(data, length); 108 } 109 110 void WebCoreSynchronousLoader::didFinishLoading(ResourceHandle*, double) 111 { 112 g_main_loop_quit(m_mainLoop); 113 m_finished = true; 114 } 115 116 void WebCoreSynchronousLoader::didFail(ResourceHandle* handle, const ResourceError& error) 117 { 118 m_error = error; 119 didFinishLoading(handle, 0); 120 } 121 122 void WebCoreSynchronousLoader::run() 123 { 124 if (!m_finished) 125 g_main_loop_run(m_mainLoop); 126 } 127 128 static void cleanupSoupRequestOperation(ResourceHandle*, bool isDestroying); 129 static void sendRequestCallback(GObject*, GAsyncResult*, gpointer); 130 static void readCallback(GObject*, GAsyncResult*, gpointer); 131 static void closeCallback(GObject*, GAsyncResult*, gpointer); 132 static bool startNonHTTPRequest(ResourceHandle*, KURL); 133 134 ResourceHandleInternal::~ResourceHandleInternal() 135 { 136 if (m_soupRequest) 137 g_object_set_data(G_OBJECT(m_soupRequest.get()), "webkit-resource", 0); 138 } 139 140 ResourceHandle::~ResourceHandle() 141 { 142 cleanupSoupRequestOperation(this, true); 143 } 144 145 static void ensureSessionIsInitialized(SoupSession* session) 146 { 147 // Values taken from http://stevesouders.com/ua/index.php following 148 // the rule "Do What Every Other Modern Browser Is Doing". They seem 149 // to significantly improve page loading time compared to soup's 150 // default values. 151 static const int maxConnections = 60; 152 static const int maxConnectionsPerHost = 6; 153 154 if (g_object_get_data(G_OBJECT(session), "webkit-init")) 155 return; 156 157 SoupCookieJar* jar = SOUP_COOKIE_JAR(soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR)); 158 if (!jar) 159 soup_session_add_feature(session, SOUP_SESSION_FEATURE(defaultCookieJar())); 160 else 161 setDefaultCookieJar(jar); 162 163 if (!soup_session_get_feature(session, SOUP_TYPE_LOGGER) && LogNetwork.state == WTFLogChannelOn) { 164 SoupLogger* logger = soup_logger_new(static_cast<SoupLoggerLogLevel>(SOUP_LOGGER_LOG_BODY), -1); 165 soup_session_add_feature(session, SOUP_SESSION_FEATURE(logger)); 166 g_object_unref(logger); 167 } 168 169 if (!soup_session_get_feature(session, SOUP_TYPE_REQUESTER)) { 170 SoupRequester* requester = soup_requester_new(); 171 soup_session_add_feature(session, SOUP_SESSION_FEATURE(requester)); 172 g_object_unref(requester); 173 } 174 175 g_object_set(session, 176 SOUP_SESSION_MAX_CONNS, maxConnections, 177 SOUP_SESSION_MAX_CONNS_PER_HOST, maxConnectionsPerHost, 178 NULL); 179 180 g_object_set_data(G_OBJECT(session), "webkit-init", reinterpret_cast<void*>(0xdeadbeef)); 181 } 182 183 void ResourceHandle::prepareForURL(const KURL& url) 184 { 185 GOwnPtr<SoupURI> soupURI(soup_uri_new(url.string().utf8().data())); 186 if (!soupURI) 187 return; 188 soup_session_prepare_for_uri(ResourceHandle::defaultSession(), soupURI.get()); 189 } 190 191 // All other kinds of redirections, except for the *304* status code 192 // (SOUP_STATUS_NOT_MODIFIED) which needs to be fed into WebCore, will be 193 // handled by soup directly. 194 static gboolean statusWillBeHandledBySoup(guint statusCode) 195 { 196 if (SOUP_STATUS_IS_TRANSPORT_ERROR(statusCode) 197 || (SOUP_STATUS_IS_REDIRECTION(statusCode) && (statusCode != SOUP_STATUS_NOT_MODIFIED)) 198 || (statusCode == SOUP_STATUS_UNAUTHORIZED)) 199 return true; 200 201 return false; 202 } 203 204 static void fillResponseFromMessage(SoupMessage* msg, ResourceResponse* response) 205 { 206 response->updateFromSoupMessage(msg); 207 } 208 209 // Called each time the message is going to be sent again except the first time. 210 // It's used mostly to let webkit know about redirects. 211 static void restartedCallback(SoupMessage* msg, gpointer data) 212 { 213 ResourceHandle* handle = static_cast<ResourceHandle*>(data); 214 if (!handle) 215 return; 216 ResourceHandleInternal* d = handle->getInternal(); 217 if (d->m_cancelled) 218 return; 219 220 GOwnPtr<char> uri(soup_uri_to_string(soup_message_get_uri(msg), false)); 221 String location = String::fromUTF8(uri.get()); 222 KURL newURL = KURL(handle->firstRequest().url(), location); 223 224 ResourceRequest request = handle->firstRequest(); 225 ResourceResponse response; 226 request.setURL(newURL); 227 request.setHTTPMethod(msg->method); 228 fillResponseFromMessage(msg, &response); 229 230 // Should not set Referer after a redirect from a secure resource to non-secure one. 231 if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https")) { 232 request.clearHTTPReferrer(); 233 soup_message_headers_remove(msg->request_headers, "Referer"); 234 } 235 236 if (d->client()) 237 d->client()->willSendRequest(handle, request, response); 238 239 if (d->m_cancelled) 240 return; 241 242 // Update the first party in case the base URL changed with the redirect 243 String firstPartyString = request.firstPartyForCookies().string(); 244 if (!firstPartyString.isEmpty()) { 245 GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data())); 246 soup_message_set_first_party(d->m_soupMessage.get(), firstParty.get()); 247 } 248 } 249 250 static void contentSniffedCallback(SoupMessage*, const char*, GHashTable*, gpointer); 251 252 static void gotHeadersCallback(SoupMessage* msg, gpointer data) 253 { 254 // For 401, we will accumulate the resource body, and only use it 255 // in case authentication with the soup feature doesn't happen. 256 // For 302 we accumulate the body too because it could be used by 257 // some servers to redirect with a clunky http-equiv=REFRESH 258 if (statusWillBeHandledBySoup(msg->status_code)) { 259 soup_message_body_set_accumulate(msg->response_body, TRUE); 260 return; 261 } 262 263 // For all the other responses, we handle each chunk ourselves, 264 // and we don't need msg->response_body to contain all of the data 265 // we got, when we finish downloading. 266 soup_message_body_set_accumulate(msg->response_body, FALSE); 267 268 RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data); 269 270 // The content-sniffed callback will handle the response if WebCore 271 // require us to sniff. 272 if (!handle || statusWillBeHandledBySoup(msg->status_code)) 273 return; 274 275 if (handle->shouldContentSniff()) { 276 // Avoid MIME type sniffing if the response comes back as 304 Not Modified. 277 if (msg->status_code == SOUP_STATUS_NOT_MODIFIED) { 278 soup_message_disable_feature(msg, SOUP_TYPE_CONTENT_SNIFFER); 279 g_signal_handlers_disconnect_by_func(msg, reinterpret_cast<gpointer>(contentSniffedCallback), handle.get()); 280 } else 281 return; 282 } 283 284 ResourceHandleInternal* d = handle->getInternal(); 285 if (d->m_cancelled) 286 return; 287 ResourceHandleClient* client = handle->client(); 288 if (!client) 289 return; 290 291 ASSERT(d->m_response.isNull()); 292 293 fillResponseFromMessage(msg, &d->m_response); 294 client->didReceiveResponse(handle.get(), d->m_response); 295 } 296 297 static void wroteBodyDataCallback(SoupMessage*, SoupBuffer* buffer, gpointer data) 298 { 299 RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data); 300 if (!handle) 301 return; 302 303 ASSERT(buffer); 304 ResourceHandleInternal* internal = handle->getInternal(); 305 internal->m_bodyDataSent += buffer->length; 306 307 if (internal->m_cancelled) 308 return; 309 ResourceHandleClient* client = handle->client(); 310 if (!client) 311 return; 312 313 client->didSendData(handle.get(), internal->m_bodyDataSent, internal->m_bodySize); 314 } 315 316 // This callback will not be called if the content sniffer is disabled in startHTTPRequest. 317 static void contentSniffedCallback(SoupMessage* msg, const char* sniffedType, GHashTable *params, gpointer data) 318 { 319 if (sniffedType) { 320 const char* officialType = soup_message_headers_get_one(msg->response_headers, "Content-Type"); 321 322 if (!officialType || strcmp(officialType, sniffedType)) 323 soup_message_headers_set_content_type(msg->response_headers, sniffedType, params); 324 } 325 326 if (statusWillBeHandledBySoup(msg->status_code)) 327 return; 328 329 RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data); 330 if (!handle) 331 return; 332 ResourceHandleInternal* d = handle->getInternal(); 333 if (d->m_cancelled) 334 return; 335 ResourceHandleClient* client = handle->client(); 336 if (!client) 337 return; 338 339 ASSERT(d->m_response.isNull()); 340 341 fillResponseFromMessage(msg, &d->m_response); 342 client->didReceiveResponse(handle.get(), d->m_response); 343 } 344 345 static void gotChunkCallback(SoupMessage* msg, SoupBuffer* chunk, gpointer data) 346 { 347 if (statusWillBeHandledBySoup(msg->status_code)) 348 return; 349 350 RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data); 351 if (!handle) 352 return; 353 ResourceHandleInternal* d = handle->getInternal(); 354 if (d->m_cancelled) 355 return; 356 ResourceHandleClient* client = handle->client(); 357 if (!client) 358 return; 359 360 ASSERT(!d->m_response.isNull()); 361 362 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=19793 363 // -1 means we do not provide any data about transfer size to inspector so it would use 364 // Content-Length headers or content size to show transfer size. 365 client->didReceiveData(handle.get(), chunk->data, chunk->length, -1); 366 } 367 368 static SoupSession* createSoupSession() 369 { 370 return soup_session_async_new(); 371 } 372 373 static void cleanupSoupRequestOperation(ResourceHandle* handle, bool isDestroying = false) 374 { 375 ResourceHandleInternal* d = handle->getInternal(); 376 377 if (d->m_soupRequest) { 378 g_object_set_data(G_OBJECT(d->m_soupRequest.get()), "webkit-resource", 0); 379 d->m_soupRequest.clear(); 380 } 381 382 if (d->m_inputStream) { 383 g_object_set_data(G_OBJECT(d->m_inputStream.get()), "webkit-resource", 0); 384 d->m_inputStream.clear(); 385 } 386 387 d->m_cancellable.clear(); 388 389 if (d->m_soupMessage) { 390 g_signal_handlers_disconnect_matched(d->m_soupMessage.get(), G_SIGNAL_MATCH_DATA, 391 0, 0, 0, 0, handle); 392 d->m_soupMessage.clear(); 393 } 394 395 if (d->m_buffer) { 396 g_slice_free1(READ_BUFFER_SIZE, d->m_buffer); 397 d->m_buffer = 0; 398 } 399 400 if (!isDestroying) 401 handle->deref(); 402 } 403 404 static void sendRequestCallback(GObject* source, GAsyncResult* res, gpointer userData) 405 { 406 RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(g_object_get_data(source, "webkit-resource")); 407 if (!handle) 408 return; 409 410 ResourceHandleInternal* d = handle->getInternal(); 411 ResourceHandleClient* client = handle->client(); 412 413 if (d->m_gotChunkHandler) { 414 // No need to call gotChunkHandler anymore. Received data will 415 // be reported by readCallback 416 if (g_signal_handler_is_connected(d->m_soupMessage.get(), d->m_gotChunkHandler)) 417 g_signal_handler_disconnect(d->m_soupMessage.get(), d->m_gotChunkHandler); 418 } 419 420 if (d->m_cancelled || !client) { 421 cleanupSoupRequestOperation(handle.get()); 422 return; 423 } 424 425 GOwnPtr<GError> error; 426 GInputStream* in = soup_request_send_finish(d->m_soupRequest.get(), res, &error.outPtr()); 427 428 if (error) { 429 SoupMessage* soupMsg = d->m_soupMessage.get(); 430 gboolean isTransportError = d->m_soupMessage && SOUP_STATUS_IS_TRANSPORT_ERROR(soupMsg->status_code); 431 432 if (isTransportError || (error->domain == G_IO_ERROR)) { 433 SoupURI* uri = soup_request_get_uri(d->m_soupRequest.get()); 434 GOwnPtr<char> uriStr(soup_uri_to_string(uri, false)); 435 gint errorCode = isTransportError ? static_cast<gint>(soupMsg->status_code) : error->code; 436 const gchar* errorMsg = isTransportError ? soupMsg->reason_phrase : error->message; 437 const gchar* quarkStr = isTransportError ? g_quark_to_string(SOUP_HTTP_ERROR) : g_quark_to_string(G_IO_ERROR); 438 ResourceError resourceError(quarkStr, errorCode, uriStr.get(), String::fromUTF8(errorMsg)); 439 440 cleanupSoupRequestOperation(handle.get()); 441 client->didFail(handle.get(), resourceError); 442 return; 443 } 444 445 if (d->m_soupMessage && statusWillBeHandledBySoup(d->m_soupMessage->status_code)) { 446 ASSERT(d->m_response.isNull()); 447 448 fillResponseFromMessage(soupMsg, &d->m_response); 449 client->didReceiveResponse(handle.get(), d->m_response); 450 451 // WebCore might have cancelled the job in the while. We 452 // must check for response_body->length and not 453 // response_body->data as libsoup always creates the 454 // SoupBuffer for the body even if the length is 0 455 if (!d->m_cancelled && soupMsg->response_body->length) 456 client->didReceiveData(handle.get(), soupMsg->response_body->data, soupMsg->response_body->length, soupMsg->response_body->length); 457 } 458 459 // didReceiveData above might have cancelled it 460 if (d->m_cancelled || !client) { 461 cleanupSoupRequestOperation(handle.get()); 462 return; 463 } 464 465 client->didFinishLoading(handle.get(), 0); 466 return; 467 } 468 469 if (d->m_cancelled) { 470 cleanupSoupRequestOperation(handle.get()); 471 return; 472 } 473 474 d->m_inputStream = adoptGRef(in); 475 d->m_buffer = static_cast<char*>(g_slice_alloc0(READ_BUFFER_SIZE)); 476 477 // readCallback needs it 478 g_object_set_data(G_OBJECT(d->m_inputStream.get()), "webkit-resource", handle.get()); 479 480 // If not using SoupMessage we need to call didReceiveResponse now. 481 // (This will change later when SoupRequest supports content sniffing.) 482 if (!d->m_soupMessage) { 483 d->m_response.setURL(handle->firstRequest().url()); 484 const gchar* contentType = soup_request_get_content_type(d->m_soupRequest.get()); 485 d->m_response.setMimeType(extractMIMETypeFromMediaType(contentType)); 486 d->m_response.setTextEncodingName(extractCharsetFromMediaType(contentType)); 487 d->m_response.setExpectedContentLength(soup_request_get_content_length(d->m_soupRequest.get())); 488 client->didReceiveResponse(handle.get(), d->m_response); 489 490 if (d->m_cancelled) { 491 cleanupSoupRequestOperation(handle.get()); 492 return; 493 } 494 } 495 496 if (d->m_defersLoading) 497 soup_session_pause_message(handle->defaultSession(), d->m_soupMessage.get()); 498 499 g_input_stream_read_async(d->m_inputStream.get(), d->m_buffer, READ_BUFFER_SIZE, 500 G_PRIORITY_DEFAULT, d->m_cancellable.get(), readCallback, 0); 501 } 502 503 static bool addFormElementsToSoupMessage(SoupMessage* message, const char* contentType, FormData* httpBody, unsigned long& totalBodySize) 504 { 505 size_t numElements = httpBody->elements().size(); 506 if (numElements < 2) { // No file upload is the most common case. 507 Vector<char> body; 508 httpBody->flatten(body); 509 totalBodySize = body.size(); 510 soup_message_set_request(message, contentType, SOUP_MEMORY_COPY, body.data(), body.size()); 511 return true; 512 } 513 514 // We have more than one element to upload, and some may be large files, 515 // which we will want to mmap instead of copying into memory 516 soup_message_body_set_accumulate(message->request_body, FALSE); 517 for (size_t i = 0; i < numElements; i++) { 518 const FormDataElement& element = httpBody->elements()[i]; 519 520 if (element.m_type == FormDataElement::data) { 521 totalBodySize += element.m_data.size(); 522 soup_message_body_append(message->request_body, SOUP_MEMORY_TEMPORARY, 523 element.m_data.data(), element.m_data.size()); 524 continue; 525 } 526 527 // This technique is inspired by libsoup's simple-httpd test. 528 GOwnPtr<GError> error; 529 CString fileName = fileSystemRepresentation(element.m_filename); 530 GMappedFile* fileMapping = g_mapped_file_new(fileName.data(), false, &error.outPtr()); 531 if (error) 532 return false; 533 534 gsize mappedFileSize = g_mapped_file_get_length(fileMapping); 535 totalBodySize += mappedFileSize; 536 SoupBuffer* soupBuffer = soup_buffer_new_with_owner(g_mapped_file_get_contents(fileMapping), 537 mappedFileSize, fileMapping, 538 reinterpret_cast<GDestroyNotify>(g_mapped_file_unref)); 539 soup_message_body_append_buffer(message->request_body, soupBuffer); 540 soup_buffer_free(soupBuffer); 541 } 542 543 return true; 544 } 545 546 static bool startHTTPRequest(ResourceHandle* handle) 547 { 548 ASSERT(handle); 549 550 SoupSession* session = handle->defaultSession(); 551 ensureSessionIsInitialized(session); 552 SoupRequester* requester = SOUP_REQUESTER(soup_session_get_feature(session, SOUP_TYPE_REQUESTER)); 553 554 ResourceHandleInternal* d = handle->getInternal(); 555 556 ResourceRequest request(handle->firstRequest()); 557 KURL url(request.url()); 558 url.removeFragmentIdentifier(); 559 request.setURL(url); 560 561 GOwnPtr<GError> error; 562 d->m_soupRequest = adoptGRef(soup_requester_request(requester, url.string().utf8().data(), &error.outPtr())); 563 if (error) { 564 d->m_soupRequest = 0; 565 return false; 566 } 567 568 g_object_set_data(G_OBJECT(d->m_soupRequest.get()), "webkit-resource", handle); 569 570 d->m_soupMessage = adoptGRef(soup_request_http_get_message(SOUP_REQUEST_HTTP(d->m_soupRequest.get()))); 571 if (!d->m_soupMessage) 572 return false; 573 574 SoupMessage* soupMessage = d->m_soupMessage.get(); 575 request.updateSoupMessage(soupMessage); 576 577 if (!handle->shouldContentSniff()) 578 soup_message_disable_feature(soupMessage, SOUP_TYPE_CONTENT_SNIFFER); 579 else 580 g_signal_connect(soupMessage, "content-sniffed", G_CALLBACK(contentSniffedCallback), handle); 581 582 g_signal_connect(soupMessage, "restarted", G_CALLBACK(restartedCallback), handle); 583 g_signal_connect(soupMessage, "got-headers", G_CALLBACK(gotHeadersCallback), handle); 584 g_signal_connect(soupMessage, "wrote-body-data", G_CALLBACK(wroteBodyDataCallback), handle); 585 d->m_gotChunkHandler = g_signal_connect(soupMessage, "got-chunk", G_CALLBACK(gotChunkCallback), handle); 586 587 String firstPartyString = request.firstPartyForCookies().string(); 588 if (!firstPartyString.isEmpty()) { 589 GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data())); 590 soup_message_set_first_party(soupMessage, firstParty.get()); 591 } 592 593 FormData* httpBody = d->m_firstRequest.httpBody(); 594 CString contentType = d->m_firstRequest.httpContentType().utf8().data(); 595 if (httpBody && !httpBody->isEmpty() 596 && !addFormElementsToSoupMessage(soupMessage, contentType.data(), httpBody, d->m_bodySize)) { 597 // We failed to prepare the body data, so just fail this load. 598 g_signal_handlers_disconnect_matched(soupMessage, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, handle); 599 d->m_soupMessage.clear(); 600 return false; 601 } 602 603 // balanced by a deref() in cleanupSoupRequestOperation, which should always run 604 handle->ref(); 605 606 // Make sure we have an Accept header for subresources; some sites 607 // want this to serve some of their subresources 608 if (!soup_message_headers_get_one(soupMessage->request_headers, "Accept")) 609 soup_message_headers_append(soupMessage->request_headers, "Accept", "*/*"); 610 611 // Send the request only if it's not been explicitely deferred. 612 if (!d->m_defersLoading) { 613 d->m_cancellable = adoptGRef(g_cancellable_new()); 614 soup_request_send_async(d->m_soupRequest.get(), d->m_cancellable.get(), sendRequestCallback, 0); 615 } 616 617 return true; 618 } 619 620 bool ResourceHandle::start(NetworkingContext* context) 621 { 622 ASSERT(!d->m_soupMessage); 623 624 // The frame could be null if the ResourceHandle is not associated to any 625 // Frame, e.g. if we are downloading a file. 626 // If the frame is not null but the page is null this must be an attempted 627 // load from an unload handler, so let's just block it. 628 // If both the frame and the page are not null the context is valid. 629 if (context && !context->isValid()) 630 return false; 631 632 if (!(d->m_user.isEmpty() || d->m_pass.isEmpty())) { 633 // If credentials were specified for this request, add them to the url, 634 // so that they will be passed to NetworkRequest. 635 KURL urlWithCredentials(firstRequest().url()); 636 urlWithCredentials.setUser(d->m_user); 637 urlWithCredentials.setPass(d->m_pass); 638 d->m_firstRequest.setURL(urlWithCredentials); 639 } 640 641 KURL url = firstRequest().url(); 642 String urlString = url.string(); 643 String protocol = url.protocol(); 644 645 // Used to set the authentication dialog toplevel; may be NULL 646 d->m_context = context; 647 648 if (equalIgnoringCase(protocol, "http") || equalIgnoringCase(protocol, "https")) { 649 if (startHTTPRequest(this)) 650 return true; 651 } 652 653 if (startNonHTTPRequest(this, url)) 654 return true; 655 656 // Error must not be reported immediately 657 this->scheduleFailure(InvalidURLFailure); 658 659 return true; 660 } 661 662 void ResourceHandle::cancel() 663 { 664 d->m_cancelled = true; 665 if (d->m_soupMessage) 666 soup_session_cancel_message(defaultSession(), d->m_soupMessage.get(), SOUP_STATUS_CANCELLED); 667 else if (d->m_cancellable) 668 g_cancellable_cancel(d->m_cancellable.get()); 669 } 670 671 PassRefPtr<SharedBuffer> ResourceHandle::bufferedData() 672 { 673 ASSERT_NOT_REACHED(); 674 return 0; 675 } 676 677 bool ResourceHandle::supportsBufferedData() 678 { 679 return false; 680 } 681 682 void ResourceHandle::platformSetDefersLoading(bool defersLoading) 683 { 684 // Initial implementation of this method was required for bug #44157. 685 686 if (d->m_cancelled) 687 return; 688 689 if (!defersLoading && !d->m_cancellable && d->m_soupRequest.get()) { 690 d->m_cancellable = adoptGRef(g_cancellable_new()); 691 soup_request_send_async(d->m_soupRequest.get(), d->m_cancellable.get(), sendRequestCallback, 0); 692 return; 693 } 694 695 // Only supported for http(s) transfers. Something similar would 696 // probably be needed for data transfers done with GIO. 697 if (!d->m_soupMessage) 698 return; 699 700 SoupMessage* soupMessage = d->m_soupMessage.get(); 701 if (soupMessage->status_code != SOUP_STATUS_NONE) 702 return; 703 704 if (defersLoading) 705 soup_session_pause_message(defaultSession(), soupMessage); 706 else 707 soup_session_unpause_message(defaultSession(), soupMessage); 708 } 709 710 bool ResourceHandle::loadsBlocked() 711 { 712 return false; 713 } 714 715 bool ResourceHandle::willLoadFromCache(ResourceRequest&, Frame*) 716 { 717 // Not having this function means that we'll ask the user about re-posting a form 718 // even when we go back to a page that's still in the cache. 719 notImplemented(); 720 return false; 721 } 722 723 void ResourceHandle::loadResourceSynchronously(NetworkingContext* context, const ResourceRequest& request, StoredCredentials /*storedCredentials*/, ResourceError& error, ResourceResponse& response, Vector<char>& data) 724 { 725 WebCoreSynchronousLoader syncLoader(error, response, data); 726 RefPtr<ResourceHandle> handle = create(context, request, &syncLoader, false /*defersLoading*/, false /*shouldContentSniff*/); 727 if (!handle) 728 return; 729 730 // If the request has already failed, do not run the main loop, or else we'll block indefinitely. 731 if (handle->d->m_scheduledFailureType != NoFailure) 732 return; 733 734 syncLoader.run(); 735 } 736 737 static void closeCallback(GObject* source, GAsyncResult* res, gpointer) 738 { 739 RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(g_object_get_data(source, "webkit-resource")); 740 if (!handle) 741 return; 742 743 ResourceHandleInternal* d = handle->getInternal(); 744 g_input_stream_close_finish(d->m_inputStream.get(), res, 0); 745 cleanupSoupRequestOperation(handle.get()); 746 } 747 748 static void readCallback(GObject* source, GAsyncResult* asyncResult, gpointer data) 749 { 750 RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(g_object_get_data(source, "webkit-resource")); 751 if (!handle) 752 return; 753 754 bool convertToUTF16 = static_cast<bool>(data); 755 ResourceHandleInternal* d = handle->getInternal(); 756 ResourceHandleClient* client = handle->client(); 757 758 if (d->m_cancelled || !client) { 759 cleanupSoupRequestOperation(handle.get()); 760 return; 761 } 762 763 GOwnPtr<GError> error; 764 765 gssize bytesRead = g_input_stream_read_finish(d->m_inputStream.get(), asyncResult, &error.outPtr()); 766 if (error) { 767 SoupURI* uri = soup_request_get_uri(d->m_soupRequest.get()); 768 GOwnPtr<char> uriStr(soup_uri_to_string(uri, false)); 769 ResourceError resourceError(g_quark_to_string(G_IO_ERROR), error->code, uriStr.get(), 770 error ? String::fromUTF8(error->message) : String()); 771 cleanupSoupRequestOperation(handle.get()); 772 client->didFail(handle.get(), resourceError); 773 return; 774 } 775 776 if (!bytesRead) { 777 // Finish the load. We do not wait for the stream to 778 // close. Instead we better notify WebCore as soon as possible 779 client->didFinishLoading(handle.get(), 0); 780 781 g_input_stream_close_async(d->m_inputStream.get(), G_PRIORITY_DEFAULT, 782 0, closeCallback, 0); 783 return; 784 } 785 786 // It's mandatory to have sent a response before sending data 787 ASSERT(!d->m_response.isNull()); 788 789 if (G_LIKELY(!convertToUTF16)) 790 client->didReceiveData(handle.get(), d->m_buffer, bytesRead, bytesRead); 791 else { 792 // We have to convert it to UTF-16 due to limitations in KURL 793 String data = String::fromUTF8(d->m_buffer, bytesRead); 794 client->didReceiveData(handle.get(), reinterpret_cast<const char*>(data.characters()), data.length() * sizeof(UChar), bytesRead); 795 } 796 797 // didReceiveData may cancel the load, which may release the last reference. 798 if (d->m_cancelled || !client) { 799 cleanupSoupRequestOperation(handle.get()); 800 return; 801 } 802 803 g_input_stream_read_async(d->m_inputStream.get(), d->m_buffer, READ_BUFFER_SIZE, G_PRIORITY_DEFAULT, 804 d->m_cancellable.get(), readCallback, data); 805 } 806 807 static bool startNonHTTPRequest(ResourceHandle* handle, KURL url) 808 { 809 ASSERT(handle); 810 811 if (handle->firstRequest().httpMethod() != "GET" && handle->firstRequest().httpMethod() != "POST") 812 return false; 813 814 SoupSession* session = handle->defaultSession(); 815 ensureSessionIsInitialized(session); 816 SoupRequester* requester = SOUP_REQUESTER(soup_session_get_feature(session, SOUP_TYPE_REQUESTER)); 817 ResourceHandleInternal* d = handle->getInternal(); 818 819 CString urlStr = url.string().utf8(); 820 821 GOwnPtr<GError> error; 822 d->m_soupRequest = adoptGRef(soup_requester_request(requester, urlStr.data(), &error.outPtr())); 823 if (error) { 824 d->m_soupRequest = 0; 825 return false; 826 } 827 828 g_object_set_data(G_OBJECT(d->m_soupRequest.get()), "webkit-resource", handle); 829 830 // balanced by a deref() in cleanupSoupRequestOperation, which should always run 831 handle->ref(); 832 833 d->m_cancellable = adoptGRef(g_cancellable_new()); 834 soup_request_send_async(d->m_soupRequest.get(), d->m_cancellable.get(), sendRequestCallback, 0); 835 836 return true; 837 } 838 839 SoupSession* ResourceHandle::defaultSession() 840 { 841 static SoupSession* session = createSoupSession(); 842 843 return session; 844 } 845 846 } 847
