diff --git a/libsoup/soup-connection.c b/libsoup/soup-connection.c
index 9f59816..21c247c 100644
--- a/libsoup/soup-connection.c
+++ b/libsoup/soup-connection.c
@@ -26,6 +26,7 @@
 #include "soup-socket.h"
 #include "soup-ssl.h"
 #include "soup-uri.h"
+#include "soup-enum-types.h"
 
 typedef struct {
 	SoupSocket  *socket;
@@ -63,6 +64,8 @@ enum {
 	PROP_ASYNC_CONTEXT,
 	PROP_TIMEOUT,
 	PROP_IDLE_TIMEOUT,
+	PROP_STATE,
+	PROP_MESSAGE,
 
 	LAST_PROP
 };
@@ -191,6 +194,20 @@ soup_connection_class_init (SoupConnectionClass *connection_class)
 				   "Connection lifetime when idle",
 				   0, G_MAXUINT, 0,
 				   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+	g_object_class_install_property (
+		object_class, PROP_STATE,
+		g_param_spec_enum (SOUP_CONNECTION_STATE,
+				   "Connection state",
+				   "Current state of connection",
+				   SOUP_TYPE_CONNECTION_STATE, SOUP_CONNECTION_NEW,
+				   G_PARAM_READWRITE));
+	g_object_class_install_property (
+		object_class, PROP_MESSAGE,
+		g_param_spec_object (SOUP_CONNECTION_MESSAGE,
+				   "Current message",
+				   "Message to proccess",
+				   SOUP_TYPE_MESSAGE,
+				   G_PARAM_READABLE));
 }
 
 
@@ -240,6 +257,9 @@ set_property (GObject *object, guint prop_id,
 	case PROP_IDLE_TIMEOUT:
 		priv->idle_timeout = g_value_get_uint (value);
 		break;
+	case PROP_STATE:
+		soup_connection_set_state (SOUP_CONNECTION (object), g_value_get_uint (value));
+		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 		break;
@@ -274,6 +294,12 @@ get_property (GObject *object, guint prop_id,
 	case PROP_IDLE_TIMEOUT:
 		g_value_set_uint (value, priv->idle_timeout);
 		break;
+	case PROP_STATE:
+		g_value_set_enum (value, priv->state);
+		break;
+	case PROP_MESSAGE:
+		g_value_set_object (value, priv->cur_req);
+		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 		break;
@@ -330,6 +356,8 @@ clear_current_request (SoupConnection *conn)
 {
 	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
 
+	/* soup_connection_set_state will not be used as that function may call
+	   clear_current_request */
 	if (priv->state == SOUP_CONNECTION_IN_USE)
 		priv->state = SOUP_CONNECTION_IDLE;
 	start_idle_timer (conn);
@@ -378,7 +406,7 @@ socket_connect_result (SoupSocket *sock, guint status, gpointer user_data)
 	g_signal_connect (priv->socket, "disconnected",
 			  G_CALLBACK (socket_disconnected), data->conn);
 
-	priv->state = SOUP_CONNECTION_IDLE;
+	soup_connection_set_state(data->conn, SOUP_CONNECTION_IDLE);
 	priv->unused_timeout = time (NULL) + SOUP_CONNECTION_UNUSED_TIMEOUT;
 	start_idle_timer (data->conn);
 
@@ -411,7 +439,7 @@ soup_connection_connect_async (SoupConnection *conn,
 	priv = SOUP_CONNECTION_GET_PRIVATE (conn);
 	g_return_if_fail (priv->socket == NULL);
 
-	priv->state = SOUP_CONNECTION_CONNECTING;
+	soup_connection_set_state (conn, SOUP_CONNECTION_CONNECTING);
 
 	data = g_slice_new (SoupConnectionAsyncConnectData);
 	data->conn = conn;
@@ -446,7 +474,7 @@ soup_connection_connect_sync (SoupConnection *conn)
 	priv = SOUP_CONNECTION_GET_PRIVATE (conn);
 	g_return_val_if_fail (priv->socket == NULL, SOUP_STATUS_MALFORMED);
 
-	priv->state = SOUP_CONNECTION_CONNECTING;
+	soup_connection_set_state (conn, SOUP_CONNECTION_CONNECTING);
 
 	priv->socket =
 		soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS, priv->remote_addr,
@@ -471,7 +499,7 @@ soup_connection_connect_sync (SoupConnection *conn)
 	}
 
 	if (SOUP_STATUS_IS_SUCCESSFUL (status)) {
-		priv->state = SOUP_CONNECTION_IDLE;
+		soup_connection_set_state (conn, SOUP_CONNECTION_IDLE);
 		priv->unused_timeout = time (NULL) + SOUP_CONNECTION_UNUSED_TIMEOUT;
 		start_idle_timer (conn);
 	} else {
@@ -541,7 +569,7 @@ soup_connection_disconnect (SoupConnection *conn)
 	if (priv->state < SOUP_CONNECTION_IDLE)
 		return;
 
-	priv->state = SOUP_CONNECTION_DISCONNECTED;
+	soup_connection_set_state (conn, SOUP_CONNECTION_DISCONNECTED);
 	/* NB: this might cause conn to be destroyed. */
 	g_signal_emit (conn, signals[DISCONNECTED], 0);
 }
@@ -578,13 +606,15 @@ soup_connection_get_state (SoupConnection *conn)
 		pfd.fd = soup_socket_get_fd (priv->socket);
 		pfd.events = G_IO_IN;
 		pfd.revents = 0;
-		if (g_poll (&pfd, 1, 0) == 1)
-			priv->state = SOUP_CONNECTION_REMOTE_DISCONNECTED;
+		if (g_poll (&pfd, 1, 0) == 1) {
+			soup_connection_set_state (conn, SOUP_CONNECTION_REMOTE_DISCONNECTED);
+		}
 	}
 #endif
 	if (priv->state == SOUP_CONNECTION_IDLE &&
-	    priv->unused_timeout && priv->unused_timeout < time (NULL))
-		priv->state = SOUP_CONNECTION_REMOTE_DISCONNECTED;
+	    priv->unused_timeout && priv->unused_timeout < time (NULL)) {
+		soup_connection_set_state (conn, SOUP_CONNECTION_REMOTE_DISCONNECTED);
+	}
 
 	return priv->state;
 }
@@ -592,13 +622,16 @@ soup_connection_get_state (SoupConnection *conn)
 void
 soup_connection_set_state (SoupConnection *conn, SoupConnectionState state)
 {
+	SoupConnectionState old_state = SOUP_CONNECTION_GET_PRIVATE (conn)->state;
 	g_return_if_fail (SOUP_IS_CONNECTION (conn));
 	g_return_if_fail (state > SOUP_CONNECTION_NEW &&
-			  state < SOUP_CONNECTION_DISCONNECTED);
+			  state <= SOUP_CONNECTION_DISCONNECTED);
 
 	SOUP_CONNECTION_GET_PRIVATE (conn)->state = state;
-	if (state == SOUP_CONNECTION_IDLE)
+	if ( (state == SOUP_CONNECTION_IDLE) &&
+	     (old_state == SOUP_CONNECTION_IN_USE) )
 		clear_current_request (conn);
+	g_object_notify (G_OBJECT (conn), "state");
 }
 
 /**
@@ -619,8 +652,13 @@ soup_connection_send_request (SoupConnection *conn, SoupMessage *req)
 	priv = SOUP_CONNECTION_GET_PRIVATE (conn);
 	g_return_if_fail (priv->state != SOUP_CONNECTION_NEW && priv->state != SOUP_CONNECTION_DISCONNECTED);
 
-	if (req != priv->cur_req)
+	if (req != priv->cur_req) {
 		set_current_request (priv, req);
+		g_object_notify (G_OBJECT (conn), "message");
+		/* state is notified "manually" as set_current_request does use
+		   set_session_state */
+		g_object_notify (G_OBJECT (conn), "state");
+	}
 	soup_message_send_request (req, priv->socket, conn,
 				   priv->proxy_uri != NULL);
 }
diff --git a/libsoup/soup-connection.h b/libsoup/soup-connection.h
index aa261d2..ae8973e 100644
--- a/libsoup/soup-connection.h
+++ b/libsoup/soup-connection.h
@@ -9,6 +9,7 @@
 #include <time.h>
 
 #include "soup-types.h"
+#include "soup-misc.h"
 
 G_BEGIN_DECLS
 
@@ -39,15 +40,6 @@ typedef void  (*SoupConnectionCallback)        (SoupConnection   *conn,
 						guint             status,
 						gpointer          data);
 
-typedef enum {
-	SOUP_CONNECTION_NEW,
-	SOUP_CONNECTION_CONNECTING,
-	SOUP_CONNECTION_IDLE,
-	SOUP_CONNECTION_IN_USE,
-	SOUP_CONNECTION_REMOTE_DISCONNECTED,
-	SOUP_CONNECTION_DISCONNECTED
-} SoupConnectionState;
-
 #define SOUP_CONNECTION_REMOTE_ADDRESS  "remote-address"
 #define SOUP_CONNECTION_TUNNEL_ADDRESS  "tunnel-address"
 #define SOUP_CONNECTION_PROXY_URI       "proxy-uri"
@@ -55,6 +47,8 @@ typedef enum {
 #define SOUP_CONNECTION_ASYNC_CONTEXT   "async-context"
 #define SOUP_CONNECTION_TIMEOUT         "timeout"
 #define SOUP_CONNECTION_IDLE_TIMEOUT    "idle-timeout"
+#define SOUP_CONNECTION_STATE           "state"
+#define SOUP_CONNECTION_MESSAGE         "message"
 
 SoupConnection *soup_connection_new            (const char       *propname1,
 						...) G_GNUC_NULL_TERMINATED;
diff --git a/libsoup/soup-misc.h b/libsoup/soup-misc.h
index e40fa91..8802340 100644
--- a/libsoup/soup-misc.h
+++ b/libsoup/soup-misc.h
@@ -49,6 +49,15 @@ typedef enum {
 	SOUP_SSL_ERROR_CERTIFICATE
 } SoupSSLError;
 
+typedef enum {
+	SOUP_CONNECTION_NEW,
+	SOUP_CONNECTION_CONNECTING,
+	SOUP_CONNECTION_IDLE,
+	SOUP_CONNECTION_IN_USE,
+	SOUP_CONNECTION_REMOTE_DISCONNECTED,
+	SOUP_CONNECTION_DISCONNECTED
+} SoupConnectionState;
+
 G_END_DECLS
 
 #endif /* SOUP_MISC_H */
diff --git a/libsoup/soup-session-async.c b/libsoup/soup-session-async.c
index 731138c..89af696 100644
--- a/libsoup/soup-session-async.c
+++ b/libsoup/soup-session-async.c
@@ -264,6 +264,7 @@ got_connection (SoupConnection *conn, guint status, gpointer session)
 			data->session = session;
 			data->conn = conn;
 			data->item = soup_session_make_connect_message (session, tunnel_addr);
+			g_signal_emit_by_name (session, "tunneling", conn);
 			g_signal_connect (data->item->msg, "finished",
 					  G_CALLBACK (tunnel_connected), data);
 			g_signal_connect (data->item->msg, "restarted",
diff --git a/libsoup/soup-session-sync.c b/libsoup/soup-session-sync.c
index eba77e4..e1ba325 100644
--- a/libsoup/soup-session-sync.c
+++ b/libsoup/soup-session-sync.c
@@ -142,6 +142,7 @@ tunnel_connect (SoupSession *session, SoupConnection *conn,
 	SoupMessageQueueItem *item;
 	guint status;
 
+	g_signal_emit_by_name (session, "tunneling", conn);
 	item = soup_session_make_connect_message (session, tunnel_addr);
 	do
 		soup_session_send_queue_item (session, item, conn);
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index 8fb28ec..651d538 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -123,6 +123,8 @@ enum {
 	REQUEST_STARTED,
 	REQUEST_UNQUEUED,
 	AUTHENTICATE,
+	CONNECTION_CREATED,
+	TUNNELING,
 	LAST_SIGNAL
 };
 
@@ -380,6 +382,27 @@ soup_session_class_init (SoupSessionClass *session_class)
 			      SOUP_TYPE_AUTH,
 			      G_TYPE_BOOLEAN);
 
+	signals[CONNECTION_CREATED] =
+		g_signal_new ("connection-created",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_FIRST,
+			      0,
+			      NULL, NULL,
+			      soup_marshal_NONE__OBJECT,
+			      G_TYPE_NONE, 1,
+			      SOUP_TYPE_CONNECTION);
+
+	signals[TUNNELING] =
+		g_signal_new ("tunneling",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_FIRST,
+			      0,
+			      NULL, NULL,
+			      soup_marshal_NONE__OBJECT,
+			      G_TYPE_NONE, 1,
+			      SOUP_TYPE_CONNECTION);
+
+
 	/* properties */
 	/**
 	 * SOUP_SESSION_PROXY_URI:
@@ -1204,6 +1227,8 @@ soup_session_get_connection (SoupSession *session,
 			  G_CALLBACK (connection_disconnected),
 			  session);
 
+	g_signal_emit (session, signals[CONNECTION_CREATED], 0, conn);
+
 	g_hash_table_insert (priv->conns, conn, host);
 
 	priv->num_conns++;
