static void
do_cookies_accept_policy_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
SoupCookieJar *jar;
GSList *l, *p;
int i;
debug_printf (1, "SoupCookieJarAcceptPolicy test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
soup_session_add_feature_by_type (session, SOUP_TYPE_COOKIE_JAR);
jar = SOUP_COOKIE_JAR (soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR));
for (i = 0; i < G_N_ELEMENTS (validResults); i++) {
soup_cookie_jar_set_accept_policy (jar, validResults[i].policy);
uri = soup_uri_new_with_base (first_party_uri, "/index.html");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_set_first_party (msg, first_party_uri);
soup_session_send_message (session, msg);
soup_uri_free (uri);
g_object_unref (msg);
/* We can't use two servers due to limitations in
* test_server, so let's swap first and third party here
* to simulate a cookie coming from a third party.
*/
uri = soup_uri_new_with_base (first_party_uri, "/foo.jpg");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_set_first_party (msg, third_party_uri);
soup_session_send_message (session, msg);
soup_uri_free (uri);
g_object_unref (msg);
l = soup_cookie_jar_all_cookies (jar);
if (g_slist_length (l) < validResults[i].n_cookies) {
debug_printf (1, " accepted less cookies than it should have\n");
errors++;
} else if (g_slist_length (l) > validResults[i].n_cookies) {
debug_printf (1, " accepted more cookies than it should have\n");
errors++;
}
for (p = l; p; p = p->next) {
soup_cookie_jar_delete_cookie (jar, p->data);
soup_cookie_free (p->data);
}
g_slist_free (l);
}
soup_test_session_abort_unref (session);
}
SoupMessage* ResourceRequest::toSoupMessage() const
{
SoupMessage* soupMessage = soup_message_new(httpMethod().utf8().data(), url().string().utf8().data());
if (!soupMessage)
return 0;
const HTTPHeaderMap& headers = httpHeaderFields();
SoupMessageHeaders* soupHeaders = soupMessage->request_headers;
if (!headers.isEmpty()) {
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data());
}
#ifdef HAVE_LIBSOUP_2_29_90
String firstPartyString = firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(soupMessage, firstParty.get());
}
#endif
soup_message_set_flags(soupMessage, m_soupFlags);
// Body data is only handled at ResourceHandleSoup::startHttp for
// now; this is because this may not be a good place to go
// openning and mmapping files. We should maybe revisit this.
return soupMessage;
}
void ResourceRequest::updateSoupMessageMembers(SoupMessage* soupMessage) const
{
updateSoupMessageHeaders(soupMessage->request_headers);
String firstPartyString = firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(soupMessage, firstParty.get());
}
soup_message_set_flags(soupMessage, m_soupFlags);
if (!acceptEncoding())
soup_message_disable_feature(soupMessage, SOUP_TYPE_CONTENT_DECODER);
}
void ResourceRequest::updateSoupMessage(SoupMessage* soupMessage) const
{
g_object_set(soupMessage, SOUP_MESSAGE_METHOD, httpMethod().utf8().data(), NULL);
const HTTPHeaderMap& headers = httpHeaderFields();
SoupMessageHeaders* soupHeaders = soupMessage->request_headers;
if (!headers.isEmpty()) {
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data());
}
String firstPartyString = firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(soupMessage, firstParty.get());
}
soup_message_set_flags(soupMessage, m_soupFlags);
}
void
request_starting_cb(WebKitWebView *web_view, WebKitWebFrame *frame, WebKitWebResource *resource,
WebKitNetworkRequest *request, WebKitNetworkResponse *response, gpointer user_data) {
(void) web_view;
(void) frame;
(void) resource;
(void) response;
(void) user_data;
const gchar *uri = webkit_network_request_get_uri (request);
SoupMessage *message = webkit_network_request_get_message (request);
if (message) {
SoupURI *soup_uri = soup_uri_new (uri);
soup_message_set_first_party (message, soup_uri);
}
if (uzbl.state.verbose)
printf("Request starting -> %s\n", uri);
send_event (REQUEST_STARTING, NULL, TYPE_STR, uri, NULL);
if (uzbl.behave.request_handler) {
GString *result = g_string_new ("");
GArray *a = g_array_new (TRUE, FALSE, sizeof(gchar*));
const CommandInfo *c = parse_command_parts(uzbl.behave.request_handler, a);
if(c) {
g_array_append_val(a, uri);
run_parsed_command(c, a, result);
}
g_array_free(a, TRUE);
if(result->len > 0) {
char *p = strchr(result->str, '\n' );
if ( p != NULL ) *p = '\0';
webkit_network_request_set_uri(request, result->str);
}
g_string_free(result, TRUE);
}
}
// Called each time the message is going to be sent again except the first time.
// It's used mostly to let webkit know about redirects.
static void restartedCallback(SoupMessage* msg, gpointer data)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle)
return;
ResourceHandleInternal* d = handle->getInternal();
if (d->m_cancelled)
return;
char* uri = soup_uri_to_string(soup_message_get_uri(msg), false);
String location = String(uri);
g_free(uri);
KURL newURL = KURL(handle->request().url(), location);
ResourceRequest request = handle->request();
ResourceResponse response;
request.setURL(newURL);
request.setHTTPMethod(msg->method);
fillResponseFromMessage(msg, &response);
// Should not set Referer after a redirect from a secure resource to non-secure one.
if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https")) {
request.clearHTTPReferrer();
soup_message_headers_remove(msg->request_headers, "Referer");
}
if (d->client())
d->client()->willSendRequest(handle, request, response);
if (d->m_cancelled)
return;
#ifdef HAVE_LIBSOUP_2_29_90
// Update the first party in case the base URL changed with the redirect
String firstPartyString = request.firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(d->m_msg, firstParty.get());
}
#endif
}
static bool startHttp(ResourceHandle* handle)
{
ASSERT(handle);
SoupSession* session = handle->defaultSession();
ensureSessionIsInitialized(session);
ResourceHandleInternal* d = handle->getInternal();
ResourceRequest request(handle->request());
KURL url(request.url());
url.removeFragmentIdentifier();
request.setURL(url);
d->m_msg = request.toSoupMessage();
if (!d->m_msg)
return false;
if(!handle->shouldContentSniff())
soup_message_disable_feature(d->m_msg, SOUP_TYPE_CONTENT_SNIFFER);
g_signal_connect(d->m_msg, "restarted", G_CALLBACK(restartedCallback), handle);
g_signal_connect(d->m_msg, "got-headers", G_CALLBACK(gotHeadersCallback), handle);
g_signal_connect(d->m_msg, "content-sniffed", G_CALLBACK(contentSniffedCallback), handle);
g_signal_connect(d->m_msg, "got-chunk", G_CALLBACK(gotChunkCallback), handle);
#ifdef HAVE_LIBSOUP_2_29_90
String firstPartyString = request.firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(d->m_msg, firstParty.get());
}
#endif
g_object_set_data(G_OBJECT(d->m_msg), "resourceHandle", reinterpret_cast<void*>(handle));
FormData* httpBody = d->m_request.httpBody();
if (httpBody && !httpBody->isEmpty()) {
size_t numElements = httpBody->elements().size();
// handle the most common case (i.e. no file upload)
if (numElements < 2) {
Vector<char> body;
httpBody->flatten(body);
soup_message_set_request(d->m_msg, d->m_request.httpContentType().utf8().data(),
SOUP_MEMORY_COPY, body.data(), body.size());
} else {
/*
* we have more than one element to upload, and some may
* be (big) files, which we will want to mmap instead of
* copying into memory; TODO: support upload of non-local
* (think sftp://) files by using GIO?
*/
soup_message_body_set_accumulate(d->m_msg->request_body, FALSE);
for (size_t i = 0; i < numElements; i++) {
const FormDataElement& element = httpBody->elements()[i];
if (element.m_type == FormDataElement::data)
soup_message_body_append(d->m_msg->request_body, SOUP_MEMORY_TEMPORARY, element.m_data.data(), element.m_data.size());
else {
/*
* mapping for uploaded files code inspired by technique used in
* libsoup's simple-httpd test
*/
GError* error = 0;
gchar* fileName = filenameFromString(element.m_filename);
GMappedFile* fileMapping = g_mapped_file_new(fileName, false, &error);
g_free(fileName);
if (error) {
g_error_free(error);
g_signal_handlers_disconnect_matched(d->m_msg, G_SIGNAL_MATCH_DATA,
0, 0, 0, 0, handle);
g_object_unref(d->m_msg);
d->m_msg = 0;
return false;
}
SoupBuffer* soupBuffer = soup_buffer_new_with_owner(g_mapped_file_get_contents(fileMapping),
g_mapped_file_get_length(fileMapping),
fileMapping,
#if GLIB_CHECK_VERSION(2, 21, 3)
reinterpret_cast<GDestroyNotify>(g_mapped_file_unref));
#else
reinterpret_cast<GDestroyNotify>(g_mapped_file_free));
#endif
soup_message_body_append_buffer(d->m_msg->request_body, soupBuffer);
soup_buffer_free(soupBuffer);
}
}
}
}