static void
tunnel_connected (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupMessageQueueItem *item =
soup_message_queue_lookup (priv->queue, msg);
/* Clear the connection's proxy_uri, since it is now
* (effectively) directly connected.
*/
g_object_set (item->conn,
SOUP_CONNECTION_PROXY_URI, NULL,
NULL);
}
}
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
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
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);
}
SoupMessageQueueItem *
soup_session_make_connect_message (SoupSession *session,
SoupAddress *server_addr)
{
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupURI *uri;
SoupMessage *msg;
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTPS);
soup_uri_set_host (uri, soup_address_get_name (server_addr));
soup_uri_set_port (uri, soup_address_get_port (server_addr));
soup_uri_set_path (uri, "");
msg = soup_message_new_from_uri (SOUP_METHOD_CONNECT, uri);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_uri_free (uri);
/* Call the base implementation of soup_session_queue_message
* directly, to add msg to the SoupMessageQueue and cause all
* the right signals to be emitted.
*/
queue_message (session, msg, tunnel_connected, NULL);
return soup_message_queue_lookup (priv->queue, msg);
}
