diff --git a/libsoup-zip.in b/libsoup-zip.in
old mode 100755
new mode 100644
diff --git a/libsoup/soup-connection.c b/libsoup/soup-connection.c
index 514640f..4007b49 100644
--- a/libsoup/soup-connection.c
+++ b/libsoup/soup-connection.c
@@ -38,6 +38,7 @@ typedef struct {
 	gpointer     ssl_creds;
 	gboolean     ssl_strict;
 	gboolean     ssl_fallback;
+	GTlsInteraction *tls_interaction;
 
 	GMainContext      *async_context;
 
@@ -67,6 +68,7 @@ enum {
 	PROP_SSL_CREDS,
 	PROP_SSL_STRICT,
 	PROP_SSL_FALLBACK,
+	PROP_TLS_INTERACTION,
 	PROP_ASYNC_CONTEXT,
 	PROP_TIMEOUT,
 	PROP_IDLE_TIMEOUT,
@@ -110,6 +112,9 @@ finalize (GObject *object)
 	if (priv->async_context)
 		g_main_context_unref (priv->async_context);
 
+	if (priv->tls_interaction)
+		g_object_unref (priv->tls_interaction);
+
 	G_OBJECT_CLASS (soup_connection_parent_class)->finalize (object);
 }
 
@@ -201,6 +206,12 @@ soup_connection_class_init (SoupConnectionClass *connection_class)
 				      FALSE,
 				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 	g_object_class_install_property (
+		object_class, PROP_TLS_INTERACTION,
+		g_param_spec_pointer (SOUP_CONNECTION_TLS_INTERACTION,
+				      "GTlsInteraction",
+				      "GTlsInteraction that application set to use",
+				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+	g_object_class_install_property (
 		object_class, PROP_ASYNC_CONTEXT,
 		g_param_spec_pointer (SOUP_CONNECTION_ASYNC_CONTEXT,
 				      "Async GMainContext",
@@ -278,6 +289,9 @@ set_property (GObject *object, guint prop_id,
 	case PROP_SSL_FALLBACK:
 		priv->ssl_fallback = g_value_get_boolean (value);
 		break;
+	case PROP_TLS_INTERACTION:
+		priv->tls_interaction = g_value_get_pointer (value);
+		break;
 	case PROP_ASYNC_CONTEXT:
 		priv->async_context = g_value_get_pointer (value);
 		if (priv->async_context)
@@ -323,6 +337,9 @@ get_property (GObject *object, guint prop_id,
 	case PROP_SSL_FALLBACK:
 		g_value_set_boolean (value, priv->ssl_fallback);
 		break;
+	case PROP_TLS_INTERACTION:
+		g_value_set_pointer (value, priv->tls_interaction);
+		break;
 	case PROP_ASYNC_CONTEXT:
 		g_value_set_pointer (value, priv->async_context ? g_main_context_ref (priv->async_context) : NULL);
 		break;
@@ -472,6 +489,24 @@ socket_connect_finished (SoupSocket *socket, guint status, gpointer user_data)
 }
 
 static void
+socket_connect_handshake_finished (SoupSocket *sock, guint status, gpointer user_data)
+{
+	SoupConnectionAsyncConnectData *data = user_data;
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (data->conn);
+
+	if (status == SOUP_STATUS_TLS_FAILED) {
+		priv->ssl_fallback = TRUE;
+		status = SOUP_STATUS_TRY_AGAIN;
+		socket_connect_finished (sock, status, data);
+	} else if (status == SOUP_STATUS_TLS_CERTIFICATE_REQUIRED) {
+		soup_socket_lookup_client_certificate_async (sock,
+							     data->cancellable,
+							     socket_connect_finished,
+							     data);
+	}
+}
+
+static void
 socket_connect_result (SoupSocket *sock, guint status, gpointer user_data)
 {
 	SoupConnectionAsyncConnectData *data = user_data;
@@ -481,7 +516,7 @@ socket_connect_result (SoupSocket *sock, guint status, gpointer user_data)
 	    priv->ssl_creds && !priv->tunnel_addr) {
 		if (soup_socket_start_ssl (sock, data->cancellable)) {
 			soup_socket_handshake_async (sock, data->cancellable,
-						     socket_connect_finished, data);
+						     socket_connect_handshake_finished, data);
 			return;
 		}
 
@@ -517,6 +552,7 @@ soup_connection_connect_async (SoupConnection *conn,
 				 SOUP_SOCKET_SSL_CREDENTIALS, priv->ssl_creds,
 				 SOUP_SOCKET_SSL_STRICT, priv->ssl_strict,
 				 SOUP_SOCKET_SSL_FALLBACK, priv->ssl_fallback,
+				 SOUP_SOCKET_TLS_INTERACTION, priv->tls_interaction,
 				 SOUP_SOCKET_ASYNC_CONTEXT, priv->async_context,
 				 SOUP_SOCKET_TIMEOUT, priv->io_timeout,
 				 "clean-dispose", TRUE,
@@ -542,6 +578,7 @@ soup_connection_connect_sync (SoupConnection *conn, GCancellable *cancellable)
 				 SOUP_SOCKET_SSL_CREDENTIALS, priv->ssl_creds,
 				 SOUP_SOCKET_SSL_STRICT, priv->ssl_strict,
 				 SOUP_SOCKET_SSL_FALLBACK, priv->ssl_fallback,
+				 SOUP_SOCKET_TLS_INTERACTION, priv->tls_interaction,
 				 SOUP_SOCKET_FLAG_NONBLOCKING, FALSE,
 				 SOUP_SOCKET_TIMEOUT, priv->io_timeout,
 				 "clean-dispose", TRUE,
@@ -560,7 +597,9 @@ soup_connection_connect_sync (SoupConnection *conn, GCancellable *cancellable)
 			if (status == SOUP_STATUS_TLS_FAILED) {
 				priv->ssl_fallback = TRUE;
 				status = SOUP_STATUS_TRY_AGAIN;
-			}
+			} else if (status == SOUP_STATUS_TLS_CERTIFICATE_REQUIRED)
+				status = soup_socket_lookup_client_certificate_sync
+								(priv->socket, cancellable);
 		}
 	}
 
@@ -618,7 +657,8 @@ soup_connection_start_ssl_sync (SoupConnection *conn,
 	if (status == SOUP_STATUS_TLS_FAILED) {
 		priv->ssl_fallback = TRUE;
 		status = SOUP_STATUS_TRY_AGAIN;
-	}
+	} else if (status == SOUP_STATUS_TLS_CERTIFICATE_REQUIRED)
+		status = SOUP_STATUS_TRY_AGAIN;
 
 	return status;
 }
@@ -632,7 +672,8 @@ start_ssl_completed (SoupSocket *socket, guint status, gpointer user_data)
 	if (status == SOUP_STATUS_TLS_FAILED) {
 		priv->ssl_fallback = TRUE;
 		status = SOUP_STATUS_TRY_AGAIN;
-	}
+	} else if (status == SOUP_STATUS_TLS_CERTIFICATE_REQUIRED)
+		status = SOUP_STATUS_TRY_AGAIN;
 
 	data->callback (data->conn, status, data->callback_data);
 	g_object_unref (data->conn);
diff --git a/libsoup/soup-connection.h b/libsoup/soup-connection.h
index ef304e7..619e92c 100644
--- a/libsoup/soup-connection.h
+++ b/libsoup/soup-connection.h
@@ -45,6 +45,7 @@ typedef void  (*SoupConnectionCallback)        (SoupConnection   *conn,
 #define SOUP_CONNECTION_SSL_CREDENTIALS "ssl-creds"
 #define SOUP_CONNECTION_SSL_STRICT      "ssl-strict"
 #define SOUP_CONNECTION_SSL_FALLBACK    "ssl-fallback"
+#define SOUP_CONNECTION_TLS_INTERACTION "tsl-interaction"
 #define SOUP_CONNECTION_ASYNC_CONTEXT   "async-context"
 #define SOUP_CONNECTION_TIMEOUT         "timeout"
 #define SOUP_CONNECTION_IDLE_TIMEOUT    "idle-timeout"
diff --git a/libsoup/soup-misc-private.h b/libsoup/soup-misc-private.h
index 8407101..22bbd07 100644
--- a/libsoup/soup-misc-private.h
+++ b/libsoup/soup-misc-private.h
@@ -17,5 +17,13 @@ void  soup_socket_handshake_async (SoupSocket         *sock,
 				   GCancellable       *cancellable,
 				   SoupSocketCallback  callback,
 				   gpointer            user_data);
+guint soup_socket_lookup_client_certificate_sync
+				(SoupSocket	*sock,
+				 GCancellable	*cancellable);
+void soup_socket_lookup_client_certificate_async
+				(SoupSocket		*sock,
+				 GCancellable		*cancellable,
+				 SoupSocketCallback	callback,
+				 gpointer		user_data);
 
 #endif /* SOUP_URI_PRIVATE_H */
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index 8c2b354..1d6b164 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -74,6 +74,7 @@ typedef struct {
 	char *ssl_ca_file;
 	SoupSSLCredentials *ssl_creds;
 	gboolean ssl_strict;
+	GTlsInteraction *tls_interaction;
 
 	SoupMessageQueue *queue;
 
@@ -147,6 +148,7 @@ enum {
 	PROP_USE_NTLM,
 	PROP_SSL_CA_FILE,
 	PROP_SSL_STRICT,
+	PROP_TLS_INTERACTION,
 	PROP_ASYNC_CONTEXT,
 	PROP_TIMEOUT,
 	PROP_USER_AGENT,
@@ -235,6 +237,8 @@ finalize (GObject *object)
 		g_free (priv->ssl_ca_file);
 	if (priv->ssl_creds)
 		soup_ssl_free_client_credentials (priv->ssl_creds);
+	if (priv->tls_interaction)
+		g_object_unref (priv->tls_interaction);
 
 	if (priv->async_context)
 		g_main_context_unref (priv->async_context);
@@ -546,6 +550,20 @@ soup_session_class_init (SoupSessionClass *session_class)
 				      TRUE,
 				      G_PARAM_READWRITE));
 	/**
+	 * SOUP_SESSION_TLS_INTERACTION:
+	 *
+	 * Alias for the #SoupSession:tls-interaction property.
+	 * property.
+	 *
+	 * Since: 2.40
+	 **/
+	g_object_class_install_property (
+		object_class, PROP_TLS_INTERACTION,
+		g_param_spec_pointer (SOUP_SESSION_TLS_INTERACTION,
+				      "GTlsInteraction",
+				      "GTlsInteraction that applications set to use",
+				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+	/**
 	 * SOUP_SESSION_ASYNC_CONTEXT:
 	 *
 	 * Alias for the #SoupSession:async-context property. (The
@@ -890,6 +908,9 @@ set_property (GObject *object, guint prop_id,
 	case PROP_SSL_STRICT:
 		priv->ssl_strict = g_value_get_boolean (value);
 		break;
+	case PROP_TLS_INTERACTION:
+		priv->tls_interaction = g_value_get_pointer (value);
+		break;
 	case PROP_ASYNC_CONTEXT:
 		priv->async_context = g_value_get_pointer (value);
 		if (priv->async_context)
@@ -984,6 +1005,9 @@ get_property (GObject *object, guint prop_id,
 	case PROP_SSL_STRICT:
 		g_value_set_boolean (value, priv->ssl_strict);
 		break;
+	case PROP_TLS_INTERACTION:
+		g_value_set_pointer (value, priv->tls_interaction);
+		break;
 	case PROP_ASYNC_CONTEXT:
 		g_value_set_pointer (value, priv->async_context ? g_main_context_ref (priv->async_context) : NULL);
 		break;
@@ -1396,6 +1420,7 @@ soup_session_get_connection (SoupSession *session,
 		SOUP_CONNECTION_TIMEOUT, priv->io_timeout,
 		SOUP_CONNECTION_IDLE_TIMEOUT, priv->idle_timeout,
 		SOUP_CONNECTION_SSL_FALLBACK, host->ssl_fallback,
+		SOUP_CONNECTION_TLS_INTERACTION, priv->tls_interaction,
 		NULL);
 	g_signal_connect (conn, "disconnected",
 			  G_CALLBACK (connection_disconnected),
diff --git a/libsoup/soup-session.h b/libsoup/soup-session.h
index 4b6661f..1cb8ec4 100644
--- a/libsoup/soup-session.h
+++ b/libsoup/soup-session.h
@@ -64,6 +64,7 @@ GType soup_session_get_type (void);
 #define SOUP_SESSION_USE_NTLM               "use-ntlm"
 #define SOUP_SESSION_SSL_CA_FILE            "ssl-ca-file"
 #define SOUP_SESSION_SSL_STRICT             "ssl-strict"
+#define SOUP_SESSION_TLS_INTERACTION        "tls-interaction"
 #define SOUP_SESSION_ASYNC_CONTEXT          "async-context"
 #define SOUP_SESSION_TIMEOUT                "timeout"
 #define SOUP_SESSION_USER_AGENT             "user-agent"
diff --git a/libsoup/soup-socket.c b/libsoup/soup-socket.c
index a4d9f54..d36c7d9 100644
--- a/libsoup/soup-socket.c
+++ b/libsoup/soup-socket.c
@@ -61,6 +61,7 @@ enum {
 	PROP_CLEAN_DISPOSE,
 	PROP_TLS_CERTIFICATE,
 	PROP_TLS_ERRORS,
+	PROP_TLS_INTERACTION,
 
 	LAST_PROP
 };
@@ -81,6 +82,10 @@ typedef struct {
 	guint clean_dispose:1;
 	gpointer ssl_creds;
 
+	GTlsInteraction *tls_interaction;
+	GTlsCertificate *tls_certificate;
+	guint tls_cas_num;
+
 	GMainContext   *async_context;
 	GSource        *watch_src;
 	GSource        *read_src, *write_src;
@@ -110,6 +115,8 @@ soup_socket_init (SoupSocket *sock)
 	priv->non_blocking = TRUE;
 	priv->addrlock = g_mutex_new ();
 	priv->iolock = g_mutex_new ();
+	priv->tls_certificate = NULL;
+	priv->tls_interaction = NULL;
 }
 
 static void
@@ -173,6 +180,9 @@ finalize (GObject *object)
 	if (priv->read_buf)
 		g_byte_array_free (priv->read_buf, TRUE);
 
+	if (priv->tls_interaction)
+		g_object_unref (priv->tls_interaction);
+
 	g_mutex_free (priv->addrlock);
 	g_mutex_free (priv->iolock);
 
@@ -457,6 +467,21 @@ soup_socket_class_init (SoupSocketClass *socket_class)
 				    "Errors with the peer's TLS certificate",
 				    G_TYPE_TLS_CERTIFICATE_FLAGS, 0,
 				    G_PARAM_READABLE));
+	/**
+	 * SOUP_SOCKET_TLS_INTERACTION:
+	 *
+	 * Alias for the #SoupSession:tsl-interaction property.
+	 * property.
+	 *
+	 * Since: 2.40
+	 **/
+	g_object_class_install_property (
+		object_class, PROP_TLS_INTERACTION,
+		g_param_spec_pointer (SOUP_SOCKET_TLS_INTERACTION,
+				      "GTlsInteraction",
+				      "GTlsInteraction that application set to use",
+				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
 }
 
 
@@ -514,6 +539,9 @@ set_property (GObject *object, guint prop_id,
 	case PROP_CLEAN_DISPOSE:
 		priv->clean_dispose = g_value_get_boolean (value);
 		break;
+	case PROP_TLS_INTERACTION:
+		priv->tls_interaction = g_value_get_pointer (value);
+		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 		break;
@@ -566,6 +594,9 @@ get_property (GObject *object, guint prop_id,
 	case PROP_TLS_ERRORS:
 		g_value_set_flags (value, priv->tls_errors);
 		break;
+	case PROP_TLS_INTERACTION:
+		g_value_set_pointer (value, priv->tls_interaction);
+		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 		break;
@@ -962,6 +993,12 @@ soup_socket_start_proxy_ssl (SoupSocket *sock, const char *ssl_host,
 		if (!conn)
 			return FALSE;
 
+		if (priv->tls_interaction)
+			g_tls_connection_set_interaction (G_TLS_CONNECTION (conn), priv->tls_interaction);
+
+		if (priv->tls_certificate)
+			g_tls_connection_set_certificate (G_TLS_CONNECTION (conn), priv->tls_certificate);
+
 		g_object_unref (priv->conn);
 		priv->conn = G_IO_STREAM (conn);
 
@@ -1008,6 +1045,10 @@ soup_socket_handshake_sync (SoupSocket    *sock,
 		 g_error_matches (error, G_TLS_ERROR, G_TLS_ERROR_NOT_TLS)) {
 		g_error_free (error);
 		return SOUP_STATUS_TLS_FAILED;
+	} else if (!priv->ssl_fallback &&
+		   g_error_matches (error, G_TLS_ERROR, G_TLS_ERROR_CERTIFICATE_REQUIRED)) {
+		g_error_free (error);
+		return SOUP_STATUS_TLS_CERTIFICATE_REQUIRED;
 	} else {
 		g_error_free (error);
 		return SOUP_STATUS_SSL_FAILED;
@@ -1031,6 +1072,9 @@ handshake_async_ready (GObject *source, GAsyncResult *result, gpointer user_data
 	else if (!priv->ssl_fallback &&
 		 g_error_matches (error, G_TLS_ERROR, G_TLS_ERROR_NOT_TLS))
 		status = SOUP_STATUS_TLS_FAILED;
+	else if (!priv->ssl_fallback &&
+		 g_error_matches (error, G_TLS_ERROR, G_TLS_ERROR_CERTIFICATE_REQUIRED))
+		status = SOUP_STATUS_TLS_CERTIFICATE_REQUIRED;
 	else
 		status = SOUP_STATUS_SSL_FAILED;
 	g_clear_error (&error);
@@ -1062,6 +1106,151 @@ soup_socket_handshake_async (SoupSocket         *sock,
 					  data);
 }
 
+guint
+soup_socket_lookup_client_certificate_sync
+				(SoupSocket	*sock,
+				 GCancellable	*cancellable)
+{
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
+	GError *error = NULL;
+	GList *l, *accepted;
+	GList *c, *certificates;
+	GTlsDatabase *database;
+	GTlsCertificate *certificate = NULL;
+	GTlsConnection *base;
+
+	accepted = g_tls_client_connection_get_accepted_cas (G_TLS_CLIENT_CONNECTION (priv->conn));
+	base = G_TLS_CONNECTION (priv->conn);
+	database = g_tls_connection_get_database (base);
+
+	for (l = accepted; l != NULL; l = g_list_next (l))
+	{
+		certificates = g_tls_database_lookup_certificates_issued_by
+							(database, l->data,
+							 g_tls_connection_get_interaction (base),
+							 G_TLS_DATABASE_LOOKUP_KEYPAIR,
+							 cancellable, &error);
+		if (error)
+			break;
+		if (certificates)
+			certificate = g_object_ref (certificates->data);
+		for (c = certificates; c != NULL; c = g_list_next (c))
+			g_object_unref (c->data);
+		g_list_free (certificates);
+	}
+
+	g_clear_error (&error);
+
+	for (l = accepted; l != NULL; l = g_list_next (l))
+		g_byte_array_unref (l->data);
+	g_list_free (accepted);
+
+	if (certificate == NULL)
+		return SOUP_STATUS_SSL_FAILED;
+
+	priv->tls_certificate = certificate;
+	return SOUP_STATUS_TRY_AGAIN;
+}
+
+typedef struct {
+	SoupSocket *sock;
+	SoupSocketCallback callback;
+	gpointer user_data;
+	GList *accepted_cas;
+} SoupSocketAsyncClientCertData;
+
+static void
+lookup_client_certificate_async_ready (GObject *source, GAsyncResult *result, gpointer user_data)
+{
+	SoupSocketAsyncClientCertData *data = user_data;
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (data->sock);
+	GError *error = NULL;
+	guint status;
+	GList *c, *certificates;
+	GTlsDatabase *database;
+	GTlsConnection *base;
+
+	base = G_TLS_CONNECTION (priv->conn);
+	database = g_tls_connection_get_database (base);
+	if (priv->async_context)
+		g_main_context_pop_thread_default (priv->async_context);
+
+	certificates = g_tls_database_lookup_certificates_issued_by_finish (database,
+									    result, &error);
+	/* Need to lock it? */
+	priv->tls_cas_num --;
+
+	if (error) {
+		g_error_free (error);
+		goto done;
+	}
+
+	if (certificates)
+		priv->tls_certificate = g_object_ref (certificates->data);
+	for (c = certificates; c != NULL; c = g_list_next (c))
+		g_object_unref (c->data);
+	g_list_free (certificates);
+
+	if (priv->tls_cas_num == 0) {
+done:
+		if (priv->tls_certificate == NULL)
+			status = SOUP_STATUS_SSL_FAILED;
+		else status = SOUP_STATUS_TRY_AGAIN;
+
+		data->callback (data->sock, status, data->user_data);
+		g_object_unref (data->sock);
+		for (c = data->accepted_cas; c != NULL; c = g_list_next (c))
+			g_byte_array_unref (c->data);
+		g_list_free (data->accepted_cas);
+		g_slice_free (SoupSocketAsyncClientCertData, data);
+
+		/* How to cancel rest of the asyn operation in case error happens ?*/
+	}
+}
+
+void
+soup_socket_lookup_client_certificate_async
+				(SoupSocket		*sock,
+				 GCancellable		*cancellable,
+				 SoupSocketCallback	callback,
+				 gpointer		user_data)
+{
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
+	SoupSocketAsyncClientCertData *data;
+	GList *l, *accepted;
+	GTlsDatabase *database;
+	GTlsConnection *base;
+
+	accepted = g_tls_client_connection_get_accepted_cas (G_TLS_CLIENT_CONNECTION (priv->conn));
+	priv->tls_cas_num = g_list_length (accepted);
+
+	if (priv->tls_cas_num == 0) {
+		callback (sock, SOUP_STATUS_SSL_FAILED, user_data);
+		return;
+	}
+
+	base = G_TLS_CONNECTION (priv->conn);
+	database = g_tls_connection_get_database (base);
+
+	data = g_slice_new (SoupSocketAsyncClientCertData);
+	data->sock = g_object_ref (sock);
+	data->callback = callback;
+	data->user_data = user_data;
+	data->accepted_cas = accepted;
+
+	if (priv->async_context)
+		g_main_context_push_thread_default (priv->async_context);
+
+	for (l = accepted; l != NULL; l = g_list_next (l))
+	{
+		g_tls_database_lookup_certificates_issued_by_async (database, l->data,
+								    g_tls_connection_get_interaction (base),
+								    G_TLS_DATABASE_LOOKUP_KEYPAIR,
+								    cancellable, lookup_client_certificate_async_ready,
+								    data);
+	}
+}
+
 /**
  * soup_socket_is_ssl:
  * @sock: a #SoupSocket
diff --git a/libsoup/soup-socket.h b/libsoup/soup-socket.h
index 4d1550f..7686d7c 100644
--- a/libsoup/soup-socket.h
+++ b/libsoup/soup-socket.h
@@ -51,6 +51,7 @@ typedef struct {
 #define SOUP_SOCKET_TIMEOUT             "timeout"
 #define SOUP_SOCKET_TLS_CERTIFICATE     "tls-certificate"
 #define SOUP_SOCKET_TLS_ERRORS          "tls-errors"
+#define SOUP_SOCKET_TLS_INTERACTION     "tls_interaction"
 
 typedef void (*SoupSocketCallback)            (SoupSocket         *sock,
 					       guint               status,
diff --git a/libsoup/soup-status.h b/libsoup/soup-status.h
index fc8d5a3..5efc195 100644
--- a/libsoup/soup-status.h
+++ b/libsoup/soup-status.h
@@ -34,6 +34,7 @@ typedef enum {
 	SOUP_STATUS_TRY_AGAIN,
 	SOUP_STATUS_TOO_MANY_REDIRECTS,
 	SOUP_STATUS_TLS_FAILED,
+	SOUP_STATUS_TLS_CERTIFICATE_REQUIRED,
 
 	/* HTTP Status Codes */
 	SOUP_STATUS_CONTINUE                        = 100,
