static void
run_queue (SoupSessionAsync *sa)
{
SoupSession *session = SOUP_SESSION (sa);
SoupMessageQueue *queue = soup_session_get_queue (session);
SoupMessageQueueItem *item;
SoupProxyURIResolver *proxy_resolver;
SoupMessage *msg;
SoupConnection *conn;
gboolean try_pruning = TRUE, should_prune = FALSE;
soup_session_cleanup_connections (session, FALSE);
try_again:
for (item = soup_message_queue_first (queue);
item && !should_prune;
item = soup_message_queue_next (queue, item)) {
msg = item->msg;
/* CONNECT messages are handled specially */
if (msg->method == SOUP_METHOD_CONNECT)
continue;
if (soup_message_io_in_progress (msg))
continue;
if (!item->resolved_proxy_addr) {
proxy_resolver = (SoupProxyURIResolver *)soup_session_get_feature_for_message (session, SOUP_TYPE_PROXY_URI_RESOLVER, msg);
if (proxy_resolver) {
resolve_proxy_addr (item, proxy_resolver);
continue;
} else
item->resolved_proxy_addr = TRUE;
}
conn = soup_session_get_connection (session, item,
&should_prune);
if (!conn)
continue;
if (soup_connection_get_state (conn) == SOUP_CONNECTION_NEW) {
soup_connection_connect_async (conn, got_connection,
session);
} else
soup_session_send_queue_item (session, item, conn);
}
if (item)
soup_message_queue_item_unref (item);
if (try_pruning && should_prune) {
/* There is at least one message in the queue that
* could be sent if we pruned an idle connection from
* some other server.
*/
if (soup_session_cleanup_connections (session, TRUE)) {
try_pruning = should_prune = FALSE;
goto try_again;
}
}
}
static void
queue_message (SoupSession *session, SoupMessage *req,
SoupSessionCallback callback, gpointer user_data)
{
SoupMessageQueueItem *item;
SOUP_SESSION_CLASS (soup_session_async_parent_class)->queue_message (session, req, callback, user_data);
item = soup_message_queue_lookup (soup_session_get_queue (session), req);
g_return_if_fail (item != NULL);
g_signal_connect (req, "restarted",
G_CALLBACK (request_restarted), item);
g_signal_connect_after (req, "finished",
G_CALLBACK (final_finished), item);
do_idle_run_queue (session);
}
static guint
send_message (SoupSession *session, SoupMessage *req)
{
SoupMessageQueueItem *item;
GMainContext *async_context =
soup_session_get_async_context (session);
/* Balance out the unref that queuing will eventually do */
g_object_ref (req);
queue_message (session, req, NULL, NULL);
item = soup_message_queue_lookup (soup_session_get_queue (session), req);
g_return_val_if_fail (item != NULL, SOUP_STATUS_MALFORMED);
while (item->state != SOUP_MESSAGE_FINISHED)
g_main_context_iteration (async_context, TRUE);
soup_message_queue_item_unref (item);
return req->status_code;
}
static void
run_queue (SoupSessionAsync *sa)
{
SoupSession *session = SOUP_SESSION (sa);
SoupMessageQueue *queue = soup_session_get_queue (session);
SoupMessageQueueItem *item;
SoupMessage *msg;
gboolean try_pruning = TRUE, should_prune = FALSE;
g_object_ref (session);
soup_session_cleanup_connections (session, FALSE);
try_again:
for (item = soup_message_queue_first (queue);
item && !should_prune;
item = soup_message_queue_next (queue, item)) {
msg = item->msg;
/* CONNECT messages are handled specially */
if (msg->method != SOUP_METHOD_CONNECT)
process_queue_item (item, &should_prune, TRUE);
}
if (item)
soup_message_queue_item_unref (item);
if (try_pruning && should_prune) {
/* There is at least one message in the queue that
* could be sent if we pruned an idle connection from
* some other server.
*/
if (soup_session_cleanup_connections (session, TRUE)) {
try_pruning = should_prune = FALSE;
goto try_again;
}
}
g_object_unref (session);
}
static void
authenticate_auth (SoupAuthManager *manager, SoupAuth *auth,
SoupMessage *msg, gboolean prior_auth_failed,
gboolean proxy, gboolean can_interact)
{
SoupAuthManagerPrivate *priv = manager->priv;
SoupURI *uri;
if (proxy) {
SoupMessageQueue *queue;
SoupMessageQueueItem *item;
queue = soup_session_get_queue (priv->session);
item = soup_message_queue_lookup (queue, msg);
if (item) {
uri = soup_connection_get_proxy_uri (item->conn);
soup_message_queue_item_unref (item);
} else
uri = NULL;
if (!uri)
return;
} else
uri = soup_message_get_uri (msg);
/* If a password is specified explicitly in the URI, use it
* even if the auth had previously already been authenticated.
*/
if (uri->password && uri->user) {
soup_auth_authenticate (auth, uri->user, uri->password);
soup_uri_set_password (uri, NULL);
soup_uri_set_user (uri, NULL);
} else if (!soup_auth_is_authenticated (auth) && can_interact) {
g_signal_emit (manager, signals[AUTHENTICATE], 0,
msg, auth, prior_auth_failed);
}
}
static void
cancel_message (SoupSession *session, SoupMessage *msg,
guint status_code)
{
SoupMessageQueue *queue;
SoupMessageQueueItem *item;
gboolean dummy;
SOUP_SESSION_CLASS (soup_session_async_parent_class)->
cancel_message (session, msg, status_code);
queue = soup_session_get_queue (session);
item = soup_message_queue_lookup (queue, msg);
if (!item || item->state != SOUP_MESSAGE_FINISHING)
return;
/* Force it to finish immediately, so that
* soup_session_abort (session); g_object_unref (session);
* will work.
*/
process_queue_item (item, &dummy, FALSE);
soup_message_queue_item_unref (item);
}
