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