Add 'book-config-ldap' module.

Register the "On LDAP Servers" backend in EBookSourceConfig widgets.

6 files changed, 1809 insertions, 0 deletions

diff --git a/configure.ac b/configure.ac
index bf65e3324b..9d17b75bee 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1634,6 +1634,7 @@ modules/calendar/Makefile
 modules/mail/Makefile
 modules/backup-restore/Makefile
 modules/book-config-google/Makefile
+modules/book-config-ldap/Makefile
 modules/book-config-local/Makefile
 modules/composer-autosave/Makefile
 modules/mailto-handler/Makefile
diff --git a/modules/Makefile.am b/modules/Makefile.am
index 1668322e8b..8c4cb9b4eb 100644
--- a/modules/Makefile.am
+++ b/modules/Makefile.am
@@ -1,3 +1,7 @@
+if ENABLE_LDAP
+CONFIG_LDAP_DIR = book-config-ldap
+endif
+
 if ENABLE_MONO
 MONO_DIR = plugin-mono
 endif
@@ -17,6 +21,7 @@ SUBDIRS = \
 	mail \
 	backup-restore \
 	book-config-google \
+	$(CONFIG_LDAP_DIR) \
 	book-config-local \
 	composer-autosave \
 	mailto-handler \
diff --git a/modules/book-config-ldap/Makefile.am b/modules/book-config-ldap/Makefile.am
new file mode 100644
index 0000000000..bcb9cd0695
--- /dev/null
+++ b/modules/book-config-ldap/Makefile.am
@@ -0,0 +1,31 @@
+module_LTLIBRARIES = module-book-config-ldap.la
+
+module_book_config_ldap_la_CPPFLAGS = \
+	$(AM_CPPFLAGS)						\
+	-I$(top_srcdir)						\
+	-I$(top_srcdir)/widgets					\
+	-DG_LOG_DOMAIN=\"evolution-book-config-ldap\"		\
+	$(EVOLUTION_DATA_SERVER_CFLAGS)				\
+	$(GNOME_PLATFORM_CFLAGS)				\
+	$(LDAP_CFLAGS)
+
+module_book_config_ldap_la_SOURCES = \
+	evolution-book-config-ldap.c				\
+	e-source-ldap.c						\
+	e-source-ldap.h
+
+module_book_config_ldap_la_LIBADD = \
+	$(top_builddir)/e-util/libeutil.la			\
+	$(top_builddir)/widgets/misc/libemiscwidgets.la		\
+	$(top_builddir)/addressbook/printing/libecontactprint.la \
+	$(top_builddir)/addressbook/gui/merging/libeabbookmerging.la \
+	$(top_builddir)/addressbook/gui/widgets/libeabwidgets.la \
+	$(top_builddir)/addressbook/util/libeabutil.la		\
+	$(EVOLUTION_DATA_SERVER_LIBS)				\
+	$(GNOME_PLATFORM_LIBS)					\
+	$(LDAP_LIBS)
+
+module_book_config_ldap_la_LDFLAGS = \
+	-module -avoid-version $(NO_UNDEFINED)
+
+-include $(top_srcdir)/git.mk
diff --git a/modules/book-config-ldap/e-source-ldap.c b/modules/book-config-ldap/e-source-ldap.c
new file mode 100644
index 0000000000..4e182dc625
--- /dev/null
+++ b/modules/book-config-ldap/e-source-ldap.c
@@ -0,0 +1,659 @@
+/*
+ * e-source-ldap.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+#include "e-source-ldap.h"
+
+#include <ldap.h>
+
+#include <libedataserver/e-data-server-util.h>
+#include <libedataserver/e-source-authentication.h>
+#include <libedataserver/e-source-security.h>
+
+#define E_SOURCE_LDAP_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE \
+	((obj), E_TYPE_SOURCE_LDAP, ESourceLDAPPrivate))
+
+struct _ESourceLDAPPrivate {
+	GMutex *property_lock;
+	gboolean can_browse;
+	gchar *filter;
+	guint limit;
+	gchar *root_dn;
+	ESourceLDAPScope scope;
+
+	/* These are bound to other extensions. */
+	ESourceLDAPAuthentication authentication;
+	ESourceLDAPSecurity security;
+};
+
+enum {
+	PROP_0,
+	PROP_AUTHENTICATION,
+	PROP_CAN_BROWSE,
+	PROP_FILTER,
+	PROP_LIMIT,
+	PROP_ROOT_DN,
+	PROP_SCOPE,
+	PROP_SECURITY
+};
+
+static GType e_source_ldap_authentication_type = G_TYPE_INVALID;
+static GType e_source_ldap_scope_type = G_TYPE_INVALID;
+static GType e_source_ldap_security_type = G_TYPE_INVALID;
+
+G_DEFINE_DYNAMIC_TYPE (
+	ESourceLDAP,
+	e_source_ldap,
+	E_TYPE_SOURCE_EXTENSION)
+
+static gboolean
+source_ldap_transform_enum_nick_to_value (GBinding *binding,
+                                          const GValue *source_value,
+                                          GValue *target_value,
+                                          gpointer not_used)
+{
+	GEnumClass *enum_class;
+	GEnumValue *enum_value;
+	const gchar *string;
+	gboolean success = FALSE;
+
+	enum_class = g_type_class_peek (G_VALUE_TYPE (target_value));
+	g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), FALSE);
+
+	string = g_value_get_string (source_value);
+	enum_value = g_enum_get_value_by_nick (enum_class, string);
+	if (enum_value != NULL) {
+		g_value_set_enum (target_value, enum_value->value);
+		success = TRUE;
+	}
+
+	return success;
+}
+
+static gboolean
+source_ldap_transform_enum_value_to_nick (GBinding *binding,
+                                          const GValue *source_value,
+                                          GValue *target_value,
+                                          gpointer not_used)
+{
+	GEnumClass *enum_class;
+	GEnumValue *enum_value;
+	gint value;
+	gboolean success = FALSE;
+
+	enum_class = g_type_class_peek (G_VALUE_TYPE (source_value));
+	g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), FALSE);
+
+	value = g_value_get_enum (source_value);
+	enum_value = g_enum_get_value (enum_class, value);
+	if (enum_value != NULL) {
+		g_value_set_string (target_value, enum_value->value_nick);
+		success = TRUE;
+	}
+
+	return success;
+}
+
+static void
+source_ldap_set_property (GObject *object,
+                          guint property_id,
+                          const GValue *value,
+                          GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_AUTHENTICATION:
+			e_source_ldap_set_authentication (
+				E_SOURCE_LDAP (object),
+				g_value_get_enum (value));
+			return;
+
+		case PROP_CAN_BROWSE:
+			e_source_ldap_set_can_browse (
+				E_SOURCE_LDAP (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_FILTER:
+			e_source_ldap_set_filter (
+				E_SOURCE_LDAP (object),
+				g_value_get_string (value));
+			return;
+
+		case PROP_LIMIT:
+			e_source_ldap_set_limit (
+				E_SOURCE_LDAP (object),
+				g_value_get_uint (value));
+			return;
+
+		case PROP_ROOT_DN:
+			e_source_ldap_set_root_dn (
+				E_SOURCE_LDAP (object),
+				g_value_get_string (value));
+			return;
+
+		case PROP_SCOPE:
+			e_source_ldap_set_scope (
+				E_SOURCE_LDAP (object),
+				g_value_get_enum (value));
+			return;
+
+		case PROP_SECURITY:
+			e_source_ldap_set_security (
+				E_SOURCE_LDAP (object),
+				g_value_get_enum (value));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+source_ldap_get_property (GObject *object,
+                          guint property_id,
+                          GValue *value,
+                          GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_AUTHENTICATION:
+			g_value_set_enum (
+				value,
+				e_source_ldap_get_authentication (
+				E_SOURCE_LDAP (object)));
+			return;
+
+		case PROP_CAN_BROWSE:
+			g_value_set_boolean (
+				value,
+				e_source_ldap_get_can_browse (
+				E_SOURCE_LDAP (object)));
+			return;
+
+		case PROP_FILTER:
+			g_value_take_string (
+				value,
+				e_source_ldap_dup_filter (
+				E_SOURCE_LDAP (object)));
+			return;
+
+		case PROP_LIMIT:
+			g_value_set_uint (
+				value,
+				e_source_ldap_get_limit (
+				E_SOURCE_LDAP (object)));
+			return;
+
+		case PROP_ROOT_DN:
+			g_value_take_string (
+				value,
+				e_source_ldap_dup_root_dn (
+				E_SOURCE_LDAP (object)));
+			return;
+
+		case PROP_SCOPE:
+			g_value_set_enum (
+				value,
+				e_source_ldap_get_scope (
+				E_SOURCE_LDAP (object)));
+			return;
+
+		case PROP_SECURITY:
+			g_value_set_enum (
+				value,
+				e_source_ldap_get_security (
+				E_SOURCE_LDAP (object)));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+source_ldap_finalize (GObject *object)
+{
+	ESourceLDAPPrivate *priv;
+
+	priv = E_SOURCE_LDAP_GET_PRIVATE (object);
+
+	g_mutex_free (priv->property_lock);
+
+	g_free (priv->filter);
+	g_free (priv->root_dn);
+
+	/* Chain up to parent's finalize() method. */
+	G_OBJECT_CLASS (e_source_ldap_parent_class)->finalize (object);
+}
+
+static void
+source_ldap_constructed (GObject *object)
+{
+	ESource *source;
+	ESourceExtension *this_extension;
+	ESourceExtension *other_extension;
+	const gchar *extension_name;
+
+	this_extension = E_SOURCE_EXTENSION (object);
+	source = e_source_extension_get_source (this_extension);
+
+	extension_name = E_SOURCE_EXTENSION_AUTHENTICATION;
+	other_extension = e_source_get_extension (source, extension_name);
+
+	g_object_bind_property_full (
+		other_extension, "method",
+		this_extension, "authentication",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE,
+		source_ldap_transform_enum_nick_to_value,
+		source_ldap_transform_enum_value_to_nick,
+		NULL, (GDestroyNotify) NULL);
+
+	extension_name = E_SOURCE_EXTENSION_SECURITY;
+	other_extension = e_source_get_extension (source, extension_name);
+
+	g_object_bind_property_full (
+		other_extension, "method",
+		this_extension, "security",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE,
+		source_ldap_transform_enum_nick_to_value,
+		source_ldap_transform_enum_value_to_nick,
+		NULL, (GDestroyNotify) NULL);
+}
+
+static void
+e_source_ldap_class_init (ESourceLDAPClass *class)
+{
+	GObjectClass *object_class;
+	ESourceExtensionClass *extension_class;
+
+	g_type_class_add_private (class, sizeof (ESourceLDAPPrivate));
+
+	object_class = G_OBJECT_CLASS (class);
+	object_class->set_property = source_ldap_set_property;
+	object_class->get_property = source_ldap_get_property;
+	object_class->finalize = source_ldap_finalize;
+	object_class->constructed = source_ldap_constructed;
+
+	extension_class = E_SOURCE_EXTENSION_CLASS (class);
+	extension_class->name = E_SOURCE_EXTENSION_LDAP_BACKEND;
+
+	/* This is bound to the authentication extension.
+	 * Do not use E_SOURCE_PARAM_SETTING here. */
+	g_object_class_install_property (
+		object_class,
+		PROP_AUTHENTICATION,
+		g_param_spec_enum (
+			"authentication",
+			"Authentication",
+			"LDAP authentication method",
+			E_TYPE_SOURCE_LDAP_AUTHENTICATION,
+			E_SOURCE_LDAP_AUTHENTICATION_NONE,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_CAN_BROWSE,
+		g_param_spec_boolean (
+			"can-browse",
+			"Can Browse",
+			"Allow browsing contacts",
+			FALSE,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT |
+			E_SOURCE_PARAM_SETTING));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_FILTER,
+		g_param_spec_string (
+			"filter",
+			"Filter",
+			"LDAP search filter",
+			"",
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT |
+			E_SOURCE_PARAM_SETTING));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_LIMIT,
+		g_param_spec_uint (
+			"limit",
+			"Limit",
+			"Download limit",
+			0, G_MAXUINT, 100,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT |
+			E_SOURCE_PARAM_SETTING));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_ROOT_DN,
+		g_param_spec_string (
+			"root-dn",
+			"Root DN",
+			"LDAP search base",
+			"",
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT |
+			E_SOURCE_PARAM_SETTING));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_SCOPE,
+		g_param_spec_enum (
+			"scope",
+			"Scope",
+			"LDAP search scope",
+			E_TYPE_SOURCE_LDAP_SCOPE,
+			E_SOURCE_LDAP_SCOPE_ONELEVEL,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT |
+			E_SOURCE_PARAM_SETTING));
+
+	/* This is bound to the security extension.
+	 * Do not use E_SOURCE_PARAM_SETTING here. */
+	g_object_class_install_property (
+		object_class,
+		PROP_SECURITY,
+		g_param_spec_enum (
+			"security",
+			"Security",
+			"LDAP security method",
+			E_TYPE_SOURCE_LDAP_SECURITY,
+			E_SOURCE_LDAP_SECURITY_NONE,
+			G_PARAM_READWRITE));
+}
+
+static void
+e_source_ldap_class_finalize (ESourceLDAPClass *class)
+{
+}
+
+static void
+e_source_ldap_init (ESourceLDAP *extension)
+{
+	extension->priv = E_SOURCE_LDAP_GET_PRIVATE (extension);
+	extension->priv->property_lock = g_mutex_new ();
+}
+
+void
+e_source_ldap_type_register (GTypeModule *type_module)
+{
+	static const GEnumValue e_source_ldap_authentication_values[] = {
+		{ E_SOURCE_LDAP_AUTHENTICATION_NONE,
+		  "E_SOURCE_LDAP_AUTHENTICATION_NONE",
+		  "none" },
+		{ E_SOURCE_LDAP_AUTHENTICATION_EMAIL,
+		  "E_SOURCE_LDAP_AUTHENTICATION_EMAIL",
+		  "ldap/simple-email" },
+		{ E_SOURCE_LDAP_AUTHENTICATION_BINDDN,
+		  "E_SOURCE_LDAP_AUTHENTICATION_BINDDN",
+		  "ldap/simple-binddn" },
+		{ 0, NULL, NULL }
+	};
+
+	static const GEnumValue e_source_ldap_scope_values[] = {
+		{ E_SOURCE_LDAP_SCOPE_ONELEVEL,
+		  "E_SOURCE_LDAP_SCOPE_ONELEVEL",
+		  "onelevel" },
+		{ E_SOURCE_LDAP_SCOPE_SUBTREE,
+		  "E_SOURCE_LDAP_SCOPE_SUBTREE",
+		  "subtree" },
+		{ 0, NULL, NULL }
+	};
+
+	static const GEnumValue e_source_ldap_security_values[] = {
+		{ E_SOURCE_LDAP_SECURITY_NONE,
+		  "E_SOURCE_LDAP_SECURITY_NONE",
+		  "none" },
+		{ E_SOURCE_LDAP_SECURITY_LDAPS,
+		  "E_SOURCE_LDAP_SECURITY_LDAPS",
+		  "ldaps" },
+		{ E_SOURCE_LDAP_SECURITY_STARTTLS,
+		  "E_SOURCE_LDAP_SECURITY_STARTTLS",
+		  "starttls" },
+		{ 0, NULL, NULL }
+	};
+
+	e_source_ldap_authentication_type =
+		g_type_module_register_enum (
+		type_module, "ESourceLDAPAuthentication",
+		e_source_ldap_authentication_values);
+
+	e_source_ldap_scope_type =
+		g_type_module_register_enum (
+		type_module, "ESourceLDAPScope",
+		e_source_ldap_scope_values);
+
+	e_source_ldap_security_type =
+		g_type_module_register_enum (
+		type_module, "ESourceLDAPSecurity",
+		e_source_ldap_security_values);
+
+	/* XXX G_DEFINE_DYNAMIC_TYPE declares a static type registration
+	 *     function, so we have to wrap it with a public function in
+	 *     order to register types from a separate compilation unit. */
+	e_source_ldap_register_type (type_module);
+}
+
+ESourceLDAPAuthentication
+e_source_ldap_get_authentication (ESourceLDAP *extension)
+{
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), 0);
+
+	return extension->priv->authentication;
+}
+
+void
+e_source_ldap_set_authentication (ESourceLDAP *extension,
+                                  ESourceLDAPAuthentication authentication)
+{
+	g_return_if_fail (E_IS_SOURCE_LDAP (extension));
+
+	extension->priv->authentication = authentication;
+
+	g_object_notify (G_OBJECT (extension), "authentication");
+}
+
+gboolean
+e_source_ldap_get_can_browse (ESourceLDAP *extension)
+{
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), FALSE);
+
+	return extension->priv->can_browse;
+}
+
+void
+e_source_ldap_set_can_browse (ESourceLDAP *extension,
+                              gboolean can_browse)
+{
+	g_return_if_fail (E_IS_SOURCE_LDAP (extension));
+
+	extension->priv->can_browse = can_browse;
+
+	g_object_notify (G_OBJECT (extension), "can-browse");
+}
+
+const gchar *
+e_source_ldap_get_filter (ESourceLDAP *extension)
+{
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), NULL);
+
+	return extension->priv->filter;
+}
+
+gchar *
+e_source_ldap_dup_filter (ESourceLDAP *extension)
+{
+	const gchar *protected;
+	gchar *duplicate;
+
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), NULL);
+
+	g_mutex_lock (extension->priv->property_lock);
+
+	protected = e_source_ldap_get_filter (extension);
+	duplicate = g_strdup (protected);
+
+	g_mutex_unlock (extension->priv->property_lock);
+
+	return duplicate;
+}
+
+void
+e_source_ldap_set_filter (ESourceLDAP *extension,
+                          const gchar *filter)
+{
+	gboolean needs_parens;
+
+	g_return_if_fail (E_IS_SOURCE_LDAP (extension));
+
+	needs_parens =
+		(filter != NULL) && (*filter != '\0') &&
+		!g_str_has_prefix (filter, "(") &&
+		!g_str_has_suffix (filter, ")");
+
+	g_mutex_lock (extension->priv->property_lock);
+
+	g_free (extension->priv->filter);
+	if (needs_parens)
+		extension->priv->filter = g_strdup_printf ("(%s)", filter);
+	else
+		extension->priv->filter = g_strdup (filter);
+
+	g_mutex_unlock (extension->priv->property_lock);
+
+	g_object_notify (G_OBJECT (extension), "filter");
+}
+
+guint
+e_source_ldap_get_limit (ESourceLDAP *extension)
+{
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), 0);
+
+	return extension->priv->limit;
+}
+
+void
+e_source_ldap_set_limit (ESourceLDAP *extension,
+                         guint limit)
+{
+	g_return_if_fail (E_IS_SOURCE_LDAP (extension));
+
+	extension->priv->limit = limit;
+
+	g_object_notify (G_OBJECT (extension), "limit");
+}
+
+const gchar *
+e_source_ldap_get_root_dn (ESourceLDAP *extension)
+{
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), NULL);
+
+	return extension->priv->root_dn;
+}
+
+gchar *
+e_source_ldap_dup_root_dn (ESourceLDAP *extension)
+{
+	const gchar *protected;
+	gchar *duplicate;
+
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), NULL);
+
+	g_mutex_lock (extension->priv->property_lock);
+
+	protected = e_source_ldap_get_root_dn (extension);
+	duplicate = g_strdup (protected);
+
+	g_mutex_unlock (extension->priv->property_lock);
+
+	return duplicate;
+}
+
+void
+e_source_ldap_set_root_dn (ESourceLDAP *extension,
+                           const gchar *root_dn)
+{
+	g_return_if_fail (E_IS_SOURCE_LDAP (extension));
+
+	g_mutex_lock (extension->priv->property_lock);
+
+	g_free (extension->priv->root_dn);
+	extension->priv->root_dn = e_util_strdup_strip (root_dn);
+
+	g_mutex_unlock (extension->priv->property_lock);
+
+	g_object_notify (G_OBJECT (extension), "root-dn");
+}
+
+ESourceLDAPScope
+e_source_ldap_get_scope (ESourceLDAP *extension)
+{
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), 0);
+
+	return extension->priv->scope;
+}
+
+void
+e_source_ldap_set_scope (ESourceLDAP *extension,
+                         ESourceLDAPScope scope)
+{
+	g_return_if_fail (E_IS_SOURCE_LDAP (extension));
+
+	extension->priv->scope = scope;
+
+	g_object_notify (G_OBJECT (extension), "scope");
+}
+
+ESourceLDAPSecurity
+e_source_ldap_get_security (ESourceLDAP *extension)
+{
+	g_return_val_if_fail (E_IS_SOURCE_LDAP (extension), 0);
+
+	return extension->priv->security;
+}
+
+void
+e_source_ldap_set_security (ESourceLDAP *extension,
+                            ESourceLDAPSecurity security)
+{
+	g_return_if_fail (E_IS_SOURCE_LDAP (extension));
+
+	extension->priv->security = security;
+
+	g_object_notify (G_OBJECT (extension), "security");
+}
+
+GType
+e_source_ldap_authentication_get_type (void)
+{
+	return e_source_ldap_authentication_type;
+}
+
+GType
+e_source_ldap_scope_get_type (void)
+{
+	return e_source_ldap_scope_type;
+}
+
+GType
+e_source_ldap_security_get_type (void)
+{
+	return e_source_ldap_security_type;
+}
diff --git a/modules/book-config-ldap/e-source-ldap.h b/modules/book-config-ldap/e-source-ldap.h
new file mode 100644
index 0000000000..ea9cb9fd8c
--- /dev/null
+++ b/modules/book-config-ldap/e-source-ldap.h
@@ -0,0 +1,123 @@
+/*
+ * e-source-ldap.h
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+#ifndef E_SOURCE_LDAP_H
+#define E_SOURCE_LDAP_H
+
+#include <libedataserver/e-source-extension.h>
+
+/* Standard GObject macros */
+#define E_TYPE_SOURCE_LDAP \
+	(e_source_ldap_get_type ())
+#define E_SOURCE_LDAP(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST \
+	((obj), E_TYPE_SOURCE_LDAP, ESourceLDAP))
+#define E_SOURCE_LDAP_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_CAST \
+	((cls), E_TYPE_SOURCE_LDAP, ESourceLDAPClass))
+#define E_IS_SOURCE_LDAP(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE \
+	((obj), E_TYPE_SOURCE_LDAP))
+#define E_IS_SOURCE_LDAP_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_TYPE \
+	((cls), E_TYPE_SOURCE_LDAP))
+#define E_SOURCE_LDAP_GET_CLASS(obj) \
+	(G_TYPE_INSTANCE_GET_CLASS \
+	((obj), E_TYPE_SOURCE_LDAP, ESourceLDAPClass))
+
+#define E_TYPE_SOURCE_LDAP_AUTHENTICATION \
+	(e_source_ldap_authentication_get_type ())
+
+#define E_TYPE_SOURCE_LDAP_SCOPE \
+	(e_source_ldap_scope_get_type ())
+
+#define E_TYPE_SOURCE_LDAP_SECURITY \
+	(e_source_ldap_security_get_type ())
+
+#define E_SOURCE_EXTENSION_LDAP_BACKEND "LDAP Backend"
+
+G_BEGIN_DECLS
+
+typedef struct _ESourceLDAP ESourceLDAP;
+typedef struct _ESourceLDAPClass ESourceLDAPClass;
+typedef struct _ESourceLDAPPrivate ESourceLDAPPrivate;
+
+struct _ESourceLDAP {
+	ESourceExtension parent;
+	ESourceLDAPPrivate *priv;
+};
+
+struct _ESourceLDAPClass {
+	ESourceExtensionClass parent_class;
+};
+
+typedef enum {
+	E_SOURCE_LDAP_AUTHENTICATION_NONE,
+	E_SOURCE_LDAP_AUTHENTICATION_EMAIL,
+	E_SOURCE_LDAP_AUTHENTICATION_BINDDN
+} ESourceLDAPAuthentication;
+
+typedef enum {
+	E_SOURCE_LDAP_SCOPE_ONELEVEL,
+	E_SOURCE_LDAP_SCOPE_SUBTREE
+} ESourceLDAPScope;
+
+typedef enum {
+	E_SOURCE_LDAP_SECURITY_NONE,
+	E_SOURCE_LDAP_SECURITY_LDAPS,
+	E_SOURCE_LDAP_SECURITY_STARTTLS
+} ESourceLDAPSecurity;
+
+GType		e_source_ldap_get_type		(void);
+void		e_source_ldap_type_register	(GTypeModule *type_module);
+ESourceLDAPAuthentication
+		e_source_ldap_get_authentication
+						(ESourceLDAP *extension);
+void		e_source_ldap_set_authentication
+						(ESourceLDAP *extension,
+						 ESourceLDAPAuthentication authentication);
+gboolean	e_source_ldap_get_can_browse	(ESourceLDAP *extension);
+void		e_source_ldap_set_can_browse	(ESourceLDAP *extension,
+						 gboolean can_browse);
+const gchar *	e_source_ldap_get_filter	(ESourceLDAP *extension);
+gchar *		e_source_ldap_dup_filter	(ESourceLDAP *extension);
+void		e_source_ldap_set_filter	(ESourceLDAP *extension,
+						 const gchar *filter);
+guint		e_source_ldap_get_limit		(ESourceLDAP *extension);
+void		e_source_ldap_set_limit		(ESourceLDAP *extension,
+						 guint limit);
+const gchar *	e_source_ldap_get_root_dn	(ESourceLDAP *extension);
+gchar *		e_source_ldap_dup_root_dn	(ESourceLDAP *extension);
+void		e_source_ldap_set_root_dn	(ESourceLDAP *extension,
+						 const gchar *root_dn);
+ESourceLDAPScope
+		e_source_ldap_get_scope		(ESourceLDAP *extension);
+void		e_source_ldap_set_scope		(ESourceLDAP *extension,
+						 ESourceLDAPScope scope);
+ESourceLDAPSecurity
+		e_source_ldap_get_security	(ESourceLDAP *extension);
+void		e_source_ldap_set_security	(ESourceLDAP *extension,
+						 ESourceLDAPSecurity security);
+
+GType		e_source_ldap_authentication_get_type	(void);
+GType		e_source_ldap_scope_get_type		(void);
+GType		e_source_ldap_security_get_type		(void);
+
+G_END_DECLS
+
+#endif /* E_SOURCE_LDAP_H */
diff --git a/modules/book-config-ldap/evolution-book-config-ldap.c b/modules/book-config-ldap/evolution-book-config-ldap.c
new file mode 100644
index 0000000000..a957e4c94a
--- /dev/null
+++ b/modules/book-config-ldap/evolution-book-config-ldap.c
@@ -0,0 +1,990 @@
+/*
+ * evolution-book-config-ldap.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+#include <config.h>
+#include <stdlib.h>
+#include <glib/gi18n-lib.h>
+
+#include <libebackend/e-extension.h>
+#include <libedataserver/e-source-authentication.h>
+
+#include <libevolution-utils/e-alert-dialog.h>
+#include <misc/e-source-config-backend.h>
+#include <addressbook/gui/widgets/e-book-source-config.h>
+
+#include "e-source-ldap.h"
+
+#ifndef G_OS_WIN32
+#include <ldap.h>
+#ifndef SUNLDAP
+#include <ldap_schema.h>
+#endif
+#else
+#include <winldap.h>
+#include "openldap-extract.h"
+#endif
+
+/* Combo box ordering */
+#define LDAP_PORT  389
+#define LDAPS_PORT 636
+#define MSGC_PORT  3268
+#define MSGCS_PORT 3269
+
+typedef ESourceConfigBackend EBookConfigLDAP;
+typedef ESourceConfigBackendClass EBookConfigLDAPClass;
+
+typedef struct _Closure Closure;
+typedef struct _Context Context;
+
+struct _Closure {
+	ESourceConfigBackend *backend;
+	ESource *scratch_source;
+};
+
+struct _Context {
+	GtkWidget *auth_combo;
+	GtkWidget *auth_entry;
+	GtkWidget *host_entry;
+	GtkWidget *port_combo;
+	GtkWidget *security_combo;
+	GtkWidget *search_base_combo;
+	GtkWidget *search_base_button;
+	GtkWidget *search_scope_combo;
+	GtkWidget *search_filter_entry;
+	GtkWidget *limit_spinbutton;
+	GtkWidget *can_browse_toggle;
+};
+
+/* Module Entry Points */
+void e_module_load (GTypeModule *type_module);
+void e_module_unload (GTypeModule *type_module);
+
+/* Forward Declarations */
+GType e_book_config_ldap_get_type (void);
+
+G_DEFINE_DYNAMIC_TYPE (
+	EBookConfigLDAP,
+	e_book_config_ldap,
+	E_TYPE_SOURCE_CONFIG_BACKEND)
+
+static Closure *
+book_config_ldap_closure_new (ESourceConfigBackend *backend,
+                              ESource *scratch_source)
+{
+	Closure *closure;
+
+	closure = g_slice_new (Closure);
+	closure->backend = g_object_ref (backend);
+	closure->scratch_source = g_object_ref (scratch_source);
+
+	return closure;
+}
+
+static void
+book_config_ldap_closure_free (Closure *closure)
+{
+	g_object_unref (closure->backend);
+	g_object_unref (closure->scratch_source);
+
+	g_slice_free (Closure, closure);
+}
+
+static void
+book_config_ldap_context_free (Context *context)
+{
+	g_object_unref (context->auth_combo);
+	g_object_unref (context->auth_entry);
+	g_object_unref (context->host_entry);
+	g_object_unref (context->port_combo);
+	g_object_unref (context->security_combo);
+	g_object_unref (context->search_base_combo);
+	g_object_unref (context->search_base_button);
+	g_object_unref (context->search_scope_combo);
+	g_object_unref (context->search_filter_entry);
+	g_object_unref (context->limit_spinbutton);
+	g_object_unref (context->can_browse_toggle);
+
+	g_slice_free (Context, context);
+}
+
+static GtkTreeModel *
+book_config_ldap_root_dse_query (ESourceConfigBackend *backend,
+                                 ESource *scratch_source)
+{
+	LDAP *ldap;
+	LDAPMessage *result = NULL;
+	GtkListStore *store = NULL;
+	ESourceAuthentication *extension;
+	struct timeval timeout;
+	const gchar *alert_id = NULL;
+	const gchar *extension_name;
+	const gchar *host;
+	gchar **values = NULL;
+	gint ldap_error;
+	gint option;
+	gint version;
+	guint16 port;
+	gint ii;
+
+	const gchar *attrs[] = { "namingContexts", NULL };
+
+	/* FIXME This all runs synchronously in the main loop.
+	 *       We should do this in a separate thread behind
+	 *       async/finish functions.  May need to define
+	 *       some custom GError codes, or maybe just an
+	 *       LDAP GError domain that reuses LDAP result
+	 *       codes from <ldap.h>. */
+
+	extension_name = E_SOURCE_EXTENSION_AUTHENTICATION;
+	extension = e_source_get_extension (scratch_source, extension_name);
+
+	host = e_source_authentication_get_host (extension);
+	port = e_source_authentication_get_port (extension);
+
+	timeout.tv_sec = 60;
+	timeout.tv_usec = 0;
+
+	ldap = ldap_init (host, port);
+	if (ldap == NULL) {
+		alert_id = "addressbook:ldap-init";
+		goto exit;
+	}
+
+	version = LDAP_VERSION3;
+	option = LDAP_OPT_PROTOCOL_VERSION;
+	if (ldap_set_option (ldap, option, &version) != LDAP_SUCCESS) {
+		/* XXX Define an alert for this. */
+		g_warning ("Failed to set protocol version to LDAPv3");
+		goto exit;
+	}
+
+	/* FIXME Use the user's actual authentication settings. */
+	if (ldap_simple_bind_s (ldap, NULL, NULL) != LDAP_SUCCESS) {
+		alert_id = "addressbook:ldap-auth";
+		goto exit;
+	}
+
+	ldap_error = ldap_search_ext_s (
+		ldap, LDAP_ROOT_DSE, LDAP_SCOPE_BASE,
+		"(objectclass=*)", (gchar **) attrs, 0,
+		NULL, NULL, &timeout, LDAP_NO_LIMIT, &result);
+	if (ldap_error != LDAP_SUCCESS) {
+		alert_id = "addressbook:ldap-search-base";
+		goto exit;
+	}
+
+	values = ldap_get_values (ldap, result, "namingContexts");
+	if (values == NULL || values[0] == NULL || *values[0] == '\0') {
+		alert_id = "addressbook:ldap-search-base";
+		goto exit;
+	}
+
+	store = gtk_list_store_new (1, G_TYPE_STRING);
+
+	for (ii = 0; values[ii] != NULL; ii++) {
+		GtkTreeIter iter;
+
+		gtk_list_store_append (store, &iter);
+		gtk_list_store_set (store, &iter, 0, values[ii], -1);
+	}
+
+exit:
+	if (alert_id != NULL) {
+		ESourceConfig *config;
+		gpointer parent;
+
+		config = e_source_config_backend_get_config (backend);
+
+		parent = gtk_widget_get_toplevel (GTK_WIDGET (config));
+		parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
+
+		e_alert_run_dialog_for_args (parent, alert_id, NULL);
+	}
+
+	if (values != NULL)
+		ldap_value_free (values);
+
+	if (result != NULL)
+		ldap_msgfree (result);
+
+	if (ldap != NULL)
+		ldap_unbind_s (ldap);
+
+	/* This may be NULL, so don't use a cast macro. */
+	return (GtkTreeModel *) store;
+}
+
+static gboolean
+book_config_ldap_port_to_active (GBinding *binding,
+                                 const GValue *source_value,
+                                 GValue *target_value,
+                                 gpointer unused)
+{
+	guint port;
+	gint active;
+
+	port = g_value_get_uint (source_value);
+
+	switch (port) {
+		case 0:  /* initialize to LDAP_PORT */
+		case LDAP_PORT:
+			active = 0;
+			break;
+
+		case LDAPS_PORT:
+			active = 1;
+			break;
+
+		case MSGC_PORT:
+			active = 2;
+			break;
+
+		case MSGCS_PORT:
+			active = 3;
+			break;
+
+		default:
+			active = -1;
+			break;
+	}
+
+	g_value_set_int (target_value, active);
+
+	if (active == -1) {
+		GObject *target;
+		GtkWidget *entry;
+		gchar *text;
+
+		target = g_binding_get_target (binding);
+		entry = gtk_bin_get_child (GTK_BIN (target));
+
+		text = g_strdup_printf ("%u", port);
+		gtk_entry_set_text (GTK_ENTRY (entry), text);
+		g_free (text);
+	}
+
+	return TRUE;
+}
+
+static gboolean
+book_config_ldap_active_to_port (GBinding *binding,
+                                 const GValue *source_value,
+                                 GValue *target_value,
+                                 gpointer unused)
+{
+	guint port = LDAP_PORT;
+	gint active;
+
+	active = g_value_get_int (source_value);
+
+	switch (active) {
+		case 0:
+			port = LDAP_PORT;
+			break;
+
+		case 1:
+			port = LDAPS_PORT;
+			break;
+
+		case 2:
+			port = MSGC_PORT;
+			break;
+
+		case 3:
+			port = MSGCS_PORT;
+			break;
+
+		default:
+			active = -1;
+			break;
+	}
+
+	if (active == -1) {
+		GObject *source;
+		GtkWidget *entry;
+		const gchar *text;
+		glong v_long;
+
+		source = g_binding_get_source (binding);
+		entry = gtk_bin_get_child (GTK_BIN (source));
+		text = gtk_entry_get_text (GTK_ENTRY (entry));
+
+		v_long = strtol (text, NULL, 10);
+		if (v_long != 0 && v_long == CLAMP (v_long, 0, G_MAXUINT16))
+			port = (guint) v_long;
+	}
+
+	g_value_set_uint (target_value, port);
+
+	return TRUE;
+}
+
+static gboolean
+book_config_ldap_port_to_security (GBinding *binding,
+                                   const GValue *source_value,
+                                   GValue *target_value,
+                                   gpointer unused)
+{
+	switch (g_value_get_int (source_value)) {
+		case 0:  /* LDAP_PORT -> StartTLS */
+			g_value_set_int (
+				target_value,
+				E_SOURCE_LDAP_SECURITY_STARTTLS);
+			return TRUE;
+
+		case 1:  /* LDAPS_PORT -> LDAP over SSL */
+			g_value_set_int (
+				target_value,
+				E_SOURCE_LDAP_SECURITY_LDAPS);
+			return TRUE;
+
+		case 2:  /* MSGC_PORT -> StartTLS */
+			g_value_set_int (
+				target_value,
+				E_SOURCE_LDAP_SECURITY_STARTTLS);
+			return TRUE;
+
+		case 3:  /* MSGCS_PORT -> LDAP over SSL */
+			g_value_set_int (
+				target_value,
+				E_SOURCE_LDAP_SECURITY_LDAPS);
+			return TRUE;
+
+		default:
+			break;
+	}
+
+	return FALSE;
+}
+
+static void
+book_config_ldap_search_base_button_clicked_cb (GtkButton *button,
+                                                Closure *closure)
+{
+	Context *context;
+	GtkComboBox *combo_box;
+	GtkTreeModel *model;
+	const gchar *uid;
+
+	uid = e_source_get_uid (closure->scratch_source);
+	context = g_object_get_data (G_OBJECT (closure->backend), uid);
+	g_return_if_fail (context != NULL);
+
+	model = book_config_ldap_root_dse_query (
+		closure->backend, closure->scratch_source);
+
+	combo_box = GTK_COMBO_BOX (context->search_base_combo);
+	gtk_combo_box_set_model (combo_box, model);
+	gtk_combo_box_set_active (combo_box, 0);
+
+	if (model != NULL)
+		g_object_unref (model);
+}
+
+static gboolean
+book_config_ldap_query_port_tooltip_cb (GtkComboBox *combo_box,
+                                        gint x,
+                                        gint y,
+                                        gboolean keyboard_mode,
+                                        GtkTooltip *tooltip)
+{
+	GtkTreeModel *model;
+	GtkTreeIter iter;
+	gchar *text;
+
+	/* XXX This only works if the port number was selected from
+	 *     the drop down menu.  No tooltip is shown if the user
+	 *     types the port number, even if the same port number
+	 *     is listed in the drop down menu.  That's fixable but
+	 *     the code would be a lot messier, and is arguably a
+	 *     job for GtkComboBox. */
+
+	if (!gtk_combo_box_get_active_iter (combo_box, &iter))
+		return FALSE;
+
+	model = gtk_combo_box_get_model (combo_box);
+	gtk_tree_model_get (model, &iter, 1, &text, -1);
+	gtk_tooltip_set_text (tooltip, text);
+	g_free (text);
+
+	return TRUE;
+}
+
+static GtkWidget *
+book_config_build_port_combo (void)
+{
+	GtkWidget *widget;
+	GtkComboBox *combo_box;
+	GtkCellRenderer *renderer;
+	GtkListStore *store;
+	GtkTreeIter iter;
+
+	store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
+
+	gtk_list_store_append (store, &iter);
+	gtk_list_store_set (
+		store, &iter,
+		0, G_STRINGIFY (LDAP_PORT),
+		1, _("Standard LDAP Port"), -1);
+
+	gtk_list_store_append (store, &iter);
+	gtk_list_store_set (
+		store, &iter,
+		0, G_STRINGIFY (LDAPS_PORT),
+		1, _("LDAP over SSL (deprecated)"), -1);
+
+	gtk_list_store_append (store, &iter);
+	gtk_list_store_set (
+		store, &iter,
+		0, G_STRINGIFY (MSGC_PORT),
+		1, _("Microsoft Global Catalog"), -1);
+
+	gtk_list_store_append (store, &iter);
+	gtk_list_store_set (
+		store, &iter,
+		0, G_STRINGIFY (MSGCS_PORT),
+		1, _("Microsoft Global Catalog over SSL"), -1);
+
+	widget = gtk_combo_box_new_with_entry ();
+
+	combo_box = GTK_COMBO_BOX (widget);
+	gtk_combo_box_set_model (combo_box, GTK_TREE_MODEL (store));
+	gtk_combo_box_set_entry_text_column (combo_box, 0);
+
+	renderer = gtk_cell_renderer_text_new ();
+	g_object_set (renderer, "sensitive", FALSE, NULL);
+	gtk_cell_layout_pack_start (
+		GTK_CELL_LAYOUT (widget), renderer, FALSE);
+	gtk_cell_layout_add_attribute (
+		GTK_CELL_LAYOUT (widget), renderer, "text", 1);
+
+	gtk_widget_set_has_tooltip (widget, TRUE);
+
+	g_signal_connect (
+		widget, "query-tooltip",
+		G_CALLBACK (book_config_ldap_query_port_tooltip_cb), NULL);
+
+	g_object_unref (store);
+
+	return widget;
+}
+
+static void
+book_config_ldap_insert_notebook_widget (GtkWidget *vbox,
+                                         GtkSizeGroup *size_group,
+                                         const gchar *caption,
+                                         GtkWidget *widget)
+{
+	GtkWidget *hbox;
+	GtkWidget *label;
+
+	/* This is similar to e_source_config_insert_widget(),
+	 * but instead adds the widget to the LDAP notebook. */
+
+	hbox = gtk_hbox_new (FALSE, 12);
+	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
+	gtk_widget_show (hbox);
+
+	label = gtk_label_new (caption);
+	gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
+	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
+	gtk_size_group_add_widget (size_group, label);
+	gtk_widget_show (label);
+
+	gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
+}
+
+static void
+book_config_ldap_insert_widgets (ESourceConfigBackend *backend,
+                                 ESource *scratch_source)
+{
+	ESourceConfig *config;
+	ESourceExtension *extension;
+	GtkSizeGroup *size_group;
+	GtkNotebook *notebook;
+	GtkWidget *container;
+	GtkWidget *widget;
+	GtkWidget *page;
+	GtkWidget *hbox;
+	Context *context;
+	PangoAttribute *attr;
+	PangoAttrList *attr_list;
+	const gchar *extension_name;
+	const gchar *tab_label;
+	const gchar *uid;
+
+	context = g_slice_new (Context);
+	uid = e_source_get_uid (scratch_source);
+	config = e_source_config_backend_get_config (backend);
+
+	g_object_set_data_full (
+		G_OBJECT (backend), uid, context,
+		(GDestroyNotify) book_config_ldap_context_free);
+
+	e_book_source_config_add_offline_toggle (
+		E_BOOK_SOURCE_CONFIG (config), scratch_source);
+
+	container = e_source_config_get_page (config, scratch_source);
+
+	/* Extra padding between the notebook and the options above. */
+	widget = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
+	gtk_alignment_set_padding (GTK_ALIGNMENT (widget), 6, 0, 0, 0);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_notebook_new ();
+	gtk_container_add (GTK_CONTAINER (container), widget);
+	gtk_widget_show (widget);
+
+	notebook = GTK_NOTEBOOK (widget);
+
+	/* For bold section headers. */
+	attr_list = pango_attr_list_new ();
+	attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
+	pango_attr_list_insert (attr_list, attr);
+
+	/* Page 1 */
+
+	tab_label = _("Connecting to LDAP");
+	page = gtk_vbox_new (FALSE, 12);
+	gtk_container_set_border_width (GTK_CONTAINER (page), 12);
+	gtk_notebook_append_page (notebook, page, NULL);
+	gtk_notebook_set_tab_label_text (notebook, page, tab_label);
+	gtk_widget_show (page);
+
+	size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+	/* Page 1 : Server Information */
+
+	widget = gtk_vbox_new (FALSE, 6);
+	gtk_box_pack_start (GTK_BOX (page), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_label_new (_("Server Information"));
+	gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
+	gtk_label_set_attributes (GTK_LABEL (widget), attr_list);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	widget = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
+	gtk_alignment_set_padding (GTK_ALIGNMENT (widget), 0, 0, 12, 0);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_vbox_new (FALSE, 6);
+	gtk_container_add (GTK_CONTAINER (container), widget);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_entry_new ();
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Server:"), widget);
+	context->host_entry = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	widget = book_config_build_port_combo ();
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Port:"), widget);
+	context->port_combo = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	/* This must follow the order of ESourceLDAPSecurity. */
+	widget = gtk_combo_box_text_new ();
+	gtk_combo_box_text_append_text (
+		GTK_COMBO_BOX_TEXT (widget),
+		_("None"));
+	gtk_combo_box_text_append_text (
+		GTK_COMBO_BOX_TEXT (widget),
+		_("LDAP over SSL (deprecated)"));
+	gtk_combo_box_text_append_text (
+		GTK_COMBO_BOX_TEXT (widget),
+		_("StartTLS (recommended)"));
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Encryption:"), widget);
+	context->security_combo = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	g_object_bind_property_full (
+		context->port_combo, "active",
+		context->security_combo, "active",
+		G_BINDING_DEFAULT,
+		book_config_ldap_port_to_security,
+		NULL,  /* binding is one-way */
+		NULL, (GDestroyNotify) NULL);
+
+	/* If this is a new source, initialize security to StartTLS. */
+	if (e_source_config_get_original_source (config) == NULL)
+		gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 2);
+
+	/* Page 1 : Authentication */
+
+	widget = gtk_vbox_new (FALSE, 6);
+	gtk_box_pack_start (GTK_BOX (page), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_label_new (_("Authentication"));
+	gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
+	gtk_label_set_attributes (GTK_LABEL (widget), attr_list);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	widget = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
+	gtk_alignment_set_padding (GTK_ALIGNMENT (widget), 0, 0, 12, 0);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_vbox_new (FALSE, 6);
+	gtk_container_add (GTK_CONTAINER (container), widget);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	/* This must follow the order of ESourceLDAPAuthentication. */
+	widget = gtk_combo_box_text_new ();
+	gtk_combo_box_text_append_text (
+		GTK_COMBO_BOX_TEXT (widget),
+		_("Anonymous"));
+	gtk_combo_box_text_append_text (
+		GTK_COMBO_BOX_TEXT (widget),
+		_("Using email address"));
+	gtk_combo_box_text_append_text (
+		GTK_COMBO_BOX_TEXT (widget),
+		_("Using distinguished name (DN)"));
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Method:"), widget);
+	context->auth_combo = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	gtk_widget_set_tooltip_text (
+		widget, _("This is the method Evolution will use to "
+		"authenticate you.  Note that setting this to \"Using "
+		"email address\" requires anonymous access to your LDAP "
+		"server."));
+
+	widget = gtk_entry_new ();
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Username:"), widget);
+	context->auth_entry = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	g_object_unref (size_group);
+
+	/* Page 2 */
+
+	tab_label = _("Using LDAP");
+	page = gtk_vbox_new (FALSE, 12);
+	gtk_container_set_border_width (GTK_CONTAINER (page), 12);
+	gtk_notebook_append_page (notebook, page, NULL);
+	gtk_notebook_set_tab_label_text (notebook, page, tab_label);
+	gtk_widget_show (page);
+
+	size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+	/* Page 2 : Searching */
+
+	widget = gtk_vbox_new (FALSE, 6);
+	gtk_box_pack_start (GTK_BOX (page), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_label_new (_("Searching"));
+	gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
+	gtk_label_set_attributes (GTK_LABEL (widget), attr_list);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	widget = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
+	gtk_alignment_set_padding (GTK_ALIGNMENT (widget), 0, 0, 12, 0);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_vbox_new (FALSE, 6);
+	gtk_container_add (GTK_CONTAINER (container), widget);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_combo_box_new_with_entry ();
+	gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (widget), 0);
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Search Base:"), widget);
+	context->search_base_combo = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	widget = gtk_button_new_with_label (
+		_("Find Possible Search Bases"));
+	gtk_button_set_image (
+		GTK_BUTTON (widget), gtk_image_new_from_stock (
+		GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON));
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, NULL, widget);
+	context->search_base_button = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	/* Only sensitive when we have complete
+	 * server and authentication details. */
+	g_object_bind_property (
+		config, "complete",
+		context->search_base_button, "sensitive",
+		G_BINDING_DEFAULT);
+
+	g_signal_connect_data (
+		widget, "clicked",
+		G_CALLBACK (book_config_ldap_search_base_button_clicked_cb),
+		book_config_ldap_closure_new (backend, scratch_source),
+		(GClosureNotify) book_config_ldap_closure_free, 0);
+
+	/* This must follow the order of ESourceLDAPScope. */
+	widget = gtk_combo_box_text_new ();
+	gtk_combo_box_text_append_text (
+		GTK_COMBO_BOX_TEXT (widget), _("One Level"));
+	gtk_combo_box_text_append_text (
+		GTK_COMBO_BOX_TEXT (widget), _("Subtree"));
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Search Scope:"), widget);
+	context->search_scope_combo = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	gtk_widget_set_tooltip_text (
+		widget, _("The search scope defines how deep you would "
+		"like the search to extend down the directory tree.  A "
+		"search scope of \"Subtree\" will include all entries "
+		"below your search base.  A search scope of \"One Level\" "
+		"will only include the entries one level beneath your "
+		"search base."));
+
+	widget = gtk_entry_new ();
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Search Filter:"), widget);
+	context->search_filter_entry = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	/* Page 2 : Downloading */
+
+	widget = gtk_vbox_new (FALSE, 6);
+	gtk_box_pack_start (GTK_BOX (page), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_label_new (_("Downloading"));
+	gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
+	gtk_label_set_attributes (GTK_LABEL (widget), attr_list);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	widget = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
+	gtk_alignment_set_padding (GTK_ALIGNMENT (widget), 0, 0, 12, 0);
+	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_vbox_new (FALSE, 6);
+	gtk_container_add (GTK_CONTAINER (container), widget);
+	gtk_widget_show (widget);
+
+	container = widget;
+
+	widget = gtk_hbox_new (FALSE, 6);
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, _("Limit:"), widget);
+	gtk_widget_show (widget);
+
+	hbox = widget;
+
+	widget = gtk_spin_button_new_with_range (0, G_MAXUINT, 1);
+	gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (widget), TRUE);
+	gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
+	context->limit_spinbutton = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	widget = gtk_label_new (_("contacts"));
+	gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
+	gtk_widget_show (widget);
+
+	widget = gtk_check_button_new_with_label (
+		_("Browse until limit is reached"));
+	book_config_ldap_insert_notebook_widget (
+		container, size_group, NULL, widget);
+	context->can_browse_toggle = g_object_ref (widget);
+	gtk_widget_show (widget);
+
+	g_object_unref (size_group);
+
+	pango_attr_list_unref (attr_list);
+
+	/* Bind widgets to extension properties. */
+
+	extension_name = E_SOURCE_EXTENSION_AUTHENTICATION;
+	extension = e_source_get_extension (scratch_source, extension_name);
+
+	g_object_bind_property (
+		extension, "host",
+		context->host_entry, "text",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	g_object_bind_property_full (
+		extension, "port",
+		context->port_combo, "active",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE,
+		book_config_ldap_port_to_active,
+		book_config_ldap_active_to_port,
+		NULL, (GDestroyNotify) NULL);
+
+	g_object_bind_property (
+		extension, "user",
+		context->auth_entry, "text",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	extension_name = E_SOURCE_EXTENSION_LDAP_BACKEND;
+	extension = e_source_get_extension (scratch_source, extension_name);
+
+	g_object_bind_property (
+		extension, "authentication",
+		context->auth_combo, "active",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	g_object_bind_property (
+		extension, "can-browse",
+		context->can_browse_toggle, "active",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	g_object_bind_property (
+		extension, "limit",
+		context->limit_spinbutton, "value",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	widget = gtk_bin_get_child (GTK_BIN (context->search_base_combo));
+
+	g_object_bind_property (
+		extension, "root-dn",
+		widget, "text",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	g_object_bind_property (
+		extension, "scope",
+		context->search_scope_combo, "active",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	g_object_bind_property (
+		extension, "filter",
+		context->search_filter_entry, "text",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	g_object_bind_property (
+		extension, "security",
+		context->security_combo, "active",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+}
+
+static gboolean
+book_config_ldap_check_complete (ESourceConfigBackend *backend,
+                                 ESource *scratch_source)
+{
+	ESourceLDAPAuthentication auth;
+	ESourceExtension *extension;
+	const gchar *extension_name;
+	const gchar *host;
+	const gchar *user;
+	guint16 port;
+
+	extension_name = E_SOURCE_EXTENSION_LDAP_BACKEND;
+	extension = e_source_get_extension (scratch_source, extension_name);
+
+	auth = e_source_ldap_get_authentication (E_SOURCE_LDAP (extension));
+
+	extension_name = E_SOURCE_EXTENSION_AUTHENTICATION;
+	extension = e_source_get_extension (scratch_source, extension_name);
+
+	host = e_source_authentication_get_host (
+		E_SOURCE_AUTHENTICATION (extension));
+	port = e_source_authentication_get_port (
+		E_SOURCE_AUTHENTICATION (extension));
+	user = e_source_authentication_get_user (
+		E_SOURCE_AUTHENTICATION (extension));
+
+	if (host == NULL || *host == '\0' || port == 0)
+		return FALSE;
+
+	if (auth != E_SOURCE_LDAP_AUTHENTICATION_NONE)
+		if (user == NULL || *user == '\0')
+			return FALSE;
+
+	return TRUE;
+}
+
+static void
+e_book_config_ldap_class_init (ESourceConfigBackendClass *class)
+{
+	EExtensionClass *extension_class;
+
+	extension_class = E_EXTENSION_CLASS (class);
+	extension_class->extensible_type = E_TYPE_BOOK_SOURCE_CONFIG;
+
+	class->parent_uid = "ldap-stub";
+	class->backend_name = "ldap";
+	class->insert_widgets = book_config_ldap_insert_widgets;
+	class->check_complete = book_config_ldap_check_complete;
+}
+
+static void
+e_book_config_ldap_class_finalize (ESourceConfigBackendClass *class)
+{
+}
+
+static void
+e_book_config_ldap_init (ESourceConfigBackend *backend)
+{
+}
+
+G_MODULE_EXPORT void
+e_module_load (GTypeModule *type_module)
+{
+	e_source_ldap_type_register (type_module);
+	e_book_config_ldap_register_type (type_module);
+}
+
+G_MODULE_EXPORT void
+e_module_unload (GTypeModule *type_module)
+{
+}