[libsoup/http2: 5/10] SoupSessionHost: split from SoupSession
- From: Dan Winship <danw src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libsoup/http2: 5/10] SoupSessionHost: split from SoupSession
- Date: Tue, 10 Dec 2013 17:29:02 +0000 (UTC)
commit 3f8e0d45cdf97f999c3f9362578b2ff0871021f2
Author: Dan Winship <danw gnome org>
Date: Mon Dec 9 12:16:05 2013 +0100
SoupSessionHost: split from SoupSession
HTTP/2.0 will need to do connection management differently, so let's
split SoupSessionHost out of soup-session.c in preparation for making
it more complicated.
(The split is a little bit awkward at the moment but will hopefully be
cleaned up some.)
libsoup/Makefile.am | 2 +
libsoup/soup-connection.c | 8 +-
libsoup/soup-connection.h | 1 -
libsoup/soup-misc-private.h | 4 +
libsoup/soup-misc.c | 17 ++-
libsoup/soup-session-host.c | 249 +++++++++++++++++++++++++++++++++++++++
libsoup/soup-session-host.h | 57 +++++++++
libsoup/soup-session-private.h | 2 +
libsoup/soup-session.c | 255 ++++++++++++----------------------------
9 files changed, 407 insertions(+), 188 deletions(-)
---
diff --git a/libsoup/Makefile.am b/libsoup/Makefile.am
index 32502df..73b4fb5 100644
--- a/libsoup/Makefile.am
+++ b/libsoup/Makefile.am
@@ -181,6 +181,8 @@ libsoup_2_4_la_SOURCES = \
soup-session.c \
soup-session-async.c \
soup-session-feature.c \
+ soup-session-host.c \
+ soup-session-host.h \
soup-session-private.h \
soup-session-sync.c \
soup-socket.c \
diff --git a/libsoup/soup-connection.c b/libsoup/soup-connection.c
index 32a52c0..f59a9f8 100644
--- a/libsoup/soup-connection.c
+++ b/libsoup/soup-connection.c
@@ -44,7 +44,6 @@ enum {
PROP_0,
PROP_REMOTE_URI,
- PROP_SSL,
PROP_SSL_FALLBACK,
PROP_SOCKET_PROPERTIES,
PROP_STATE,
@@ -101,9 +100,7 @@ soup_connection_set_property (GObject *object, guint prop_id,
switch (prop_id) {
case PROP_REMOTE_URI:
priv->remote_uri = g_value_dup_boxed (value);
- break;
- case PROP_SSL:
- priv->ssl = g_value_get_boolean (value);
+ priv->ssl = (priv->remote_uri->scheme == SOUP_URI_SCHEME_HTTPS);
break;
case PROP_SSL_FALLBACK:
priv->ssl_fallback = g_value_get_boolean (value);
@@ -130,9 +127,6 @@ soup_connection_get_property (GObject *object, guint prop_id,
case PROP_REMOTE_URI:
g_value_set_boxed (value, priv->remote_uri);
break;
- case PROP_SSL:
- g_value_set_boolean (value, priv->ssl);
- break;
case PROP_SSL_FALLBACK:
g_value_set_boolean (value, priv->ssl_fallback);
break;
diff --git a/libsoup/soup-connection.h b/libsoup/soup-connection.h
index 3fd6721..8df6112 100644
--- a/libsoup/soup-connection.h
+++ b/libsoup/soup-connection.h
@@ -36,7 +36,6 @@ GType soup_connection_get_type (void);
#define SOUP_CONNECTION_REMOTE_URI "remote-uri"
-#define SOUP_CONNECTION_SSL "ssl"
#define SOUP_CONNECTION_SSL_FALLBACK "ssl-fallback"
#define SOUP_CONNECTION_SOCKET_PROPERTIES "socket-properties"
#define SOUP_CONNECTION_STATE "state"
diff --git a/libsoup/soup-misc-private.h b/libsoup/soup-misc-private.h
index 52b815e..01253c7 100644
--- a/libsoup/soup-misc-private.h
+++ b/libsoup/soup-misc-private.h
@@ -66,6 +66,10 @@ SoupURI *soup_socket_get_http_proxy_uri (SoupSocket *sock);
GSource *soup_add_completion_reffed (GMainContext *async_context,
GSourceFunc function,
gpointer data);
+GSource *soup_add_timeout_reffed (GMainContext *async_context,
+ guint interval,
+ GSourceFunc function,
+ gpointer data);
guint soup_message_headers_get_ranges_internal (SoupMessageHeaders *hdrs,
goffset total_length,
diff --git a/libsoup/soup-misc.c b/libsoup/soup-misc.c
index 325b587..747a5d4 100644
--- a/libsoup/soup-misc.c
+++ b/libsoup/soup-misc.c
@@ -153,6 +153,17 @@ soup_add_completion (GMainContext *async_context,
return source;
}
+GSource *
+soup_add_timeout_reffed (GMainContext *async_context,
+ guint interval,
+ GSourceFunc function, gpointer data)
+{
+ GSource *source = g_timeout_source_new (interval);
+ g_source_set_callback (source, function, data, NULL);
+ g_source_attach (source, async_context);
+ return source;
+}
+
/**
* soup_add_timeout: (skip)
* @async_context: (allow-none): the #GMainContext to dispatch the I/O
@@ -172,9 +183,9 @@ soup_add_timeout (GMainContext *async_context,
guint interval,
GSourceFunc function, gpointer data)
{
- GSource *source = g_timeout_source_new (interval);
- g_source_set_callback (source, function, data, NULL);
- g_source_attach (source, async_context);
+ GSource *source;
+
+ source = soup_add_timeout_reffed (async_context, interval, function, data);
g_source_unref (source);
return source;
}
diff --git a/libsoup/soup-session-host.c b/libsoup/soup-session-host.c
new file mode 100644
index 0000000..ba3e7f6
--- /dev/null
+++ b/libsoup/soup-session-host.c
@@ -0,0 +1,249 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * soup-session-host.c
+ *
+ * Copyright 2013 Red Hat, Inc.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "soup-session-host.h"
+#include "soup.h"
+#include "soup-connection.h"
+#include "soup-misc-private.h"
+#include "soup-session-private.h"
+#include "soup-socket-properties.h"
+
+G_DEFINE_TYPE (SoupSessionHost, soup_session_host, G_TYPE_OBJECT)
+
+typedef struct {
+ SoupURI *uri;
+ SoupAddress *addr;
+
+ GSList *connections; /* CONTAINS: SoupConnection */
+ guint num_conns;
+ guint max_conns;
+
+ guint num_messages;
+
+ gboolean ssl_fallback;
+
+ GSource *keep_alive_src;
+ SoupSession *session;
+} SoupSessionHostPrivate;
+#define SOUP_SESSION_HOST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SESSION_HOST,
SoupSessionHostPrivate))
+
+enum {
+ UNUSED,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+#define HOST_KEEP_ALIVE 5 * 60 * 1000 /* 5 min in msecs */
+
+static void
+soup_session_host_init (SoupSessionHost *host)
+{
+}
+
+static void
+soup_session_host_finalize (GObject *object)
+{
+ SoupSessionHostPrivate *priv = SOUP_SESSION_HOST_GET_PRIVATE (object);
+
+ g_warn_if_fail (priv->connections == NULL);
+
+ if (priv->keep_alive_src) {
+ g_source_destroy (priv->keep_alive_src);
+ g_source_unref (priv->keep_alive_src);
+ }
+
+ soup_uri_free (priv->uri);
+ g_object_unref (priv->addr);
+
+ G_OBJECT_CLASS (soup_session_host_parent_class)->finalize (object);
+}
+
+static void
+soup_session_host_class_init (SoupSessionHostClass *host_class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (host_class);
+
+ g_type_class_add_private (host_class, sizeof (SoupSessionHostClass));
+
+ object_class->finalize = soup_session_host_finalize;
+
+ signals[UNUSED] =
+ g_signal_new ("unused",
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL,
+ NULL,
+ G_TYPE_NONE, 0);
+
+}
+
+SoupSessionHost *
+soup_session_host_new (SoupSession *session,
+ SoupURI *uri)
+{
+ SoupSessionHost *host;
+ SoupSessionHostPrivate *priv;
+
+ host = g_object_new (SOUP_TYPE_SESSION_HOST, NULL);
+ priv = SOUP_SESSION_HOST_GET_PRIVATE (host);
+
+ priv->uri = soup_uri_copy_host (uri);
+ priv->addr = g_object_new (SOUP_TYPE_ADDRESS,
+ SOUP_ADDRESS_NAME, priv->uri->host,
+ SOUP_ADDRESS_PORT, priv->uri->port,
+ SOUP_ADDRESS_PROTOCOL, priv->uri->scheme,
+ NULL);
+ priv->keep_alive_src = NULL;
+ priv->session = session;
+
+ g_object_get (G_OBJECT (session),
+ SOUP_SESSION_MAX_CONNS_PER_HOST, &priv->max_conns,
+ NULL);
+
+ return host;
+}
+
+SoupURI *
+soup_session_host_get_uri (SoupSessionHost *host)
+{
+ return SOUP_SESSION_HOST_GET_PRIVATE (host)->uri;
+}
+
+SoupAddress *
+soup_session_host_get_address (SoupSessionHost *host)
+{
+ return SOUP_SESSION_HOST_GET_PRIVATE (host)->addr;
+}
+
+void
+soup_session_host_add_message (SoupSessionHost *host,
+ SoupMessage *msg)
+{
+ SOUP_SESSION_HOST_GET_PRIVATE (host)->num_messages++;
+}
+
+void
+soup_session_host_remove_message (SoupSessionHost *host,
+ SoupMessage *msg)
+{
+ SOUP_SESSION_HOST_GET_PRIVATE (host)->num_messages--;
+}
+
+static gboolean
+emit_unused (gpointer host)
+{
+ g_signal_emit (host, signals[UNUSED], 0);
+ return FALSE;
+}
+
+SoupConnection *
+soup_session_host_get_connection (SoupSessionHost *host,
+ gboolean need_new_connection,
+ gboolean at_max_conns,
+ gboolean *try_cleanup)
+{
+ SoupSessionHostPrivate *priv = SOUP_SESSION_HOST_GET_PRIVATE (host);
+ SoupConnection *conn;
+ GSList *conns;
+ int num_pending = 0;
+ SoupSocketProperties *socket_props;
+
+ for (conns = priv->connections; conns; conns = conns->next) {
+ conn = conns->data;
+
+ if (!need_new_connection && soup_connection_get_state (conn) == SOUP_CONNECTION_IDLE) {
+ soup_connection_set_state (conn, SOUP_CONNECTION_IN_USE);
+ return conn;
+ } else if (soup_connection_get_state (conn) == SOUP_CONNECTION_CONNECTING)
+ num_pending++;
+ }
+
+ /* Limit the number of pending connections; num_messages / 2
+ * is somewhat arbitrary...
+ */
+ if (num_pending > priv->num_messages / 2)
+ return NULL;
+
+ if (priv->num_conns >= priv->max_conns) {
+ if (need_new_connection)
+ *try_cleanup = TRUE;
+ return NULL;
+ }
+
+ if (at_max_conns) {
+ *try_cleanup = TRUE;
+ return NULL;
+ }
+
+ g_object_get (G_OBJECT (priv->session),
+ SOUP_SESSION_SOCKET_PROPERTIES, &socket_props,
+ NULL);
+ conn = g_object_new (SOUP_TYPE_CONNECTION,
+ SOUP_CONNECTION_REMOTE_URI, priv->uri,
+ SOUP_CONNECTION_SSL_FALLBACK, priv->ssl_fallback,
+ SOUP_CONNECTION_SOCKET_PROPERTIES, socket_props,
+ NULL);
+ soup_socket_properties_unref (socket_props);
+
+ priv->num_conns++;
+ priv->connections = g_slist_prepend (priv->connections, conn);
+
+ if (priv->keep_alive_src) {
+ g_source_destroy (priv->keep_alive_src);
+ g_source_unref (priv->keep_alive_src);
+ priv->keep_alive_src = NULL;
+ }
+
+ return conn;
+}
+
+void
+soup_session_host_remove_connection (SoupSessionHost *host,
+ SoupConnection *conn)
+{
+ SoupSessionHostPrivate *priv = SOUP_SESSION_HOST_GET_PRIVATE (host);
+
+ if (soup_connection_get_ssl_fallback (conn))
+ priv->ssl_fallback = TRUE;
+
+ priv->connections = g_slist_remove (priv->connections, conn);
+ priv->num_conns--;
+
+ if (priv->num_conns == 0) {
+ g_assert (priv->keep_alive_src == NULL);
+ priv->keep_alive_src = soup_add_timeout_reffed (soup_session_get_async_context
(priv->session),
+ HOST_KEEP_ALIVE,
+ emit_unused,
+ host);
+ }
+}
+
+int
+soup_session_host_get_num_connections (SoupSessionHost *host)
+{
+ return SOUP_SESSION_HOST_GET_PRIVATE (host)->num_conns;
+}
+
+gboolean
+soup_session_host_get_ssl_fallback (SoupSessionHost *host)
+{
+ return SOUP_SESSION_HOST_GET_PRIVATE (host)->ssl_fallback;
+}
+
+void
+soup_session_host_set_ssl_fallback (SoupSessionHost *host,
+ gboolean ssl_fallback)
+{
+ SOUP_SESSION_HOST_GET_PRIVATE (host)->ssl_fallback = ssl_fallback;
+}
+
diff --git a/libsoup/soup-session-host.h b/libsoup/soup-session-host.h
new file mode 100644
index 0000000..fecd5d2
--- /dev/null
+++ b/libsoup/soup-session-host.h
@@ -0,0 +1,57 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * Copyright 2013 Red Hat, Inc.
+ */
+
+#ifndef SOUP_SESSION_HOST_H
+#define SOUP_SESSION_HOST_H 1
+
+#include "soup-types.h"
+
+G_BEGIN_DECLS
+
+#define SOUP_TYPE_SESSION_HOST (soup_session_host_get_type ())
+#define SOUP_SESSION_HOST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SESSION_HOST,
SoupSessionHost))
+#define SOUP_SESSION_HOST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SESSION_HOST,
SoupSessionHostClass))
+#define SOUP_IS_SESSION_HOST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SESSION_HOST))
+#define SOUP_IS_SESSION_HOST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_HOST))
+#define SOUP_SESSION_HOST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_HOST,
SoupSessionHostClass))
+
+typedef struct {
+ GObject parent;
+
+} SoupSessionHost;
+
+typedef struct {
+ GObjectClass parent_class;
+
+} SoupSessionHostClass;
+
+GType soup_session_host_get_type (void);
+
+SoupSessionHost *soup_session_host_new (SoupSession *session,
+ SoupURI *uri);
+
+SoupURI *soup_session_host_get_uri (SoupSessionHost *host);
+SoupAddress *soup_session_host_get_address (SoupSessionHost *host);
+
+void soup_session_host_add_message (SoupSessionHost *host,
+ SoupMessage *msg);
+void soup_session_host_remove_message (SoupSessionHost *host,
+ SoupMessage *msg);
+
+SoupConnection *soup_session_host_get_connection (SoupSessionHost *host,
+ gboolean need_new_connection,
+ gboolean at_max_conns,
+ gboolean *try_cleanup);
+void soup_session_host_remove_connection (SoupSessionHost *host,
+ SoupConnection *conn);
+int soup_session_host_get_num_connections (SoupSessionHost *host);
+
+gboolean soup_session_host_get_ssl_fallback (SoupSessionHost *host);
+void soup_session_host_set_ssl_fallback (SoupSessionHost *host,
+ gboolean ssl_fallback);
+
+G_END_DECLS
+
+#endif /* SOUP_SESSION_HOST_H */
diff --git a/libsoup/soup-session-private.h b/libsoup/soup-session-private.h
index dc4d300..b769e9d 100644
--- a/libsoup/soup-session-private.h
+++ b/libsoup/soup-session-private.h
@@ -12,6 +12,8 @@
G_BEGIN_DECLS
+#define SOUP_SESSION_SOCKET_PROPERTIES "socket-properties"
+
/* "protected" methods for subclasses */
SoupMessageQueue *soup_session_get_queue (SoupSession *session);
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index 9f0c2cd..03af7cd 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -20,11 +20,10 @@
#include "soup-misc-private.h"
#include "soup-message-queue.h"
#include "soup-proxy-resolver-wrapper.h"
+#include "soup-session-host.h"
#include "soup-session-private.h"
#include "soup-socket-properties.h"
-#define HOST_KEEP_ALIVE 5 * 60 * 1000 /* 5 min in msecs */
-
/**
* SECTION:soup-session
* @short_description: Soup session state object
@@ -65,22 +64,9 @@ soup_init (void)
#endif
}
-typedef struct {
- SoupURI *uri;
- SoupAddress *addr;
-
- GSList *connections; /* CONTAINS: SoupConnection */
- guint num_conns;
-
- guint num_messages;
-
- gboolean ssl_fallback;
-
- GSource *keep_alive_src;
- SoupSession *session;
-} SoupSessionHost;
static guint soup_host_uri_hash (gconstpointer key);
static gboolean soup_host_uri_equal (gconstpointer v1, gconstpointer v2);
+static void free_unused_host (SoupSessionHost *host, gpointer session);
typedef struct {
SoupSession *session;
@@ -135,7 +121,6 @@ typedef struct {
#define SOUP_IS_PLAIN_SESSION(o) (G_TYPE_FROM_INSTANCE (o) == SOUP_TYPE_SESSION)
-static void free_host (SoupSessionHost *host);
static void connection_state_changed (GObject *object, GParamSpec *param,
gpointer user_data);
static void connection_disconnected (SoupConnection *conn, gpointer user_data);
@@ -176,6 +161,7 @@ static guint signals[LAST_SIGNAL] = { 0 };
enum {
PROP_0,
+ PROP_SOCKET_PROPERTIES,
PROP_PROXY_URI,
PROP_PROXY_RESOLVER,
PROP_MAX_CONNS,
@@ -216,10 +202,10 @@ soup_session_init (SoupSession *session)
g_cond_init (&priv->conn_cond);
priv->http_hosts = g_hash_table_new_full (soup_host_uri_hash,
soup_host_uri_equal,
- NULL, (GDestroyNotify)free_host);
+ NULL, g_object_unref);
priv->https_hosts = g_hash_table_new_full (soup_host_uri_hash,
soup_host_uri_equal,
- NULL, (GDestroyNotify)free_host);
+ NULL, g_object_unref);
priv->conns = g_hash_table_new (NULL, NULL);
priv->max_conns = SOUP_SESSION_MAX_CONNS_DEFAULT;
@@ -754,8 +740,21 @@ soup_session_get_property (GObject *object, guint prop_id,
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupSessionFeature *feature;
GTlsDatabase *tlsdb;
+ SoupSocketProperties *props;
switch (prop_id) {
+ case PROP_SOCKET_PROPERTIES:
+ tlsdb = get_tls_database (session);
+ props = soup_socket_properties_new (priv->async_context,
+ priv->use_thread_context,
+ get_proxy_resolver (session),
+ priv->local_addr,
+ tlsdb,
+ priv->ssl_strict && (tlsdb != NULL ||
SOUP_IS_PLAIN_SESSION (priv->session)),
+ priv->io_timeout,
+ priv->idle_timeout);
+ g_value_take_boxed (value, props);
+ break;
case PROP_LOCAL_ADDRESS:
g_value_set_object (value, priv->local_addr);
break;
@@ -925,55 +924,38 @@ soup_host_uri_equal (gconstpointer v1, gconstpointer v2)
return g_ascii_strcasecmp (one->host, two->host) == 0;
}
-
-static SoupSessionHost *
-soup_session_host_new (SoupSession *session, SoupURI *uri)
-{
- SoupSessionHost *host;
-
- host = g_slice_new0 (SoupSessionHost);
- host->uri = soup_uri_copy_host (uri);
- if (host->uri->scheme != SOUP_URI_SCHEME_HTTP &&
- host->uri->scheme != SOUP_URI_SCHEME_HTTPS) {
- SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
-
- if (soup_uri_is_https (host->uri, priv->https_aliases))
- host->uri->scheme = SOUP_URI_SCHEME_HTTPS;
- else
- host->uri->scheme = SOUP_URI_SCHEME_HTTP;
- }
-
- host->addr = g_object_new (SOUP_TYPE_ADDRESS,
- SOUP_ADDRESS_NAME, host->uri->host,
- SOUP_ADDRESS_PORT, host->uri->port,
- SOUP_ADDRESS_PROTOCOL, host->uri->scheme,
- NULL);
- host->keep_alive_src = NULL;
- host->session = session;
-
- return host;
-}
-
/* Requires conn_lock to be locked */
static SoupSessionHost *
get_host_for_uri (SoupSession *session, SoupURI *uri)
{
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupSessionHost *host;
+ gboolean https;
+ SoupURI *uri_tmp = NULL;
- if (soup_uri_is_https (uri, priv->https_aliases))
+ https = soup_uri_is_https (uri, priv->https_aliases);
+ if (https)
host = g_hash_table_lookup (priv->https_hosts, uri);
else
host = g_hash_table_lookup (priv->http_hosts, uri);
if (host)
return host;
+ if (uri->scheme != SOUP_URI_SCHEME_HTTP &&
+ uri->scheme != SOUP_URI_SCHEME_HTTPS) {
+ uri = uri_tmp = soup_uri_copy (uri);
+ uri->scheme = https ? SOUP_URI_SCHEME_HTTPS : SOUP_URI_SCHEME_HTTP;
+ }
host = soup_session_host_new (session, uri);
+ if (uri_tmp)
+ soup_uri_free (uri_tmp);
- if (soup_uri_is_https (uri, priv->https_aliases))
- g_hash_table_insert (priv->https_hosts, host->uri, host);
+ if (https)
+ g_hash_table_insert (priv->https_hosts, soup_session_host_get_uri (host), host);
else
- g_hash_table_insert (priv->http_hosts, host->uri, host);
+ g_hash_table_insert (priv->http_hosts, soup_session_host_get_uri (host), host);
+
+ g_signal_connect (host, "unused", G_CALLBACK (free_unused_host), session);
return host;
}
@@ -986,21 +968,6 @@ get_host_for_message (SoupSession *session, SoupMessage *msg)
}
static void
-free_host (SoupSessionHost *host)
-{
- g_warn_if_fail (host->connections == NULL);
-
- if (host->keep_alive_src) {
- g_source_destroy (host->keep_alive_src);
- g_source_unref (host->keep_alive_src);
- }
-
- soup_uri_free (host->uri);
- g_object_unref (host->addr);
- g_slice_free (SoupSessionHost, host);
-}
-
-static void
auth_manager_authenticate (SoupAuthManager *manager, SoupMessage *msg,
SoupAuth *auth, gboolean retrying,
gpointer session)
@@ -1221,7 +1188,7 @@ soup_session_append_queue_item (SoupSession *session, SoupMessage *msg,
g_mutex_lock (&priv->conn_lock);
host = get_host_for_message (session, item->msg);
- host->num_messages++;
+ soup_session_host_add_message (host, msg);
g_mutex_unlock (&priv->conn_lock);
if (!(soup_message_get_flags (msg) & SOUP_MESSAGE_NO_REDIRECT)) {
@@ -1313,32 +1280,32 @@ soup_session_cleanup_connections (SoupSession *session,
return TRUE;
}
-static gboolean
-free_unused_host (gpointer user_data)
+static void
+free_unused_host (SoupSessionHost *host,
+ gpointer session)
{
- SoupSessionHost *host = (SoupSessionHost *) user_data;
- SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (host->session);
+ SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
+ SoupURI *uri;
g_mutex_lock (&priv->conn_lock);
/* In a multithreaded session, a connection might have been
* added while we were waiting for conn_lock.
*/
- if (host->connections) {
+ if (soup_session_host_get_num_connections (host)) {
g_mutex_unlock (&priv->conn_lock);
- return FALSE;
+ return;
}
/* This will free the host in addition to removing it from the
* hash table
*/
- if (host->uri->scheme == SOUP_URI_SCHEME_HTTPS)
- g_hash_table_remove (priv->https_hosts, host->uri);
+ uri = soup_session_host_get_uri (host);
+ if (uri->scheme == SOUP_URI_SCHEME_HTTPS)
+ g_hash_table_remove (priv->https_hosts, uri);
else
- g_hash_table_remove (priv->http_hosts, host->uri);
+ g_hash_table_remove (priv->http_hosts, uri);
g_mutex_unlock (&priv->conn_lock);
-
- return FALSE;
}
static void
@@ -1350,26 +1317,8 @@ drop_connection (SoupSession *session, SoupSessionHost *host, SoupConnection *co
* from priv->conns itself.
*/
- if (host) {
- host->connections = g_slist_remove (host->connections, conn);
- host->num_conns--;
-
- /* Free the SoupHost (and its SoupAddress) if there
- * has not been any new connection to the host during
- * the last HOST_KEEP_ALIVE msecs.
- */
- if (host->num_conns == 0) {
- g_assert (host->keep_alive_src == NULL);
- host->keep_alive_src = soup_add_timeout (priv->async_context,
- HOST_KEEP_ALIVE,
- free_unused_host,
- host);
- host->keep_alive_src = g_source_ref (host->keep_alive_src);
- }
-
- if (soup_connection_get_ssl_fallback (conn))
- host->ssl_fallback = TRUE;
- }
+ if (host)
+ soup_session_host_remove_connection (host, conn);
g_signal_handlers_disconnect_by_func (conn, connection_disconnected, session);
g_signal_handlers_disconnect_by_func (conn, connection_state_changed, session);
@@ -1438,7 +1387,7 @@ soup_session_unqueue_item (SoupSession *session,
g_mutex_lock (&priv->conn_lock);
host = get_host_for_message (session, item->msg);
- host->num_messages--;
+ soup_session_host_remove_message (host, item->msg);
g_cond_broadcast (&priv->conn_cond);
g_mutex_unlock (&priv->conn_lock);
@@ -1527,8 +1476,8 @@ status_from_connect_error (SoupMessageQueueItem *item, GError *error)
g_mutex_lock (&priv->conn_lock);
host = get_host_for_message (item->session, item->msg);
- if (!host->ssl_fallback) {
- host->ssl_fallback = TRUE;
+ if (!soup_session_host_get_ssl_fallback (host)) {
+ soup_session_host_set_ssl_fallback (host, TRUE);
status = SOUP_STATUS_TRY_AGAIN;
} else
status = SOUP_STATUS_SSL_FAILED;
@@ -1728,90 +1677,35 @@ get_connection_for_host (SoupSession *session,
{
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupConnection *conn;
- GSList *conns;
- int num_pending = 0;
- GTlsDatabase *tlsdb;
- gboolean ssl_strict;
- SoupSocketProperties *socket_props;
if (priv->disposed)
- return FALSE;
+ return NULL;
if (item->conn) {
- g_return_val_if_fail (soup_connection_get_state (item->conn) != SOUP_CONNECTION_DISCONNECTED,
FALSE);
+ g_return_val_if_fail (soup_connection_get_state (item->conn) != SOUP_CONNECTION_DISCONNECTED,
NULL);
return item->conn;
}
- for (conns = host->connections; conns; conns = conns->next) {
- conn = conns->data;
-
- if (!need_new_connection && soup_connection_get_state (conn) == SOUP_CONNECTION_IDLE) {
- soup_connection_set_state (conn, SOUP_CONNECTION_IN_USE);
- return conn;
- } else if (soup_connection_get_state (conn) == SOUP_CONNECTION_CONNECTING)
- num_pending++;
- }
-
- /* Limit the number of pending connections; num_messages / 2
- * is somewhat arbitrary...
- */
- if (num_pending > host->num_messages / 2)
- return NULL;
-
- if (host->num_conns >= priv->max_conns_per_host) {
- if (need_new_connection)
- *try_cleanup = TRUE;
- return NULL;
- }
-
- if (priv->num_conns >= priv->max_conns) {
- *try_cleanup = TRUE;
- return NULL;
- }
-
- tlsdb = get_tls_database (session);
- ssl_strict = priv->ssl_strict && (tlsdb != NULL || SOUP_IS_PLAIN_SESSION (priv->session));
- socket_props = soup_socket_properties_new (priv->async_context,
- priv->use_thread_context,
- get_proxy_resolver (session),
- priv->local_addr,
- tlsdb,
- ssl_strict,
- priv->io_timeout,
- priv->idle_timeout);
-
- conn = g_object_new (
- SOUP_TYPE_CONNECTION,
- SOUP_CONNECTION_REMOTE_URI, host->uri,
- SOUP_CONNECTION_SSL, soup_uri_is_https (soup_message_get_uri (item->msg),
priv->https_aliases),
- SOUP_CONNECTION_SSL_FALLBACK, host->ssl_fallback,
- SOUP_CONNECTION_SOCKET_PROPERTIES, socket_props,
- NULL);
- soup_socket_properties_unref (socket_props);
-
- g_signal_connect (conn, "disconnected",
- G_CALLBACK (connection_disconnected),
- session);
- g_signal_connect (conn, "notify::state",
- G_CALLBACK (connection_state_changed),
- session);
-
- /* This is a debugging-related signal, and so can ignore the
- * usual rule about not emitting signals while holding
- * conn_lock.
- */
- g_signal_emit (session, signals[CONNECTION_CREATED], 0, conn);
-
- g_hash_table_insert (priv->conns, conn, host);
-
- priv->num_conns++;
- host->num_conns++;
- host->connections = g_slist_prepend (host->connections, conn);
+ conn = soup_session_host_get_connection (host, need_new_connection,
+ priv->num_conns >= priv->max_conns,
+ try_cleanup);
+
+ if (conn && soup_connection_get_state (conn) == SOUP_CONNECTION_NEW) {
+ g_signal_connect (conn, "disconnected",
+ G_CALLBACK (connection_disconnected),
+ session);
+ g_signal_connect (conn, "notify::state",
+ G_CALLBACK (connection_state_changed),
+ session);
+
+ /* This is a debugging-related signal, and so can ignore the
+ * usual rule about not emitting signals while holding
+ * conn_lock.
+ */
+ g_signal_emit (session, signals[CONNECTION_CREATED], 0, conn);
- if (host->keep_alive_src) {
- g_source_destroy (host->keep_alive_src);
- g_source_unref (host->keep_alive_src);
- host->keep_alive_src = NULL;
+ g_hash_table_insert (priv->conns, conn, host);
+ priv->num_conns++;
}
return conn;
@@ -2488,7 +2382,7 @@ prefetch_uri (SoupSession *session, SoupURI *uri,
g_mutex_lock (&priv->conn_lock);
host = get_host_for_uri (session, uri);
- addr = g_object_ref (host->addr);
+ addr = g_object_ref (soup_session_host_get_address (host));
g_mutex_unlock (&priv->conn_lock);
soup_address_resolve_async (addr,
@@ -3098,6 +2992,13 @@ soup_session_class_init (SoupSessionClass *session_class)
/* properties */
+ g_object_class_install_property (
+ object_class, PROP_SOCKET_PROPERTIES,
+ g_param_spec_boxed (SOUP_SESSION_SOCKET_PROPERTIES,
+ "Socket properties",
+ "Socket properties",
+ SOUP_TYPE_SOCKET_PROPERTIES,
+ G_PARAM_READABLE));
/**
* SoupSession:proxy-uri:
*
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
