static void
tunnel_message_completed (SoupMessage *msg, gpointer user_data)
{
SoupMessageQueueItem *item = user_data;
SoupSession *session = item->session;
if (item->state == SOUP_MESSAGE_RESTARTING) {
soup_message_restarted (msg);
if (item->conn) {
soup_session_send_queue_item (session, item, tunnel_message_completed);
return;
}
soup_message_set_status (msg, SOUP_STATUS_TRY_AGAIN);
}
item->state = SOUP_MESSAGE_FINISHED;
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
if (item->conn)
soup_connection_disconnect (item->conn);
if (msg->status_code == SOUP_STATUS_TRY_AGAIN) {
item->related->state = SOUP_MESSAGE_AWAITING_CONNECTION;
g_object_unref (item->related->conn);
item->related->conn = NULL;
} else
soup_message_set_status (item->related->msg, msg->status_code);
goto done;
}
if (!soup_connection_start_ssl (item->conn)) {
if (item->conn)
soup_connection_disconnect (item->conn);
soup_message_set_status (item->related->msg, SOUP_STATUS_SSL_FAILED);
goto done;
}
g_signal_connect (item->conn, "disconnected",
G_CALLBACK (connection_closed), item->session);
soup_connection_set_state (item->conn, SOUP_CONNECTION_IDLE);
soup_connection_set_state (item->conn, SOUP_CONNECTION_IN_USE);
item->related->state = SOUP_MESSAGE_READY;
done:
soup_message_finished (msg);
if (item->related->msg->status_code)
item->related->state = SOUP_MESSAGE_FINISHING;
do_idle_run_queue (item->session);
soup_message_queue_item_unref (item->related);
soup_session_unqueue_item (session, item);
soup_message_queue_item_unref (item);
g_object_unref (session);
}
static void
soup_message_io_finished (SoupMessage *msg)
{
g_object_ref (msg);
soup_message_io_cleanup (msg);
if (SOUP_MESSAGE_IS_STARTING (msg))
soup_message_restarted (msg);
else
soup_message_finished (msg);
g_object_unref (msg);
}
static void
conditional_get_ready_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
ConditionalHelper *helper = (ConditionalHelper *)user_data;
GSimpleAsyncResult *simple;
SoupHTTPInputStream *httpstream;
simple = g_simple_async_result_new (G_OBJECT (helper->req),
helper->callback, helper->user_data,
conditional_get_ready_cb);
if (msg->status_code == SOUP_STATUS_NOT_MODIFIED) {
SoupCache *cache = (SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE);
httpstream = (SoupHTTPInputStream *)soup_cache_send_response (cache, msg);
if (httpstream) {
g_simple_async_result_set_op_res_gpointer (simple, httpstream, g_object_unref);
soup_message_got_headers (helper->original);
if (soup_session_get_feature_for_message (session, SOUP_TYPE_CONTENT_SNIFFER, helper->original)) {
const char *content_type = soup_message_headers_get_content_type (msg->response_headers, NULL);
soup_message_content_sniffed (helper->original, content_type, NULL);
}
g_simple_async_result_complete (simple);
soup_message_finished (helper->original);
g_object_unref (simple);
} else {
/* Ask again for the resource, somehow the cache cannot locate it */
httpstream = soup_http_input_stream_new (session, helper->original);
soup_http_input_stream_send_async (httpstream, G_PRIORITY_DEFAULT,
helper->cancellable, sent_async, simple);
}
} else {
/* It is in the cache but it was modified remotely */
httpstream = soup_http_input_stream_new (session, helper->original);
soup_http_input_stream_send_async (httpstream, G_PRIORITY_DEFAULT,
helper->cancellable, sent_async, simple);
}
g_object_unref (helper->req);
g_object_unref (helper->original);
g_slice_free (ConditionalHelper, helper);
}
static void
cancel_message (SoupSession *session, SoupMessage *msg, guint status_code)
{
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupMessageQueueItem *item;
item = soup_message_queue_lookup (priv->queue, msg);
if (item) {
if (item->cancellable)
g_cancellable_cancel (item->cancellable);
soup_message_queue_item_unref (item);
}
soup_message_io_stop (msg);
soup_message_set_status (msg, status_code);
soup_message_finished (msg);
}
static void
gdav_request_splice_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
SoupMessage *message;
GTask *task = G_TASK (user_data);
GError *local_error = NULL;
message = g_task_get_task_data (task);
g_output_stream_splice_finish (
G_OUTPUT_STREAM (source_object), result, &local_error);
if (local_error != NULL) {
g_task_return_error (task, local_error);
/* XXX That the input stream's content is not automatically
* copied to the SoupMessage's response_body is a known
* libsoup bug which may be fixed in a future release.
* Check that the response body is empty so we don't
* accidentally duplicate the body. */
} else if (message->response_body->data == NULL) {
GMemoryOutputStream *output_stream;
gpointer data;
gsize size;
output_stream = G_MEMORY_OUTPUT_STREAM (source_object);
size = g_memory_output_stream_get_data_size (output_stream);
data = g_memory_output_stream_steal_data (output_stream);
soup_message_body_append_take (
message->response_body, data, size);
soup_message_body_flatten (message->response_body);
soup_message_finished (message);
g_task_return_boolean (task, TRUE);
} else {
g_task_return_boolean (task, TRUE);
}
g_object_unref (task);
}
static gboolean
send_async_cb (gpointer data)
{
GSimpleAsyncResult *simple;
SoupSession *session;
SendAsyncHelper *helper = (SendAsyncHelper *)data;
session = soup_request_get_session (SOUP_REQUEST (helper->http));
simple = g_simple_async_result_new (G_OBJECT (helper->http),
helper->callback, helper->user_data,
soup_request_http_send_async);
g_simple_async_result_set_op_res_gpointer (simple, helper->httpstream, g_object_unref);
/* Update message status */
soup_message_set_status (helper->http->priv->msg, SOUP_STATUS_OK);
/* Issue signals */
soup_message_got_headers (helper->http->priv->msg);
if (soup_session_get_feature_for_message (session, SOUP_TYPE_CONTENT_SNIFFER, helper->http->priv->msg)) {
const char *content_type = soup_message_headers_get_content_type (helper->http->priv->msg->response_headers, NULL);
soup_message_content_sniffed (helper->http->priv->msg, content_type, NULL);
}
g_simple_async_result_complete (simple);
soup_message_finished (helper->http->priv->msg);
g_object_unref (simple);
g_object_unref (helper->http);
g_slice_free (SendAsyncHelper, helper);
return FALSE;
}
static void
process_queue_item (SoupMessageQueueItem *item,
gboolean *should_prune,
gboolean loop)
{
SoupSession *session = item->session;
SoupProxyURIResolver *proxy_resolver;
do {
switch (item->state) {
case SOUP_MESSAGE_STARTING:
proxy_resolver = (SoupProxyURIResolver *)soup_session_get_feature_for_message (session, SOUP_TYPE_PROXY_URI_RESOLVER, item->msg);
if (!proxy_resolver) {
item->state = SOUP_MESSAGE_AWAITING_CONNECTION;
break;
}
resolve_proxy_addr (item, proxy_resolver);
return;
case SOUP_MESSAGE_AWAITING_CONNECTION:
if (!soup_session_get_connection (session, item, should_prune))
return;
if (soup_connection_get_state (item->conn) != SOUP_CONNECTION_NEW) {
item->state = SOUP_MESSAGE_READY;
break;
}
item->state = SOUP_MESSAGE_CONNECTING;
soup_message_queue_item_ref (item);
g_object_ref (session);
soup_connection_connect_async (item->conn, item->cancellable,
got_connection, item);
return;
case SOUP_MESSAGE_READY:
item->state = SOUP_MESSAGE_RUNNING;
soup_session_send_queue_item (session, item, message_completed);
break;
case SOUP_MESSAGE_RESTARTING:
item->state = SOUP_MESSAGE_STARTING;
soup_message_restarted (item->msg);
break;
case SOUP_MESSAGE_FINISHING:
item->state = SOUP_MESSAGE_FINISHED;
soup_message_finished (item->msg);
if (item->state != SOUP_MESSAGE_FINISHED)
break;
g_object_ref (session);
soup_session_unqueue_item (session, item);
if (item->callback)
item->callback (session, item->msg, item->callback_data);
g_object_unref (item->msg);
do_idle_run_queue (session);
g_object_unref (session);
return;
default:
/* Nothing to do with this message in any
* other state.
*/
return;
}
} while (loop && item->state != SOUP_MESSAGE_FINISHED);
}