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); }