ResourceHandleSoup.cpp [plain text]
#include "config.h"
#include "ResourceHandle.h"
#if USE(SOUP)
#include "CookieJarSoup.h"
#include "CredentialStorage.h"
#include "FileSystem.h"
#include "GUniquePtrSoup.h"
#include "HTTPParsers.h"
#include "LocalizedStrings.h"
#include "MIMETypeRegistry.h"
#include "NetworkingContext.h"
#include "NotImplemented.h"
#include "ResourceError.h"
#include "ResourceHandleClient.h"
#include "ResourceHandleInternal.h"
#include "ResourceResponse.h"
#include "SharedBuffer.h"
#include "SoupNetworkSession.h"
#include "TextEncoding.h"
#include <errno.h>
#include <fcntl.h>
#include <gio/gio.h>
#include <glib.h>
#include <libsoup/soup.h>
#include <sys/stat.h>
#include <sys/types.h>
#if !COMPILER(MSVC)
#include <unistd.h>
#endif
#include <wtf/CurrentTime.h>
#include <wtf/SHA1.h>
#include <wtf/gobject/GRefPtr.h>
#include <wtf/text/Base64.h>
#include <wtf/text/CString.h>
#include "BlobData.h"
#include "BlobRegistryImpl.h"
#if PLATFORM(GTK)
#include "CredentialBackingStore.h"
#endif
namespace WebCore {
static bool loadingSynchronousRequest = false;
static const size_t gDefaultReadBufferSize = 8192;
class WebCoreSynchronousLoader : public ResourceHandleClient {
WTF_MAKE_NONCOPYABLE(WebCoreSynchronousLoader);
public:
WebCoreSynchronousLoader(ResourceError& error, ResourceResponse& response, SoupSession* session, Vector<char>& data, StoredCredentials storedCredentials)
: m_error(error)
, m_response(response)
, m_session(session)
, m_data(data)
, m_finished(false)
, m_storedCredentials(storedCredentials)
{
loadingSynchronousRequest = true;
GRefPtr<GMainContext> innerMainContext = adoptGRef(g_main_context_new());
g_main_context_push_thread_default(innerMainContext.get());
m_mainLoop = adoptGRef(g_main_loop_new(innerMainContext.get(), false));
adjustMaxConnections(1);
}
~WebCoreSynchronousLoader()
{
adjustMaxConnections(-1);
GMainContext* context = g_main_context_get_thread_default();
while (g_main_context_pending(context))
g_main_context_iteration(context, FALSE);
g_main_context_pop_thread_default(context);
loadingSynchronousRequest = false;
}
void adjustMaxConnections(int adjustment)
{
int maxConnections, maxConnectionsPerHost;
g_object_get(m_session,
SOUP_SESSION_MAX_CONNS, &maxConnections,
SOUP_SESSION_MAX_CONNS_PER_HOST, &maxConnectionsPerHost,
NULL);
maxConnections += adjustment;
maxConnectionsPerHost += adjustment;
g_object_set(m_session,
SOUP_SESSION_MAX_CONNS, maxConnections,
SOUP_SESSION_MAX_CONNS_PER_HOST, maxConnectionsPerHost,
NULL);
}
virtual bool isSynchronousClient()
{
return true;
}
virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
{
m_response = response;
}
virtual void didReceiveData(ResourceHandle*, const char* , unsigned , int)
{
ASSERT_NOT_REACHED();
}
virtual void didReceiveBuffer(ResourceHandle*, PassRefPtr<SharedBuffer> buffer, int )
{
const char* segment;
unsigned position = 0;
while (unsigned length = buffer->getSomeData(segment, position)) {
m_data.append(segment, length);
position += length;
}
}
virtual void didFinishLoading(ResourceHandle*, double)
{
if (g_main_loop_is_running(m_mainLoop.get()))
g_main_loop_quit(m_mainLoop.get());
m_finished = true;
}
virtual void didFail(ResourceHandle* handle, const ResourceError& error)
{
m_error = error;
didFinishLoading(handle, 0);
}
virtual void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge& challenge)
{
challenge.authenticationClient()->receivedRequestToContinueWithoutCredential(challenge);
}
virtual bool shouldUseCredentialStorage(ResourceHandle*)
{
return m_storedCredentials == AllowStoredCredentials;
}
void run()
{
if (!m_finished)
g_main_loop_run(m_mainLoop.get());
}
private:
ResourceError& m_error;
ResourceResponse& m_response;
SoupSession* m_session;
Vector<char>& m_data;
bool m_finished;
GRefPtr<GMainLoop> m_mainLoop;
StoredCredentials m_storedCredentials;
};
class HostTLSCertificateSet {
public:
void add(GTlsCertificate* certificate)
{
String certificateHash = computeCertificateHash(certificate);
if (!certificateHash.isEmpty())
m_certificates.add(certificateHash);
}
bool contains(GTlsCertificate* certificate)
{
return m_certificates.contains(computeCertificateHash(certificate));
}
private:
static String computeCertificateHash(GTlsCertificate* certificate)
{
GRefPtr<GByteArray> certificateData;
g_object_get(G_OBJECT(certificate), "certificate", &certificateData.outPtr(), NULL);
if (!certificateData)
return String();
SHA1 sha1;
sha1.addBytes(certificateData->data, certificateData->len);
SHA1::Digest digest;
sha1.computeHash(digest);
return base64Encode(reinterpret_cast<const char*>(digest.data()), SHA1::hashSize);
}
HashSet<String> m_certificates;
};
static bool createSoupRequestAndMessageForHandle(ResourceHandle*, const ResourceRequest&, bool isHTTPFamilyRequest);
static void cleanupSoupRequestOperation(ResourceHandle*, bool isDestroying = false);
static void sendRequestCallback(GObject*, GAsyncResult*, gpointer);
static void readCallback(GObject*, GAsyncResult*, gpointer);
static gboolean requestTimeoutCallback(void*);
#if ENABLE(WEB_TIMING)
static int milisecondsSinceRequest(double requestTime);
#endif
static void continueAfterDidReceiveResponse(ResourceHandle*);
static bool gIgnoreSSLErrors = false;
static HashSet<String>& allowsAnyHTTPSCertificateHosts()
{
DEPRECATED_DEFINE_STATIC_LOCAL(HashSet<String>, hosts, ());
return hosts;
}
typedef HashMap<String, HostTLSCertificateSet> CertificatesMap;
static CertificatesMap& clientCertificates()
{
DEPRECATED_DEFINE_STATIC_LOCAL(CertificatesMap, certificates, ());
return certificates;
}
ResourceHandleInternal::~ResourceHandleInternal()
{
}
static SoupSession* sessionFromContext(NetworkingContext* context)
{
if (!context || !context->isValid())
return SoupNetworkSession::defaultSession().soupSession();
return context->storageSession().soupNetworkSession().soupSession();
}
ResourceHandle::~ResourceHandle()
{
cleanupSoupRequestOperation(this, true);
}
SoupSession* ResourceHandleInternal::soupSession()
{
return sessionFromContext(m_context.get());
}
bool ResourceHandle::cancelledOrClientless()
{
if (!client())
return true;
return getInternal()->m_cancelled;
}
void ResourceHandle::ensureReadBuffer()
{
ResourceHandleInternal* d = getInternal();
if (d->m_soupBuffer)
return;
size_t bufferSize;
char* bufferFromClient = client()->getOrCreateReadBuffer(gDefaultReadBufferSize, bufferSize);
if (bufferFromClient)
d->m_soupBuffer.reset(soup_buffer_new(SOUP_MEMORY_TEMPORARY, bufferFromClient, bufferSize));
else
d->m_soupBuffer.reset(soup_buffer_new(SOUP_MEMORY_TAKE, static_cast<char*>(g_malloc(gDefaultReadBufferSize)), gDefaultReadBufferSize));
ASSERT(d->m_soupBuffer);
}
static bool isAuthenticationFailureStatusCode(int httpStatusCode)
{
return httpStatusCode == SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED || httpStatusCode == SOUP_STATUS_UNAUTHORIZED;
}
static void gotHeadersCallback(SoupMessage* message, gpointer data)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle || handle->cancelledOrClientless())
return;
ResourceHandleInternal* d = handle->getInternal();
#if PLATFORM(GTK)
if (!isAuthenticationFailureStatusCode(message->status_code) && message->status_code < 500 && !d->m_credentialDataToSaveInPersistentStore.credential.isEmpty()) {
credentialBackingStore().storeCredentialsForChallenge(
d->m_credentialDataToSaveInPersistentStore.challenge,
d->m_credentialDataToSaveInPersistentStore.credential);
}
#endif
d->m_response.updateFromSoupMessage(message);
}
static void applyAuthenticationToRequest(ResourceHandle* handle, ResourceRequest& request, bool redirect)
{
ResourceHandleInternal* d = handle->getInternal();
if (handle->shouldUseCredentialStorage()) {
if (d->m_user.isEmpty() && d->m_pass.isEmpty())
d->m_initialCredential = CredentialStorage::get(request.url());
else if (!redirect) {
CredentialStorage::set(Credential(d->m_user, d->m_pass, CredentialPersistenceNone), request.url());
}
}
String user = d->m_user;
String password = d->m_pass;
if (!d->m_initialCredential.isEmpty()) {
user = d->m_initialCredential.user();
password = d->m_initialCredential.password();
}
if (user.isEmpty() && password.isEmpty()) {
d->m_useAuthenticationManager = handle->shouldUseCredentialStorage();
return;
}
URL urlWithCredentials(request.url());
urlWithCredentials.setUser(user);
urlWithCredentials.setPass(password);
request.setURL(urlWithCredentials);
}
#if ENABLE(WEB_TIMING)
static void restartedCallback(SoupMessage*, gpointer data)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle || handle->cancelledOrClientless())
return;
handle->m_requestTime = monotonicallyIncreasingTime();
}
#endif
static bool shouldRedirect(ResourceHandle* handle)
{
ResourceHandleInternal* d = handle->getInternal();
SoupMessage* message = d->m_soupMessage.get();
if (message->status_code == 300 || message->status_code == 304 || message->status_code == 305 || message->status_code == 306)
return false;
if (!soup_message_headers_get_one(message->response_headers, "Location"))
return false;
return true;
}
static bool shouldRedirectAsGET(SoupMessage* message, URL& newURL, bool crossOrigin)
{
if (message->method == SOUP_METHOD_GET || message->method == SOUP_METHOD_HEAD)
return false;
if (!newURL.protocolIsInHTTPFamily())
return true;
switch (message->status_code) {
case SOUP_STATUS_SEE_OTHER:
return true;
case SOUP_STATUS_FOUND:
case SOUP_STATUS_MOVED_PERMANENTLY:
if (message->method == SOUP_METHOD_POST)
return true;
break;
}
if (crossOrigin && message->method == SOUP_METHOD_DELETE)
return true;
return false;
}
static void continueAfterWillSendRequest(ResourceHandle* handle, const ResourceRequest& request)
{
if (handle->cancelledOrClientless())
return;
ResourceRequest newRequest(request);
ResourceHandleInternal* d = handle->getInternal();
if (protocolHostAndPortAreEqual(newRequest.url(), d->m_response.url()))
applyAuthenticationToRequest(handle, newRequest, true);
if (!createSoupRequestAndMessageForHandle(handle, newRequest, true)) {
d->client()->cannotShowURL(handle);
return;
}
handle->sendPendingRequest();
}
static void doRedirect(ResourceHandle* handle)
{
ResourceHandleInternal* d = handle->getInternal();
static const int maxRedirects = 20;
if (d->m_redirectCount++ > maxRedirects) {
d->client()->didFail(handle, ResourceError::transportError(d->m_soupRequest.get(), SOUP_STATUS_TOO_MANY_REDIRECTS, "Too many redirects"));
cleanupSoupRequestOperation(handle);
return;
}
ResourceRequest newRequest = handle->firstRequest();
SoupMessage* message = d->m_soupMessage.get();
const char* location = soup_message_headers_get_one(message->response_headers, "Location");
URL newURL = URL(URL(soup_message_get_uri(message)), location);
bool crossOrigin = !protocolHostAndPortAreEqual(handle->firstRequest().url(), newURL);
newRequest.setURL(newURL);
newRequest.setFirstPartyForCookies(newURL);
if (newRequest.httpMethod() != "GET") {
if (message->method == SOUP_METHOD_GET || shouldRedirectAsGET(message, newURL, crossOrigin)) {
newRequest.setHTTPMethod("GET");
newRequest.setHTTPBody(0);
newRequest.clearHTTPContentType();
}
}
if (!newURL.protocolIs("https") && protocolIs(newRequest.httpReferrer(), "https") && handle->context()->shouldClearReferrerOnHTTPSToHTTPRedirect())
newRequest.clearHTTPReferrer();
d->m_user = newURL.user();
d->m_pass = newURL.pass();
newRequest.removeCredentials();
if (crossOrigin) {
newRequest.clearHTTPAuthorization();
}
cleanupSoupRequestOperation(handle);
if (d->client()->usesAsyncCallbacks())
d->client()->willSendRequestAsync(handle, newRequest, d->m_response);
else {
d->client()->willSendRequest(handle, newRequest, d->m_response);
continueAfterWillSendRequest(handle, newRequest);
}
}
static void redirectSkipCallback(GObject*, GAsyncResult* asyncResult, gpointer data)
{
RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data);
if (handle->cancelledOrClientless()) {
cleanupSoupRequestOperation(handle.get());
return;
}
GUniqueOutPtr<GError> error;
ResourceHandleInternal* d = handle->getInternal();
gssize bytesSkipped = g_input_stream_skip_finish(d->m_inputStream.get(), asyncResult, &error.outPtr());
if (error) {
handle->client()->didFail(handle.get(), ResourceError::genericGError(error.get(), d->m_soupRequest.get()));
cleanupSoupRequestOperation(handle.get());
return;
}
if (bytesSkipped > 0) {
g_input_stream_skip_async(d->m_inputStream.get(), gDefaultReadBufferSize, G_PRIORITY_DEFAULT,
d->m_cancellable.get(), redirectSkipCallback, handle.get());
return;
}
g_input_stream_close(d->m_inputStream.get(), 0, 0);
doRedirect(handle.get());
}
static void wroteBodyDataCallback(SoupMessage*, SoupBuffer* buffer, gpointer data)
{
RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data);
if (!handle)
return;
ASSERT(buffer);
ResourceHandleInternal* d = handle->getInternal();
d->m_bodyDataSent += buffer->length;
if (handle->cancelledOrClientless())
return;
handle->client()->didSendData(handle.get(), d->m_bodyDataSent, d->m_bodySize);
}
static void cleanupSoupRequestOperation(ResourceHandle* handle, bool isDestroying)
{
ResourceHandleInternal* d = handle->getInternal();
d->m_soupRequest.clear();
d->m_inputStream.clear();
d->m_multipartInputStream.clear();
d->m_cancellable.clear();
d->m_soupBuffer.reset();
if (d->m_soupMessage) {
g_signal_handlers_disconnect_matched(d->m_soupMessage.get(), G_SIGNAL_MATCH_DATA,
0, 0, 0, 0, handle);
g_object_set_data(G_OBJECT(d->m_soupMessage.get()), "handle", 0);
d->m_soupMessage.clear();
}
if (d->m_timeoutSource) {
g_source_destroy(d->m_timeoutSource.get());
d->m_timeoutSource.clear();
}
if (!isDestroying)
handle->deref();
}
static bool handleUnignoredTLSErrors(ResourceHandle* handle)
{
ResourceHandleInternal* d = handle->getInternal();
const ResourceResponse& response = d->m_response;
if (!response.soupMessageTLSErrors() || gIgnoreSSLErrors)
return false;
String lowercaseHostURL = handle->firstRequest().url().host().lower();
if (allowsAnyHTTPSCertificateHosts().contains(lowercaseHostURL))
return false;
CertificatesMap::iterator i = clientCertificates().find(lowercaseHostURL);
if (i != clientCertificates().end() && i->value.contains(response.soupMessageCertificate()))
return false;
handle->client()->didFail(handle, ResourceError::tlsError(d->m_soupRequest.get(), response.soupMessageTLSErrors(), response.soupMessageCertificate()));
return true;
}
size_t ResourceHandle::currentStreamPosition() const
{
GInputStream* baseStream = d->m_inputStream.get();
while (!G_IS_SEEKABLE(baseStream) && G_IS_FILTER_INPUT_STREAM(baseStream))
baseStream = g_filter_input_stream_get_base_stream(G_FILTER_INPUT_STREAM(baseStream));
if (!G_IS_SEEKABLE(baseStream))
return 0;
return g_seekable_tell(G_SEEKABLE(baseStream));
}
static void nextMultipartResponsePartCallback(GObject* , GAsyncResult* result, gpointer data)
{
RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data);
if (handle->cancelledOrClientless()) {
cleanupSoupRequestOperation(handle.get());
return;
}
ResourceHandleInternal* d = handle->getInternal();
ASSERT(!d->m_inputStream);
GUniqueOutPtr<GError> error;
d->m_inputStream = adoptGRef(soup_multipart_input_stream_next_part_finish(d->m_multipartInputStream.get(), result, &error.outPtr()));
if (error) {
handle->client()->didFail(handle.get(), ResourceError::httpError(d->m_soupMessage.get(), error.get(), d->m_soupRequest.get()));
cleanupSoupRequestOperation(handle.get());
return;
}
if (!d->m_inputStream) {
handle->client()->didFinishLoading(handle.get(), 0);
cleanupSoupRequestOperation(handle.get());
return;
}
d->m_response = ResourceResponse();
d->m_response.setURL(handle->firstRequest().url());
d->m_response.updateFromSoupMessageHeaders(soup_multipart_input_stream_get_headers(d->m_multipartInputStream.get()));
d->m_previousPosition = 0;
if (handle->client()->usesAsyncCallbacks())
handle->client()->didReceiveResponseAsync(handle.get(), d->m_response);
else {
handle->client()->didReceiveResponse(handle.get(), d->m_response);
continueAfterDidReceiveResponse(handle.get());
}
}
static void sendRequestCallback(GObject*, GAsyncResult* result, gpointer data)
{
RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data);
if (handle->cancelledOrClientless()) {
cleanupSoupRequestOperation(handle.get());
return;
}
ResourceHandleInternal* d = handle->getInternal();
SoupMessage* soupMessage = d->m_soupMessage.get();
if (d->m_defersLoading) {
d->m_deferredResult = result;
return;
}
GUniqueOutPtr<GError> error;
GRefPtr<GInputStream> inputStream = adoptGRef(soup_request_send_finish(d->m_soupRequest.get(), result, &error.outPtr()));
if (error) {
handle->client()->didFail(handle.get(), ResourceError::httpError(soupMessage, error.get(), d->m_soupRequest.get()));
cleanupSoupRequestOperation(handle.get());
return;
}
if (soupMessage) {
if (handle->shouldContentSniff() && soupMessage->status_code != SOUP_STATUS_NOT_MODIFIED) {
const char* sniffedType = soup_request_get_content_type(d->m_soupRequest.get());
d->m_response.setSniffedContentType(sniffedType);
}
d->m_response.updateFromSoupMessage(soupMessage);
if (handleUnignoredTLSErrors(handle.get())) {
cleanupSoupRequestOperation(handle.get());
return;
}
if (SOUP_STATUS_IS_REDIRECTION(soupMessage->status_code) && shouldRedirect(handle.get())) {
d->m_inputStream = inputStream;
g_input_stream_skip_async(d->m_inputStream.get(), gDefaultReadBufferSize, G_PRIORITY_DEFAULT,
d->m_cancellable.get(), redirectSkipCallback, handle.get());
return;
}
} else {
d->m_response.setURL(handle->firstRequest().url());
const gchar* contentType = soup_request_get_content_type(d->m_soupRequest.get());
d->m_response.setMimeType(extractMIMETypeFromMediaType(contentType));
d->m_response.setTextEncodingName(extractCharsetFromMediaType(contentType));
d->m_response.setExpectedContentLength(soup_request_get_content_length(d->m_soupRequest.get()));
}
#if ENABLE(WEB_TIMING)
d->m_response.resourceLoadTiming().responseStart = milisecondsSinceRequest(handle->m_requestTime);
#endif
if (soupMessage && d->m_response.isMultipart())
d->m_multipartInputStream = adoptGRef(soup_multipart_input_stream_new(soupMessage, inputStream.get()));
else
d->m_inputStream = inputStream;
if (d->client()->usesAsyncCallbacks())
handle->client()->didReceiveResponseAsync(handle.get(), d->m_response);
else {
handle->client()->didReceiveResponse(handle.get(), d->m_response);
continueAfterDidReceiveResponse(handle.get());
}
}
static void continueAfterDidReceiveResponse(ResourceHandle* handle)
{
if (handle->cancelledOrClientless()) {
cleanupSoupRequestOperation(handle);
return;
}
ResourceHandleInternal* d = handle->getInternal();
if (d->m_soupMessage && d->m_multipartInputStream && !d->m_inputStream) {
soup_multipart_input_stream_next_part_async(d->m_multipartInputStream.get(), G_PRIORITY_DEFAULT,
d->m_cancellable.get(), nextMultipartResponsePartCallback, handle);
return;
}
ASSERT(d->m_inputStream);
handle->ensureReadBuffer();
g_input_stream_read_async(d->m_inputStream.get(), const_cast<char*>(d->m_soupBuffer->data), d->m_soupBuffer->length,
G_PRIORITY_DEFAULT, d->m_cancellable.get(), readCallback, handle);
}
static bool addFileToSoupMessageBody(SoupMessage* message, const String& fileNameString, size_t offset, size_t lengthToSend, unsigned long& totalBodySize)
{
GUniqueOutPtr<GError> error;
CString fileName = fileSystemRepresentation(fileNameString);
GMappedFile* fileMapping = g_mapped_file_new(fileName.data(), false, &error.outPtr());
if (error)
return false;
gsize bufferLength = lengthToSend;
if (!lengthToSend)
bufferLength = g_mapped_file_get_length(fileMapping);
totalBodySize += bufferLength;
SoupBuffer* soupBuffer = soup_buffer_new_with_owner(g_mapped_file_get_contents(fileMapping) + offset,
bufferLength,
fileMapping,
reinterpret_cast<GDestroyNotify>(g_mapped_file_unref));
soup_message_body_append_buffer(message->request_body, soupBuffer);
soup_buffer_free(soupBuffer);
return true;
}
static bool blobIsOutOfDate(const BlobDataItem& blobItem)
{
ASSERT(blobItem.type == BlobDataItem::File);
if (!isValidFileTime(blobItem.file->expectedModificationTime()))
return false;
time_t fileModificationTime;
if (!getFileModificationTime(blobItem.file->path(), fileModificationTime))
return true;
return fileModificationTime != static_cast<time_t>(blobItem.file->expectedModificationTime());
}
static void addEncodedBlobItemToSoupMessageBody(SoupMessage* message, const BlobDataItem& blobItem, unsigned long& totalBodySize)
{
if (blobItem.type == BlobDataItem::Data) {
totalBodySize += blobItem.length();
soup_message_body_append(message->request_body, SOUP_MEMORY_TEMPORARY, blobItem.data->data() + blobItem.offset(), blobItem.length());
return;
}
ASSERT(blobItem.type == BlobDataItem::File);
if (blobIsOutOfDate(blobItem))
return;
addFileToSoupMessageBody(message, blobItem.file->path(), blobItem.offset(), blobItem.length() == BlobDataItem::toEndOfFile ? 0 : blobItem.length(), totalBodySize);
}
static void addEncodedBlobToSoupMessageBody(SoupMessage* message, const FormDataElement& element, unsigned long& totalBodySize)
{
RefPtr<BlobData> blobData = static_cast<BlobRegistryImpl&>(blobRegistry()).getBlobDataFromURL(URL(ParsedURLString, element.m_url));
if (!blobData)
return;
for (size_t i = 0; i < blobData->items().size(); ++i)
addEncodedBlobItemToSoupMessageBody(message, blobData->items()[i], totalBodySize);
}
static bool addFormElementsToSoupMessage(SoupMessage* message, const char*, FormData* httpBody, unsigned long& totalBodySize)
{
soup_message_body_set_accumulate(message->request_body, FALSE);
size_t numElements = httpBody->elements().size();
for (size_t i = 0; i < numElements; i++) {
const FormDataElement& element = httpBody->elements()[i];
if (element.m_type == FormDataElement::Type::Data) {
totalBodySize += element.m_data.size();
soup_message_body_append(message->request_body, SOUP_MEMORY_TEMPORARY,
element.m_data.data(), element.m_data.size());
continue;
}
if (element.m_type == FormDataElement::Type::EncodedFile) {
if (!addFileToSoupMessageBody(message ,
element.m_filename,
0 ,
0 ,
totalBodySize))
return false;
continue;
}
ASSERT(element.m_type == FormDataElement::Type::EncodedBlob);
addEncodedBlobToSoupMessageBody(message, element, totalBodySize);
}
return true;
}
#if ENABLE(WEB_TIMING)
static int milisecondsSinceRequest(double requestTime)
{
return static_cast<int>((monotonicallyIncreasingTime() - requestTime) * 1000.0);
}
void ResourceHandle::didStartRequest()
{
getInternal()->m_response.resourceLoadTiming().requestStart = milisecondsSinceRequest(m_requestTime);
}
static void networkEventCallback(SoupMessage*, GSocketClientEvent event, GIOStream*, gpointer data)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle)
return;
if (handle->cancelledOrClientless())
return;
ResourceHandleInternal* d = handle->getInternal();
int deltaTime = milisecondsSinceRequest(handle->m_requestTime);
switch (event) {
case G_SOCKET_CLIENT_RESOLVING:
d->m_response.resourceLoadTiming().domainLookupStart = deltaTime;
break;
case G_SOCKET_CLIENT_RESOLVED:
d->m_response.resourceLoadTiming().domainLookupEnd = deltaTime;
break;
case G_SOCKET_CLIENT_CONNECTING:
d->m_response.resourceLoadTiming().connectStart = deltaTime;
if (d->m_response.resourceLoadTiming().domainLookupStart != -1) {
d->m_response.resourceLoadTiming().connectStart -=
d->m_response.resourceLoadTiming().domainLookupEnd - d->m_response.resourceLoadTiming().domainLookupStart;
}
break;
case G_SOCKET_CLIENT_CONNECTED:
break;
case G_SOCKET_CLIENT_PROXY_NEGOTIATING:
break;
case G_SOCKET_CLIENT_PROXY_NEGOTIATED:
break;
case G_SOCKET_CLIENT_TLS_HANDSHAKING:
d->m_response.resourceLoadTiming().secureConnectionStart = deltaTime;
break;
case G_SOCKET_CLIENT_TLS_HANDSHAKED:
break;
case G_SOCKET_CLIENT_COMPLETE:
d->m_response.resourceLoadTiming().connectEnd = deltaTime;
break;
default:
ASSERT_NOT_REACHED();
break;
}
}
#endif
static bool createSoupMessageForHandleAndRequest(ResourceHandle* handle, const ResourceRequest& request)
{
ASSERT(handle);
ResourceHandleInternal* d = handle->getInternal();
ASSERT(d->m_soupRequest);
d->m_soupMessage = adoptGRef(soup_request_http_get_message(SOUP_REQUEST_HTTP(d->m_soupRequest.get())));
if (!d->m_soupMessage)
return false;
SoupMessage* soupMessage = d->m_soupMessage.get();
request.updateSoupMessage(soupMessage);
g_object_set_data(G_OBJECT(soupMessage), "handle", handle);
if (!handle->shouldContentSniff())
soup_message_disable_feature(soupMessage, SOUP_TYPE_CONTENT_SNIFFER);
if (!d->m_useAuthenticationManager)
soup_message_disable_feature(soupMessage, SOUP_TYPE_AUTH_MANAGER);
FormData* httpBody = request.httpBody();
CString contentType = request.httpContentType().utf8().data();
if (httpBody && !httpBody->isEmpty() && !addFormElementsToSoupMessage(soupMessage, contentType.data(), httpBody, d->m_bodySize)) {
d->m_soupMessage.clear();
return false;
}
if (!soup_message_headers_get_one(soupMessage->request_headers, "Accept"))
soup_message_headers_append(soupMessage->request_headers, "Accept", "*/*");
if ((request.httpMethod() == "POST" || request.httpMethod() == "PUT")
&& (!request.httpBody() || request.httpBody()->isEmpty()))
soup_message_headers_set_content_length(soupMessage->request_headers, 0);
g_signal_connect(d->m_soupMessage.get(), "got-headers", G_CALLBACK(gotHeadersCallback), handle);
g_signal_connect(d->m_soupMessage.get(), "wrote-body-data", G_CALLBACK(wroteBodyDataCallback), handle);
soup_message_set_flags(d->m_soupMessage.get(), static_cast<SoupMessageFlags>(soup_message_get_flags(d->m_soupMessage.get()) | SOUP_MESSAGE_NO_REDIRECT));
#if ENABLE(WEB_TIMING)
g_signal_connect(d->m_soupMessage.get(), "network-event", G_CALLBACK(networkEventCallback), handle);
g_signal_connect(d->m_soupMessage.get(), "restarted", G_CALLBACK(restartedCallback), handle);
#endif
#if SOUP_CHECK_VERSION(2, 43, 1)
soup_message_set_priority(d->m_soupMessage.get(), toSoupMessagePriority(request.priority()));
#endif
return true;
}
static bool createSoupRequestAndMessageForHandle(ResourceHandle* handle, const ResourceRequest& request, bool isHTTPFamilyRequest)
{
ResourceHandleInternal* d = handle->getInternal();
GUniquePtr<SoupURI> soupURI = request.createSoupURI();
if (!soupURI)
return false;
GUniqueOutPtr<GError> error;
d->m_soupRequest = adoptGRef(soup_session_request_uri(d->soupSession(), soupURI.get(), &error.outPtr()));
if (error) {
d->m_soupRequest.clear();
return false;
}
if (isHTTPFamilyRequest && !createSoupMessageForHandleAndRequest(handle, request)) {
d->m_soupRequest.clear();
return false;
}
request.updateSoupRequest(d->m_soupRequest.get());
return true;
}
bool ResourceHandle::start()
{
ASSERT(!d->m_soupMessage);
if (d->m_context && !d->m_context->isValid())
return false;
const ResourceRequest& request = firstRequest();
bool isHTTPFamilyRequest = request.url().protocolIsInHTTPFamily();
if (!isHTTPFamilyRequest && request.httpMethod() != "GET" && request.httpMethod() != "POST") {
this->scheduleFailure(InvalidURLFailure); return true;
}
applyAuthenticationToRequest(this, firstRequest(), false);
if (!createSoupRequestAndMessageForHandle(this, request, isHTTPFamilyRequest)) {
this->scheduleFailure(InvalidURLFailure); return true;
}
if (!d->m_defersLoading)
sendPendingRequest();
return true;
}
void ResourceHandle::sendPendingRequest()
{
#if ENABLE(WEB_TIMING)
m_requestTime = monotonicallyIncreasingTime();
#endif
if (d->m_firstRequest.timeoutInterval() > 0) {
d->m_timeoutSource = soup_add_timeout(g_main_context_get_thread_default(),
d->m_firstRequest.timeoutInterval() * 1000, requestTimeoutCallback, this);
}
ref();
d->m_cancellable = adoptGRef(g_cancellable_new());
soup_request_send_async(d->m_soupRequest.get(), d->m_cancellable.get(), sendRequestCallback, this);
}
void ResourceHandle::cancel()
{
d->m_cancelled = true;
if (d->m_soupMessage)
soup_session_cancel_message(d->soupSession(), d->m_soupMessage.get(), SOUP_STATUS_CANCELLED);
else if (d->m_cancellable)
g_cancellable_cancel(d->m_cancellable.get());
}
bool ResourceHandle::shouldUseCredentialStorage()
{
return (!client() || client()->shouldUseCredentialStorage(this)) && firstRequest().url().protocolIsInHTTPFamily();
}
void ResourceHandle::setHostAllowsAnyHTTPSCertificate(const String& host)
{
allowsAnyHTTPSCertificateHosts().add(host.lower());
}
void ResourceHandle::setClientCertificate(const String& host, GTlsCertificate* certificate)
{
clientCertificates().add(host.lower(), HostTLSCertificateSet()).iterator->value.add(certificate);
}
void ResourceHandle::setIgnoreSSLErrors(bool ignoreSSLErrors)
{
gIgnoreSSLErrors = ignoreSSLErrors;
}
#if PLATFORM(GTK)
void getCredentialFromPersistentStoreCallback(const Credential& credential, void* data)
{
static_cast<ResourceHandle*>(data)->continueDidReceiveAuthenticationChallenge(credential);
}
#endif
void ResourceHandle::continueDidReceiveAuthenticationChallenge(const Credential& credentialFromPersistentStorage)
{
ASSERT(!d->m_currentWebChallenge.isNull());
AuthenticationChallenge& challenge = d->m_currentWebChallenge;
ASSERT(challenge.soupSession());
ASSERT(challenge.soupMessage());
if (!credentialFromPersistentStorage.isEmpty())
challenge.setProposedCredential(credentialFromPersistentStorage);
if (!client()) {
soup_session_unpause_message(challenge.soupSession(), challenge.soupMessage());
clearAuthentication();
return;
}
ASSERT(challenge.soupSession());
ASSERT(challenge.soupMessage());
client()->didReceiveAuthenticationChallenge(this, challenge);
}
void ResourceHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge& challenge)
{
ASSERT(d->m_currentWebChallenge.isNull());
bool useCredentialStorage = shouldUseCredentialStorage();
if (useCredentialStorage) {
if (!d->m_initialCredential.isEmpty() || challenge.previousFailureCount()) {
CredentialStorage::remove(challenge.protectionSpace());
}
if (!challenge.previousFailureCount()) {
Credential credential = CredentialStorage::get(challenge.protectionSpace());
if (!credential.isEmpty() && credential != d->m_initialCredential) {
ASSERT(credential.persistence() == CredentialPersistenceNone);
if (isAuthenticationFailureStatusCode(challenge.failureResponse().httpStatusCode()))
CredentialStorage::set(credential, challenge.protectionSpace(), challenge.failureResponse().url());
soup_auth_authenticate(challenge.soupAuth(), credential.user().utf8().data(), credential.password().utf8().data());
return;
}
}
}
d->m_currentWebChallenge = challenge;
soup_session_pause_message(challenge.soupSession(), challenge.soupMessage());
#if PLATFORM(GTK)
if (useCredentialStorage) {
credentialBackingStore().credentialForChallenge(challenge, getCredentialFromPersistentStoreCallback, this);
return;
}
#endif
continueDidReceiveAuthenticationChallenge(Credential());
}
void ResourceHandle::receivedRequestToContinueWithoutCredential(const AuthenticationChallenge& challenge)
{
ASSERT(!challenge.isNull());
if (challenge != d->m_currentWebChallenge)
return;
soup_session_unpause_message(challenge.soupSession(), challenge.soupMessage());
clearAuthentication();
}
void ResourceHandle::receivedCredential(const AuthenticationChallenge& challenge, const Credential& credential)
{
ASSERT(!challenge.isNull());
if (challenge != d->m_currentWebChallenge)
return;
if (credential.isEmpty()) {
receivedRequestToContinueWithoutCredential(challenge);
return;
}
if (shouldUseCredentialStorage()) {
if (credential.persistence() == CredentialPersistenceForSession || credential.persistence() == CredentialPersistencePermanent)
CredentialStorage::set(credential, challenge.protectionSpace(), challenge.failureResponse().url());
#if PLATFORM(GTK)
if (credential.persistence() == CredentialPersistencePermanent) {
d->m_credentialDataToSaveInPersistentStore.credential = credential;
d->m_credentialDataToSaveInPersistentStore.challenge = challenge;
}
#endif
}
ASSERT(challenge.soupSession());
ASSERT(challenge.soupMessage());
soup_auth_authenticate(challenge.soupAuth(), credential.user().utf8().data(), credential.password().utf8().data());
soup_session_unpause_message(challenge.soupSession(), challenge.soupMessage());
clearAuthentication();
}
void ResourceHandle::receivedCancellation(const AuthenticationChallenge& challenge)
{
ASSERT(!challenge.isNull());
if (challenge != d->m_currentWebChallenge)
return;
if (cancelledOrClientless()) {
clearAuthentication();
return;
}
ASSERT(challenge.soupSession());
ASSERT(challenge.soupMessage());
soup_session_unpause_message(challenge.soupSession(), challenge.soupMessage());
if (client())
client()->receivedCancellation(this, challenge);
clearAuthentication();
}
void ResourceHandle::receivedRequestToPerformDefaultHandling(const AuthenticationChallenge&)
{
ASSERT_NOT_REACHED();
}
void ResourceHandle::receivedChallengeRejection(const AuthenticationChallenge&)
{
ASSERT_NOT_REACHED();
}
static bool waitingToSendRequest(ResourceHandle* handle)
{
return handle->getInternal()->m_soupRequest && !handle->getInternal()->m_cancellable;
}
void ResourceHandle::platformSetDefersLoading(bool defersLoading)
{
if (cancelledOrClientless())
return;
if (defersLoading) {
if (d->m_timeoutSource) {
g_source_destroy(d->m_timeoutSource.get());
d->m_timeoutSource.clear();
}
return;
}
if (waitingToSendRequest(this)) {
sendPendingRequest();
return;
}
if (d->m_deferredResult) {
GRefPtr<GAsyncResult> asyncResult = adoptGRef(d->m_deferredResult.leakRef());
if (d->m_inputStream)
readCallback(G_OBJECT(d->m_inputStream.get()), asyncResult.get(), this);
else
sendRequestCallback(G_OBJECT(d->m_soupRequest.get()), asyncResult.get(), this);
}
}
bool ResourceHandle::loadsBlocked()
{
return false;
}
void ResourceHandle::platformLoadResourceSynchronously(NetworkingContext* context, const ResourceRequest& request, StoredCredentials storedCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& data)
{
ASSERT(!loadingSynchronousRequest);
if (loadingSynchronousRequest) return;
WebCoreSynchronousLoader syncLoader(error, response, sessionFromContext(context), data, storedCredentials);
RefPtr<ResourceHandle> handle = create(context, request, &syncLoader, false , false );
if (!handle)
return;
if (handle->d->m_scheduledFailureType != NoFailure)
return;
syncLoader.run();
}
static void readCallback(GObject*, GAsyncResult* asyncResult, gpointer data)
{
RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data);
if (handle->cancelledOrClientless()) {
cleanupSoupRequestOperation(handle.get());
return;
}
ResourceHandleInternal* d = handle->getInternal();
if (d->m_defersLoading) {
d->m_deferredResult = asyncResult;
return;
}
GUniqueOutPtr<GError> error;
gssize bytesRead = g_input_stream_read_finish(d->m_inputStream.get(), asyncResult, &error.outPtr());
if (error) {
handle->client()->didFail(handle.get(), ResourceError::genericGError(error.get(), d->m_soupRequest.get()));
cleanupSoupRequestOperation(handle.get());
return;
}
if (!bytesRead) {
if (d->m_soupMessage && d->m_multipartInputStream) {
d->m_inputStream.clear();
soup_multipart_input_stream_next_part_async(d->m_multipartInputStream.get(), G_PRIORITY_DEFAULT,
d->m_cancellable.get(), nextMultipartResponsePartCallback, handle.get());
return;
}
g_input_stream_close(d->m_inputStream.get(), 0, 0);
handle->client()->didFinishLoading(handle.get(), 0);
cleanupSoupRequestOperation(handle.get());
return;
}
ASSERT(!d->m_response.isNull());
size_t currentPosition = handle->currentStreamPosition();
size_t encodedDataLength = currentPosition ? currentPosition - d->m_previousPosition : bytesRead;
ASSERT(d->m_soupBuffer);
d->m_soupBuffer->length = bytesRead; handle->client()->didReceiveBuffer(handle.get(), SharedBuffer::wrapSoupBuffer(d->m_soupBuffer.release()), encodedDataLength);
d->m_previousPosition = currentPosition;
if (handle->cancelledOrClientless()) {
cleanupSoupRequestOperation(handle.get());
return;
}
handle->ensureReadBuffer();
g_input_stream_read_async(d->m_inputStream.get(), const_cast<char*>(d->m_soupBuffer->data), d->m_soupBuffer->length, G_PRIORITY_DEFAULT,
d->m_cancellable.get(), readCallback, handle.get());
}
void ResourceHandle::continueWillSendRequest(const ResourceRequest& request)
{
ASSERT(client());
ASSERT(client()->usesAsyncCallbacks());
continueAfterWillSendRequest(this, request);
}
void ResourceHandle::continueDidReceiveResponse()
{
ASSERT(client());
ASSERT(client()->usesAsyncCallbacks());
continueAfterDidReceiveResponse(this);
}
static gboolean requestTimeoutCallback(gpointer data)
{
RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data);
handle->client()->didFail(handle.get(), ResourceError::timeoutError(handle->getInternal()->m_firstRequest.url().string()));
handle->cancel();
return FALSE;
}
}
#endif