Merge pull request #719 from mfournier/openldap-improvements-rebased

Openldap plugin

diff --git a/README b/README
index 7aa83b0..76d2e4f 100644 (file)
--- a/README
+++ b/README
@@ -229,6 +229,9 @@ Features
       Read onewire sensors using the owcapu library of the owfs project.
       Please read in collectd.conf(5) why this plugin is experimental.
 
+    - openldap
+      Read monitoring information from OpenLDAP's cn=Monitor subtree.
+
     - openvpn
       RX and TX of each client in openvpn-status.log (status-version 2).
       <http://openvpn.net/index.php/documentation/howto.html>
@@ -654,6 +657,10 @@ Prerequisites
     libjvm” below.
     <http://openjdk.java.net/> (and others)
 
+  * libldap (optional)
+    Used by the `openldap' plugin.
+    <http://www.openldap.org/>
+
   * liblvm2 (optional)
     Used by the `lvm' plugin.
     <ftp://sources.redhat.com/pub/lvm2/>

diff --git a/configure.ac b/configure.ac
index 13577c9..6ac2554 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -2247,6 +2247,64 @@ AC_SUBST(JAVA_LIBS)
 AM_CONDITIONAL(BUILD_WITH_JAVA, test "x$with_java" = "xyes")
 # }}}
 
+# --with-libldap {{{
+AC_ARG_WITH(libldap, [AS_HELP_STRING([--with-libldap@<:@=PREFIX@:>@], [Path to libldap.])],
+[
+ if test "x$withval" = "xyes"
+ then
+        with_libldap="yes"
+ else if test "x$withval" = "xno"
+ then
+        with_libldap="no"
+ else
+        with_libldap="yes"
+        LIBLDAP_CPPFLAGS="$LIBLDAP_CPPFLAGS -I$withval/include"
+        LIBLDAP_LDFLAGS="$LIBLDAP_LDFLAGS -L$withval/lib"
+ fi; fi
+],
+[with_libldap="yes"])
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+
+CPPFLAGS="$CPPFLAGS $LIBLDAP_CPPFLAGS"
+LDFLAGS="$LDFLAGS $LIBLDAP_LDFLAGS"
+
+if test "x$with_libldap" = "xyes"
+then
+       if test "x$LIBLDAP_CPPFLAGS" != "x"
+       then
+               AC_MSG_NOTICE([libldap CPPFLAGS: $LIBLDAP_CPPFLAGS])
+       fi
+       AC_CHECK_HEADERS(ldap.h,
+       [with_libldap="yes"],
+       [with_libldap="no ('ldap.h' not found)"])
+fi
+if test "x$with_libldap" = "xyes"
+then
+       if test "x$LIBLDAP_LDFLAGS" != "x"
+       then
+               AC_MSG_NOTICE([libldap LDFLAGS: $LIBLDAP_LDFLAGS])
+       fi
+       AC_CHECK_LIB(ldap, ldap_initialize,
+       [with_libldap="yes"],
+       [with_libldap="no (symbol 'ldap_initialize' not found)"])
+
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
+
+if test "x$with_libldap" = "xyes"
+then
+       BUILD_WITH_LIBLDAP_CPPFLAGS="$LIBLDAP_CPPFLAGS"
+       BUILD_WITH_LIBLDAP_LDFLAGS="$LIBLDAP_LDFLAGS"
+       AC_SUBST(BUILD_WITH_LIBLDAP_CPPFLAGS)
+       AC_SUBST(BUILD_WITH_LIBLDAP_LDFLAGS)
+fi
+AM_CONDITIONAL(BUILD_WITH_LIBLDAP, test "x$with_libldap" = "xyes")
+# }}}
+
 # --with-liblvm2app {{{
 with_liblvm2app_cppflags=""
 with_liblvm2app_ldflags=""
@@ -5515,6 +5573,7 @@ AC_PLUGIN([numa],        [$plugin_numa],       [NUMA virtual memory statistics])
 AC_PLUGIN([nut],         [$with_libupsclient], [Network UPS tools statistics])
 AC_PLUGIN([olsrd],       [yes],                [olsrd statistics])
 AC_PLUGIN([onewire],     [$with_libowcapi],    [OneWire sensor statistics])
+AC_PLUGIN([openldap],    [$with_libldap],      [OpenLDAP statistics])
 AC_PLUGIN([openvpn],     [yes],                [OpenVPN client statistics])
 AC_PLUGIN([oracle],      [$with_oracle],       [Oracle plugin])
 AC_PLUGIN([perl],        [$plugin_perl],       [Embed a Perl interpreter])
@@ -5768,6 +5827,7 @@ Configuration:
     libjvm  . . . . . . . $with_java
     libkstat  . . . . . . $with_kstat
     libkvm  . . . . . . . $with_libkvm
+    libldap . . . . . . . $with_libldap
     liblvm2app  . . . . . $with_liblvm2app
     libmemcached  . . . . $with_libmemcached
     libmnl  . . . . . . . $with_libmnl
@@ -5882,6 +5942,7 @@ Configuration:
     nut . . . . . . . . . $enable_nut
     olsrd . . . . . . . . $enable_olsrd
     onewire . . . . . . . $enable_onewire
+    openldap  . . . . . . $enable_openldap
     openvpn . . . . . . . $enable_openvpn
     oracle  . . . . . . . $enable_oracle
     perl  . . . . . . . . $enable_perl

diff --git a/src/Makefile.am b/src/Makefile.am
index 74c5007..04c77a3 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -728,6 +728,14 @@ onewire_la_LIBADD = $(BUILD_WITH_LIBOWCAPI_LIBS)
 onewire_la_LDFLAGS = $(PLUGIN_LDFLAGS)
 endif
 
+if BUILD_PLUGIN_OPENLDAP
+pkglib_LTLIBRARIES += openldap.la
+openldap_la_SOURCES = openldap.c
+openldap_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBLDAP_LDFLAGS)
+openldap_la_CFLAGS = $(AM_CFLAGS) $(BUILD_WITH_LIBLDAP_CPPFLAGS)
+openldap_la_LIBADD = -lldap
+endif
+
 if BUILD_PLUGIN_OPENVPN
 pkglib_LTLIBRARIES += openvpn.la
 openvpn_la_SOURCES = openvpn.c

diff --git a/src/collectd.conf.in b/src/collectd.conf.in
index 8e7f3fc..84410e0 100644 (file)
--- a/src/collectd.conf.in
+++ b/src/collectd.conf.in
@@ -150,6 +150,7 @@
 #@BUILD_PLUGIN_NUT_TRUE@LoadPlugin nut
 #@BUILD_PLUGIN_OLSRD_TRUE@LoadPlugin olsrd
 #@BUILD_PLUGIN_ONEWIRE_TRUE@LoadPlugin onewire
+#@BUILD_PLUGIN_OPENLDAP_TRUE@LoadPlugin openldap
 #@BUILD_PLUGIN_OPENVPN_TRUE@LoadPlugin openvpn
 #@BUILD_PLUGIN_ORACLE_TRUE@LoadPlugin oracle
 #@BUILD_PLUGIN_PERL_TRUE@<LoadPlugin perl>
@@ -768,6 +769,17 @@
 #      IgnoreSelected false
 #</Plugin>
 
+#<Plugin openldap>
+#  <Instance "localhost">
+#    URL "ldap://localhost:389"
+#    StartTLS false
+#    VerifyHost true
+#    CACert "/path/to/ca.crt"
+#    Timeout -1
+#    Version 3
+#  </Instance>
+#</Plugin>
+
 #<Plugin openvpn>
 #      StatusFile "/etc/openvpn/openvpn-status.log"
 #      ImprovedNamingSchema false

diff --git a/src/collectd.conf.pod b/src/collectd.conf.pod
index 7da36b8..69c922b 100644 (file)
--- a/src/collectd.conf.pod
+++ b/src/collectd.conf.pod
@@ -4245,6 +4245,70 @@ short: If it works for you: Great! But keep in mind that the config I<might>
 change, though this is unlikely. Oh, and if you want to help improving this
 plugin, just send a short notice to the mailing list. ThanksE<nbsp>:)
 
+=head2 Plugin C<openldap>
+
+To use the C<openldap> plugin you first need to configure the I<OpenLDAP>
+server correctly. The backend database C<monitor> needs to be loaded and
+working. See slapd-monitor(5) for the details.
+
+The configuration of the C<openldap> plugin consists of one or more B<Instance>
+blocks. Each block requires one string argument as the instance name. For
+example:
+
+ <Plugin "openldap">
+   <Instance "foo">
+     URL "ldap://localhost/"
+   </Instance>
+   <Instance "bar">
+     URL "ldaps://localhost/"
+   </Instance>
+ </Plugin>
+
+The instance name will be used as the I<plugin instance>. To emulate the old
+(versionE<nbsp>4) behavior, you can use an empty string (""). In order for the
+plugin to work correctly, each instance name must be unique. This is not
+enforced by the plugin and it is your responsibility to ensure it is.
+
+The following options are accepted within each B<Instance> block:
+
+=over 4
+
+=item B<URL> I<ldap://host/binddn>
+
+Sets the URL to use to connect to the I<OpenLDAP> server. This option is
+I<mandatory>.
+
+=item B<StartTLS> B<true|false>
+
+Defines whether TLS must be used when connecting to the I<OpenLDAP> server.
+Disabled by default.
+
+=item B<VerifyHost> B<true|false>
+
+Enables or disables peer host name verification. If enabled, the plugin checks
+if the C<Common Name> or a C<Subject Alternate Name> field of the SSL
+certificate matches the host name provided by the B<URL> option. If this
+identity check fails, the connection is aborted. Enabled by default.
+
+=item B<CACert> I<File>
+
+File that holds one or more SSL certificates. If you want to use TLS/SSL you
+may possibly need this option. What CA certificates are checked by default
+depends on the distribution you use and can be changed with the usual ldap
+client configuration mechanisms. See ldap.conf(5) for the details.
+
+=item B<Timeout> I<Seconds>
+
+Sets the timeout value for ldap operations. Defaults to B<-1> which results in
+an infinite timeout.
+
+=item B<Version> I<Version>
+
+An integer which sets the LDAP protocol version number to use when connecting
+to the I<OpenLDAP> server. Defaults to B<3> for using I<LDAPv3>.
+
+=back
+
 =head2 Plugin C<openvpn>
 
 The OpenVPN plugin reads a status file maintained by OpenVPN and gathers

diff --git a/src/openldap.c b/src/openldap.c
new file mode 100644 (file)
index 0000000..212310b
--- /dev/null
+++ b/src/openldap.c
@@ -0,0 +1,682 @@
+/**
+ * collectd - src/openldap.c
+ * Copyright (C) 2011       Kimo Rosenbaum
+ * Copyright (C) 2014       Marc Fournier
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *   Kimo Rosenbaum <kimor79 at yahoo.com>
+ *   Marc Fournier <marc.fournier at camptocamp.com>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "configfile.h"
+
+#include <lber.h>
+#include <ldap.h>
+
+struct ldap_s /* {{{ */
+{
+       char *name;
+
+       char *cacert;
+       char *host;
+       int   state;
+       _Bool starttls;
+       int   timeout;
+       char *url;
+       _Bool verifyhost;
+       int   version;
+
+       LDAP *ld;
+};
+typedef struct ldap_s ldap_t; /* }}} */
+
+static void ldap_free (ldap_t *st) /* {{{ */
+{
+       if (st == NULL)
+               return;
+
+       sfree (st->cacert);
+       sfree (st->host);
+       sfree (st->name);
+       sfree (st->url);
+       if (st->ld)
+               ldap_memfree (st->ld);
+       sfree (st);
+} /* }}} void ldap_free */
+
+/* initialize ldap for each host */
+static int ldap_init_host (ldap_t *st) /* {{{ */
+{
+       LDAP *ld;
+       int rc;
+       rc = ldap_initialize (&ld, st->url);
+       if (rc != LDAP_SUCCESS)
+       {
+               ERROR ("openldap plugin: ldap_initialize failed: %s",
+                       ldap_err2string (rc));
+               st->state = 0;
+               ldap_unbind_ext_s (ld, NULL, NULL);
+               return (-1);
+       }
+
+       st->ld = ld;
+
+       ldap_set_option (st->ld, LDAP_OPT_PROTOCOL_VERSION, &st->version);
+
+       ldap_set_option (st->ld, LDAP_OPT_TIMEOUT,
+               &(const struct timeval){st->timeout, 0});
+
+       if (st->cacert != NULL)
+               ldap_set_option (st->ld, LDAP_OPT_X_TLS_CACERTFILE, st->cacert);
+
+       if (st->verifyhost == 0)
+       {
+               int never = LDAP_OPT_X_TLS_NEVER;
+               ldap_set_option (st->ld, LDAP_OPT_X_TLS_REQUIRE_CERT, &never);
+       }
+
+       if (st->starttls != 0)
+       {
+               rc = ldap_start_tls_s (ld, NULL, NULL);
+               if (rc != LDAP_SUCCESS)
+               {
+                       ERROR ("openldap plugin: Failed to start tls on %s: %s",
+                                       st->url, ldap_err2string (rc));
+                       st->state = 0;
+                       ldap_unbind_ext_s (st->ld, NULL, NULL);
+                       return (-1);
+               }
+       }
+
+       struct berval cred;
+       cred.bv_val = "";
+       cred.bv_len = 0;
+
+       rc = ldap_sasl_bind_s (st->ld, NULL, NULL, &cred, NULL, NULL, NULL);
+       if (rc != LDAP_SUCCESS)
+       {
+               ERROR ("openldap plugin: Failed to bind to %s: %s",
+                               st->url, ldap_err2string (rc));
+               st->state = 0;
+               ldap_unbind_ext_s (st->ld, NULL, NULL);
+               return (-1);
+       }
+       else
+       {
+               DEBUG ("openldap plugin: Successfully connected to %s",
+                               st->url);
+               st->state = 1;
+               return (0);
+       }
+} /* }}} static ldap_init_host */
+
+static void ldap_submit_value (const char *type, const char *type_instance, /* {{{ */
+               value_t value, ldap_t *st)
+{
+       value_list_t vl = VALUE_LIST_INIT;
+
+       vl.values     = &value;
+       vl.values_len = 1;
+
+       if ((st->host == NULL)
+                       || (strcmp ("", st->host) == 0)
+                       || (strcmp ("localhost", st->host) == 0))
+       {
+               sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+       }
+       else
+       {
+               sstrncpy (vl.host, st->host, sizeof (vl.host));
+       }
+
+       sstrncpy (vl.plugin, "openldap", sizeof (vl.plugin));
+       if (st->name != NULL)
+               sstrncpy (vl.plugin_instance, st->name,
+                               sizeof (vl.plugin_instance));
+
+       sstrncpy (vl.type, type, sizeof (vl.type));
+       if (type_instance != NULL)
+               sstrncpy (vl.type_instance, type_instance,
+                               sizeof (vl.type_instance));
+
+       plugin_dispatch_values (&vl);
+} /* }}} void ldap_submit_value */
+
+static void ldap_submit_derive (const char *type, const char *type_instance, /* {{{ */
+               derive_t d, ldap_t *st)
+{
+       value_t v;
+       v.derive = d;
+       ldap_submit_value (type, type_instance, v, st);
+} /* }}} void ldap_submit_derive */
+
+static void ldap_submit_gauge (const char *type, const char *type_instance, /* {{{ */
+               gauge_t g, ldap_t *st)
+{
+       value_t v;
+       v.gauge = g;
+       ldap_submit_value (type, type_instance, v, st);
+} /* }}} void ldap_submit_gauge */
+
+static int ldap_read_host (user_data_t *ud) /* {{{ */
+{
+       ldap_t *st;
+       LDAPMessage *e, *result;
+       char *dn;
+       int rc;
+       int status;
+
+       char *attrs[9] = { "monitorCounter",
+                               "monitorOpCompleted",
+                               "monitorOpInitiated",
+                               "monitoredInfo",
+                               "olmBDBEntryCache",
+                               "olmBDBDNCache",
+                               "olmBDBIDLCache",
+                               "namingContexts",
+                               NULL };
+
+       if ((ud == NULL) || (ud->data == NULL))
+       {
+               ERROR ("openldap plugin: ldap_read_host: Invalid user data.");
+               return (-1);
+       }
+
+       st = (ldap_t *) ud->data;
+
+       status = ldap_init_host (st);
+       if (status != 0)
+               return (-1);
+
+       rc = ldap_search_ext_s (st->ld, "cn=Monitor", LDAP_SCOPE_SUBTREE,
+               "(|(!(cn=* *))(cn=Database*))", attrs, 0,
+               NULL, NULL, NULL, 0, &result);
+
+       if (rc != LDAP_SUCCESS)
+       {
+               ERROR ("openldap plugin: Failed to execute search: %s",
+                               ldap_err2string (rc));
+               ldap_msgfree (result);
+               ldap_unbind_ext_s (st->ld, NULL, NULL);
+               return (-1);
+       }
+
+       for (e = ldap_first_entry (st->ld, result); e != NULL;
+               e = ldap_next_entry (st->ld, e))
+       {
+               if ((dn = ldap_get_dn (st->ld, e)) != NULL)
+               {
+                       unsigned long long counter = 0;
+                       unsigned long long opc = 0;
+                       unsigned long long opi = 0;
+                       unsigned long long info = 0;
+
+                       struct berval counter_data;
+                       struct berval opc_data;
+                       struct berval opi_data;
+                       struct berval info_data;
+                       struct berval olmbdb_data;
+                       struct berval nc_data;
+
+                       struct berval **counter_list;
+                       struct berval **opc_list;
+                       struct berval **opi_list;
+                       struct berval **info_list;
+                       struct berval **olmbdb_list;
+                       struct berval **nc_list;
+
+                       if ((counter_list = ldap_get_values_len (st->ld, e,
+                               "monitorCounter")) != NULL)
+                       {
+                               counter_data = *counter_list[0];
+                               counter = atoll (counter_data.bv_val);
+                       }
+
+                       if ((opc_list = ldap_get_values_len (st->ld, e,
+                               "monitorOpCompleted")) != NULL)
+                       {
+                               opc_data = *opc_list[0];
+                               opc = atoll (opc_data.bv_val);
+                       }
+
+                       if ((opi_list = ldap_get_values_len (st->ld, e,
+                               "monitorOpInitiated")) != NULL)
+                       {
+                               opi_data = *opi_list[0];
+                               opi = atoll (opi_data.bv_val);
+                       }
+
+                       if ((info_list = ldap_get_values_len (st->ld, e,
+                               "monitoredInfo")) != NULL)
+                       {
+                               info_data = *info_list[0];
+                               info = atoll (info_data.bv_val);
+                       }
+
+                       if (strcmp (dn, "cn=Total,cn=Connections,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("total_connections", NULL,
+                                       counter, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Current,cn=Connections,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_gauge ("current_connections", NULL,
+                                       counter, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Operations,cn=Monitor") == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Bind,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "bind-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "bind-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=UnBind,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "unbind-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "unbind-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Search,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "search-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "search-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Compare,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "compare-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "compare-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Modify,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "modify-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "modify-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Modrdn,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "modrdn-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "modrdn-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Add,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "add-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "add-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Delete,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "delete-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "delete-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Abandon,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "abandon-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "abandon-initiated", opi, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Extended,cn=Operations,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("operations",
+                                       "extended-completed", opc, st);
+                               ldap_submit_derive ("operations",
+                                       "extended-initiated", opi, st);
+                       }
+                       else if ((strncmp (dn, "cn=Database", 11) == 0)
+                               && ((nc_list = ldap_get_values_len
+                                               (st->ld, e, "namingContexts")) != NULL))
+                       {
+                               nc_data = *nc_list[0];
+                               char typeinst[DATA_MAX_NAME_LEN];
+
+                               if ((olmbdb_list = ldap_get_values_len (st->ld, e,
+                                       "olmBDBEntryCache")) != NULL)
+                               {
+                                       olmbdb_data = *olmbdb_list[0];
+                                       ssnprintf (typeinst, sizeof (typeinst),
+                                               "bdbentrycache-%s", nc_data.bv_val);
+                                       ldap_submit_gauge ("cache_size", typeinst,
+                                               atoll (olmbdb_data.bv_val), st);
+                                       ldap_value_free_len (olmbdb_list);
+                               }
+
+                               if ((olmbdb_list = ldap_get_values_len (st->ld, e,
+                                       "olmBDBDNCache")) != NULL)
+                               {
+                                       olmbdb_data = *olmbdb_list[0];
+                                       ssnprintf (typeinst, sizeof (typeinst),
+                                               "bdbdncache-%s", nc_data.bv_val);
+                                       ldap_submit_gauge ("cache_size", typeinst,
+                                               atoll (olmbdb_data.bv_val), st);
+                                       ldap_value_free_len (olmbdb_list);
+                               }
+
+                               if ((olmbdb_list = ldap_get_values_len (st->ld, e,
+                                       "olmBDBIDLCache")) != NULL)
+                               {
+                                       olmbdb_data = *olmbdb_list[0];
+                                       ssnprintf (typeinst, sizeof (typeinst),
+                                               "bdbidlcache-%s", nc_data.bv_val);
+                                       ldap_submit_gauge ("cache_size", typeinst,
+                                               atoll (olmbdb_data.bv_val), st);
+                                       ldap_value_free_len (olmbdb_list);
+                               }
+
+                               ldap_value_free_len (nc_list);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Bytes,cn=Statistics,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("derive", "statistics-bytes",
+                                       counter, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=PDU,cn=Statistics,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("derive", "statistics-pdu",
+                                       counter, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Entries,cn=Statistics,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("derive", "statistics-entries",
+                                       counter, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Referrals,cn=Statistics,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("derive", "statistics-referrals",
+                                       counter, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Open,cn=Threads,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_gauge ("threads", "threads-open",
+                                       info, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Starting,cn=Threads,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_gauge ("threads", "threads-starting",
+                                       info, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Active,cn=Threads,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_gauge ("threads", "threads-active",
+                                       info, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Pending,cn=Threads,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_gauge ("threads", "threads-pending",
+                                       info, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Backload,cn=Threads,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_gauge ("threads", "threads-backload",
+                                       info, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Read,cn=Waiters,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("derive", "waiters-read",
+                                       counter, st);
+                       }
+                       else if (strcmp (dn,
+                                       "cn=Write,cn=Waiters,cn=Monitor")
+                                       == 0)
+                       {
+                               ldap_submit_derive ("derive", "waiters-write",
+                                       counter, st);
+                       }
+
+                       ldap_value_free_len (counter_list);
+                       ldap_value_free_len (opc_list);
+                       ldap_value_free_len (opi_list);
+                       ldap_value_free_len (info_list);
+               }
+
+               ldap_memfree (dn);
+       }
+
+       ldap_msgfree (result);
+       ldap_unbind_ext_s (st->ld, NULL, NULL);
+       return (0);
+} /* }}} int ldap_read_host */
+
+/* Configuration handling functions {{{
+ *
+ * <Plugin ldap>
+ *   <Instance "plugin_instance1">
+ *     URL "ldap://localhost"
+ *     ...
+ *   </Instance>
+ * </Plugin>
+ */
+
+static int ldap_config_add (oconfig_item_t *ci) /* {{{ */
+{
+       ldap_t *st;
+       int i;
+       int status;
+
+       st = malloc (sizeof (*st));
+       if (st == NULL)
+       {
+               ERROR ("openldap plugin: malloc failed.");
+               return (-1);
+       }
+       memset (st, 0, sizeof (*st));
+
+       status = cf_util_get_string (ci, &st->name);
+       if (status != 0)
+       {
+               sfree (st);
+               return (status);
+       }
+
+       st->starttls = 0;
+       st->timeout = -1;
+       st->verifyhost = 1;
+       st->version = LDAP_VERSION3;
+
+       for (i = 0; i < ci->children_num; i++)
+       {
+               oconfig_item_t *child = ci->children + i;
+
+               if (strcasecmp ("CACert", child->key) == 0)
+                       status = cf_util_get_string (child, &st->cacert);
+               else if (strcasecmp ("StartTLS", child->key) == 0)
+                       status = cf_util_get_boolean (child, &st->starttls);
+               else if (strcasecmp ("Timeout", child->key) == 0)
+                       status = cf_util_get_int (child, &st->timeout);
+               else if (strcasecmp ("URL", child->key) == 0)
+                       status = cf_util_get_string (child, &st->url);
+               else if (strcasecmp ("VerifyHost", child->key) == 0)
+                       status = cf_util_get_boolean (child, &st->verifyhost);
+               else if (strcasecmp ("Version", child->key) == 0)
+                       status = cf_util_get_int (child, &st->version);
+               else
+               {
+                       WARNING ("openldap plugin: Option `%s' not allowed here.",
+                                       child->key);
+                       status = -1;
+               }
+
+               if (status != 0)
+                       break;
+       }
+
+       /* Check if struct is complete.. */
+       if ((status == 0) && (st->url == NULL))
+       {
+               ERROR ("openldap plugin: Instance `%s': "
+                               "No URL has been configured.",
+                               st->name);
+               status = -1;
+       }
+
+       /* Check if URL is valid */
+       if ((status == 0) && (st->url != NULL))
+       {
+               LDAPURLDesc *ludpp;
+               int rc;
+
+               if ((rc = ldap_url_parse (st->url, &ludpp)) != 0)
+               {
+                       ERROR ("openldap plugin: Instance `%s': "
+                               "Invalid URL: `%s'",
+                               st->name, st->url);
+                       status = -1;
+               }
+               else
+               {
+                       st->host = strdup (ludpp->lud_host);
+               }
+
+               ldap_free_urldesc (ludpp);
+       }
+
+       if (status == 0)
+       {
+               user_data_t ud;
+               char callback_name[3*DATA_MAX_NAME_LEN];
+
+               memset (&ud, 0, sizeof (ud));
+               ud.data = st;
+
+               memset (callback_name, 0, sizeof (callback_name));
+               ssnprintf (callback_name, sizeof (callback_name),
+                               "openldap/%s/%s",
+                               (st->host != NULL) ? st->host : hostname_g,
+                               (st->name != NULL) ? st->name : "default"),
+
+               status = plugin_register_complex_read (/* group = */ NULL,
+                               /* name      = */ callback_name,
+                               /* callback  = */ ldap_read_host,
+                               /* interval  = */ NULL,
+                               /* user_data = */ &ud);
+       }
+
+       if (status != 0)
+       {
+               ldap_free (st);
+               return (-1);
+       }
+
+       return (0);
+} /* }}} int ldap_config_add */
+
+static int ldap_config (oconfig_item_t *ci) /* {{{ */
+{
+       int i;
+       int status = 0;
+
+       for (i = 0; i < ci->children_num; i++)
+       {
+               oconfig_item_t *child = ci->children + i;
+
+               if (strcasecmp ("Instance", child->key) == 0)
+                       ldap_config_add (child);
+               else
+                       WARNING ("openldap plugin: The configuration option "
+                                       "\"%s\" is not allowed here. Did you "
+                                       "forget to add an <Instance /> block "
+                                       "around the configuration?",
+                                       child->key);
+       } /* for (ci->children) */
+
+       return (status);
+} /* }}} int ldap_config */
+
+/* }}} End of configuration handling functions */
+
+static int ldap_init (void) /* {{{ */
+{
+       /* Initialize LDAP library while still single-threaded as recommended in
+        * ldap_initialize(3) */
+       int debug_level;
+       ldap_get_option (NULL, LDAP_OPT_DEBUG_LEVEL, &debug_level);
+       return (0);
+} /* }}} int ldap_init */
+
+void module_register (void) /* {{{ */
+{
+       plugin_register_complex_config ("openldap", ldap_config);
+       plugin_register_init ("openldap", ldap_init);
+} /* }}} void module_register */