static void
do_msg_reuse_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
guint *signal_ids, n_signal_ids;
debug_printf (1, "\nSoupMessage reuse\n");
signal_ids = g_signal_list_ids (SOUP_TYPE_MESSAGE, &n_signal_ids);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (reuse_test_authenticate), NULL);
debug_printf (1, " First message\n");
msg = soup_message_new_from_uri ("GET", base_uri);
soup_session_send_message (session, msg);
ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
debug_printf (1, " Redirect message\n");
uri = soup_uri_new_with_base (base_uri, "/redirect");
soup_message_set_uri (msg, uri);
soup_uri_free (uri);
soup_session_send_message (session, msg);
if (!soup_uri_equal (soup_message_get_uri (msg), base_uri)) {
debug_printf (1, " Message did not get redirected!\n");
errors++;
}
ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
debug_printf (1, " Auth message\n");
uri = soup_uri_new_with_base (base_uri, "/auth");
soup_message_set_uri (msg, uri);
soup_uri_free (uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " Message did not get authenticated!\n");
errors++;
}
ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
/* One last try to make sure the auth stuff got cleaned up */
debug_printf (1, " Last message\n");
soup_message_set_uri (msg, base_uri);
soup_session_send_message (session, msg);
ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
soup_test_session_abort_unref (session);
g_object_unref (msg);
g_free (signal_ids);
}
// 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);
// FIXME: This is needed because some servers use broken URIs in
// their Location header, when redirecting, such as URIs with
// white spaces instead of %20; this should be fixed in soup, in
// the future, and this work-around removed.
// See http://bugzilla.gnome.org/show_bug.cgi?id=575378.
SoupURI* soup_uri = soup_uri_new(newURL.string().utf8().data());
soup_message_set_uri(msg, soup_uri);
soup_uri_free(soup_uri);
ResourceRequest request = handle->request();
ResourceResponse response;
request.setURL(newURL);
fillResponseFromMessage(msg, &response);
if (d->client())
d->client()->willSendRequest(handle, request, response);
}
static void
redirect_handler (SoupMessage *msg, gpointer user_data)
{
if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
CallbackInfo *info = user_data;
SoupURI *new_uri;
const gchar *new_loc;
new_loc = soup_message_headers_get (msg->response_headers, "Location");
if (!new_loc)
return;
info->reset=1;
new_uri = soup_uri_new_with_base (soup_message_get_uri (msg), new_loc);
if (!new_uri) {
soup_message_set_status_full (msg,
SOUP_STATUS_MALFORMED,
"Invalid Redirect URL");
return;
}
soup_message_set_uri (msg, new_uri);
soup_session_requeue_message (info->ss, msg);
soup_uri_free (new_uri);
}
}
void ResourceRequest::updateSoupMessage(SoupMessage* soupMessage) const
{
g_object_set(soupMessage, SOUP_MESSAGE_METHOD, httpMethod().utf8().data(), NULL);
GOwnPtr<SoupURI> uri(soupURI());
soup_message_set_uri(soupMessage, uri.get());
updateSoupMessageMembers(soupMessage);
}
static void
soup_session_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
DQTask *task = user_data;
if (SOUP_STATUS_IS_REDIRECTION (msg->status_code))
{
const char *header =
soup_message_headers_get_one (msg->response_headers, "Location");
if (header)
{
SoupURI *uri;
uri = soup_uri_new_with_base (soup_message_get_uri (msg), header);
soup_message_set_uri (msg, uri);
soup_uri_free (uri);
soup_session_requeue_message (session, msg);
return;
}
}
else if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))
{
void *cache;
task->any.callback (task->any.queue, task->any.uri,
msg->response_body->data,
msg->response_body->length,
NULL,
task->any.userdata);
/* add the contents to the cache */
cache = g_memdup (msg->response_body->data, msg->response_body->length);
mex_download_queue_cache_insert (task->any.queue, task->any.uri, cache,
msg->response_body->length);
}
else if (msg->status_code != SOUP_STATUS_CANCELLED)
{
/* FIXME: Also create an error on failure */
task->any.callback (task->any.queue, task->any.uri,
NULL, 0, NULL,
task->any.userdata);
}
/* The message is unref'd by the session */
task->soup.message = NULL;
mex_download_queue_free (task);
}
/**
* webkit_network_request_set_uri:
* @request: a #WebKitNetworkRequest
* @uri: an URI
*
* Sets the URI held and used by the given request. When the request
* has an associated #SoupMessage, its URI will also be set by this
* call.
*
*/
void webkit_network_request_set_uri(WebKitNetworkRequest* request, const gchar* uri)
{
g_return_if_fail(WEBKIT_IS_NETWORK_REQUEST(request));
g_return_if_fail(uri);
WebKitNetworkRequestPrivate* priv = request->priv;
if (priv->uri)
g_free(priv->uri);
priv->uri = g_strdup(uri);
if (!priv->message)
return;
SoupURI* soupURI = soup_uri_new(uri);
g_return_if_fail(soupURI);
soup_message_set_uri(priv->message, soupURI);
soup_uri_free(soupURI);
}
/**
* webkit_network_response_set_uri:
* @response: a #WebKitNetworkResponse
* @uri: an URI
*
* Sets the URI held and used by the given response. When the response
* has an associated #SoupMessage, its URI will also be set by this
* call.
*
* Since: 1.1.14
*/
void webkit_network_response_set_uri(WebKitNetworkResponse* response, const gchar* uri)
{
g_return_if_fail(WEBKIT_IS_NETWORK_RESPONSE(response));
g_return_if_fail(uri);
WebKitNetworkResponsePrivate* priv = response->priv;
if (priv->uri)
g_free(priv->uri);
priv->uri = g_strdup(uri);
if (!priv->message)
return;
SoupURI* soupURI = soup_uri_new(uri);
g_return_if_fail(soupURI);
soup_message_set_uri(priv->message, soupURI);
soup_uri_free(soupURI);
}
static void
redirect_handler (SoupMessage *msg, gpointer user_data)
{
SoupSession *session = user_data;
const char *new_loc;
SoupURI *new_uri;
new_loc = soup_message_headers_get_one (msg->response_headers,
"Location");
g_return_if_fail (new_loc != NULL);
if (msg->status_code == SOUP_STATUS_SEE_OTHER ||
(msg->status_code == SOUP_STATUS_FOUND &&
!SOUP_METHOD_IS_SAFE (msg->method))) {
/* Redirect using a GET */
g_object_set (msg,
SOUP_MESSAGE_METHOD, SOUP_METHOD_GET,
NULL);
soup_message_set_request (msg, NULL,
SOUP_MEMORY_STATIC, NULL, 0);
soup_message_headers_set_encoding (msg->request_headers,
SOUP_ENCODING_NONE);
} else if (msg->status_code == SOUP_STATUS_MOVED_PERMANENTLY ||
msg->status_code == SOUP_STATUS_TEMPORARY_REDIRECT ||
msg->status_code == SOUP_STATUS_FOUND) {
/* Don't redirect non-safe methods */
if (!SOUP_METHOD_IS_SAFE (msg->method))
return;
} else {
/* Three possibilities:
*
* 1) This was a non-3xx response that happened to
* have a "Location" header
* 2) It's a non-redirecty 3xx response (300, 304,
* 305, 306)
* 3) It's some newly-defined 3xx response (308+)
*
* We ignore all of these cases. In the first two,
* redirecting would be explicitly wrong, and in the
* last case, we have no clue if the 3xx response is
* supposed to be redirecty or non-redirecty. Plus,
* 2616 says unrecognized status codes should be
* treated as the equivalent to the x00 code, and we
* don't redirect on 300, so therefore we shouldn't
* redirect on 308+ either.
*/
return;
}
/* Location is supposed to be an absolute URI, but some sites
* are lame, so we use soup_uri_new_with_base().
*/
new_uri = soup_uri_new_with_base (soup_message_get_uri (msg), new_loc);
if (!new_uri) {
soup_message_set_status_full (msg,
SOUP_STATUS_MALFORMED,
"Invalid Redirect URL");
return;
}
soup_message_set_uri (msg, new_uri);
soup_uri_free (new_uri);
soup_session_requeue_message (session, msg);
}
static guint
parse_request_headers (SoupMessage *msg, char *headers, guint headers_len,
SoupEncoding *encoding, gpointer sock)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
char *req_method, *req_path, *url;
SoupHTTPVersion version;
const char *req_host;
guint status;
SoupURI *uri;
status = soup_headers_parse_request (headers, headers_len,
msg->request_headers,
&req_method,
&req_path,
&version);
if (!SOUP_STATUS_IS_SUCCESSFUL (status))
return status;
g_object_set (G_OBJECT (msg),
SOUP_MESSAGE_METHOD, req_method,
SOUP_MESSAGE_HTTP_VERSION, version,
NULL);
g_free (req_method);
/* Handle request body encoding */
*encoding = soup_message_headers_get_encoding (msg->request_headers);
if (*encoding == SOUP_ENCODING_UNRECOGNIZED) {
if (soup_message_headers_get_list (msg->request_headers, "Transfer-Encoding"))
return SOUP_STATUS_NOT_IMPLEMENTED;
else
return SOUP_STATUS_BAD_REQUEST;
}
/* Generate correct context for request */
req_host = soup_message_headers_get_one (msg->request_headers, "Host");
if (req_host && strchr (req_host, '/')) {
g_free (req_path);
return SOUP_STATUS_BAD_REQUEST;
}
if (!strcmp (req_path, "*") && req_host) {
/* Eg, "OPTIONS * HTTP/1.1" */
url = g_strdup_printf ("%s://%s",
soup_socket_is_ssl (sock) ? "https" : "http",
req_host);
uri = soup_uri_new (url);
if (uri)
soup_uri_set_path (uri, "*");
g_free (url);
} else if (*req_path != '/') {
/* Must be an absolute URI */
uri = soup_uri_new (req_path);
} else if (req_host) {
url = g_strdup_printf ("%s://%s%s",
soup_socket_is_ssl (sock) ? "https" : "http",
req_host, req_path);
uri = soup_uri_new (url);
g_free (url);
} else if (priv->http_version == SOUP_HTTP_1_0) {
/* No Host header, no AbsoluteUri */
SoupAddress *addr = soup_socket_get_local_address (sock);
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, soup_socket_is_ssl (sock) ?
SOUP_URI_SCHEME_HTTPS :
SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (uri, soup_address_get_physical (addr));
soup_uri_set_port (uri, soup_address_get_port (addr));
soup_uri_set_path (uri, req_path);
} else
uri = NULL;
g_free (req_path);
if (!SOUP_URI_VALID_FOR_HTTP (uri)) {
/* certainly not "a valid host on the server" (RFC2616 5.2.3)
* SOUP_URI_VALID_FOR_HTTP also guards against uri == NULL
*/
if (uri)
soup_uri_free (uri);
return SOUP_STATUS_BAD_REQUEST;
}
soup_message_set_uri (msg, uri);
soup_uri_free (uri);
return SOUP_STATUS_OK;
}