Merge branch 'collectd-4.6'
authorFlorian Forster <octo@leeloo.lan.home.verplant.org>
Sat, 11 Apr 2009 07:37:30 +0000 (09:37 +0200)
committerFlorian Forster <octo@leeloo.lan.home.verplant.org>
Sat, 11 Apr 2009 07:37:30 +0000 (09:37 +0200)
76 files changed:
README
bindings/java/org/collectd/api/Collectd.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdConfigInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdFlushInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdInitInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdLogInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdMatchFactoryInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdMatchInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdNotificationInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdReadInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdShutdownInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdTargetFactoryInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdTargetInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/CollectdWriteInterface.java [new file with mode: 0644]
bindings/java/org/collectd/api/DataSet.java [new file with mode: 0644]
bindings/java/org/collectd/api/DataSource.java [new file with mode: 0644]
bindings/java/org/collectd/api/Notification.java [new file with mode: 0644]
bindings/java/org/collectd/api/OConfigItem.java [new file with mode: 0644]
bindings/java/org/collectd/api/OConfigValue.java [new file with mode: 0644]
bindings/java/org/collectd/api/PluginData.java [new file with mode: 0644]
bindings/java/org/collectd/api/ValueList.java [new file with mode: 0644]
bindings/java/org/collectd/java/JMXMemory.java [new file with mode: 0644]
clean.sh
configure.in
contrib/collectd-unixsock.py [new file with mode: 0644]
contrib/collection3/etc/collection.conf
src/Makefile.am
src/bind.c
src/collectd-java.pod [new file with mode: 0644]
src/collectd-perl.pod
src/collectd-snmp.pod
src/collectd.conf.in
src/collectd.conf.pod
src/common.c
src/common.h
src/configfile.c
src/csv.c
src/exec.c
src/gmond.c [new file with mode: 0644]
src/java.c [new file with mode: 0644]
src/liboconfig/oconfig.c
src/liboconfig/oconfig.h
src/liboping/AUTHORS [deleted file]
src/liboping/COPYING [deleted file]
src/liboping/ChangeLog [deleted file]
src/liboping/Makefile.am [deleted file]
src/liboping/README [deleted file]
src/liboping/liboping.c [deleted file]
src/liboping/oping.h [deleted file]
src/logfile.c
src/memcachec.c [new file with mode: 0644]
src/mysql.c
src/network.c
src/network.h
src/notify_desktop.c
src/notify_email.c
src/onewire.c
src/perl.c
src/ping.c
src/plugin.c
src/plugin.h
src/powerdns.c
src/protocols.c [new file with mode: 0644]
src/rrdcached.c
src/rrdtool.c
src/snmp.c
src/syslog.c
src/table.c [new file with mode: 0644]
src/ted.c [new file with mode: 0644]
src/types.db
src/types.db.pod
src/uptime.c [new file with mode: 0644]
src/utils_cmd_putval.c
src/utils_db_query.c
src/utils_heap.c [new file with mode: 0644]
src/utils_heap.h [new file with mode: 0644]

diff --git a/README b/README
index b641741..c556c75 100644 (file)
--- a/README
+++ b/README
@@ -76,6 +76,9 @@ Features
     - filecount
       Count the number of files in directories.
 
+    - gmond
+      Receive multicast traffic from Ganglia instances.
+
     - hddtemp
       Harddisk temperatures using hddtempd.
 
@@ -179,6 +182,9 @@ Features
     - processes
       Process counts: Number of running, sleeping, zombie, ... processes.
 
+    - protocols
+      Counts various aspects of network protocols such as IP, TCP, UDP, etc.
+
     - rrdcached
       RRDtool caching daemon (RRDcacheD) statistics.
 
@@ -210,6 +216,9 @@ Features
     - teamspeak2
       TeamSpeak2 server statistics.
 
+    - ted
+      Plugin to read values from `The Energy Detective' (TED).
+
     - thermal
       Linux ACPI thermal zone information.
 
diff --git a/bindings/java/org/collectd/api/Collectd.java b/bindings/java/org/collectd/api/Collectd.java
new file mode 100644 (file)
index 0000000..84e6592
--- /dev/null
@@ -0,0 +1,295 @@
+/*
+ * collectd/java - org/collectd/api/Collectd.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Java API to internal functions of collectd.
+ *
+ * All functions in this class are {@code static}. You don't need to create an
+ * object of this class (in fact, you can't). Just call these functions
+ * directly.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ */
+public class Collectd
+{
+
+  /**
+   * Constant for severity (log level) "error".
+   *
+   * @see CollectdLogInterface
+   */
+  public static final int LOG_ERR     = 3;
+
+  /**
+   * Constant for severity (log level) "warning".
+   *
+   * @see CollectdLogInterface
+   */
+  public static final int LOG_WARNING = 4;
+
+  /**
+   * Constant for severity (log level) "notice".
+   *
+   * @see CollectdLogInterface
+   */
+  public static final int LOG_NOTICE  = 5;
+
+  /**
+   * Constant for severity (log level) "info".
+   *
+   * @see CollectdLogInterface
+   */
+  public static final int LOG_INFO    = 6;
+
+  /**
+   * Constant for severity (log level) "debug".
+   *
+   * @see CollectdLogInterface
+   */
+  public static final int LOG_DEBUG   = 7;
+
+  /**
+   * Return value of match methods: No match.
+   *
+   * This is one of two valid return values from match callbacks, indicating
+   * that the passed {@link DataSet} and {@link ValueList} did not match.
+   *
+   * Do not use the numeric value directly, it is subject to change without
+   * notice!
+   *
+   * @see CollectdMatchInterface
+   */
+  public static final int FC_MATCH_NO_MATCH  = 0;
+
+  /**
+   * Return value of match methods: Match.
+   *
+   * This is one of two valid return values from match callbacks, indicating
+   * that the passed {@link DataSet} and {@link ValueList} did match.
+   *
+   * Do not use the numeric value directly, it is subject to change without
+   * notice!
+   *
+   * @see CollectdMatchInterface
+   */
+  public static final int FC_MATCH_MATCHES   = 1;
+
+  /**
+   * Return value of target methods: Continue.
+   *
+   * This is one of three valid return values from target callbacks, indicating
+   * that processing of the {@link ValueList} should continue.
+   *
+   * Do not use the numeric value directly, it is subject to change without
+   * notice!
+   *
+   * @see CollectdTargetInterface
+   */
+  public static final int FC_TARGET_CONTINUE = 0;
+
+  /**
+   * Return value of target methods: Stop.
+   *
+   * This is one of three valid return values from target callbacks, indicating
+   * that processing of the {@link ValueList} should stop immediately.
+   *
+   * Do not use the numeric value directly, it is subject to change without
+   * notice!
+   *
+   * @see CollectdTargetInterface
+   */
+  public static final int FC_TARGET_STOP     = 1;
+
+  /**
+   * Return value of target methods: Return.
+   *
+   * This is one of three valid return values from target callbacks, indicating
+   * that processing of the current chain should be stopped and processing of
+   * the {@link ValueList} should continue in the calling chain.
+   *
+   * Do not use the numeric value directly, it is subject to change without
+   * notice!
+   *
+   * @see CollectdTargetInterface
+   */
+  public static final int FC_TARGET_RETURN   = 2;
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_register_config
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdConfigInterface
+   */
+  native public static int registerConfig (String name,
+      CollectdConfigInterface object);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_register_init
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdInitInterface
+   */
+  native public static int registerInit (String name,
+      CollectdInitInterface object);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_register_read
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdReadInterface
+   */
+  native public static int registerRead (String name,
+      CollectdReadInterface object);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_register_write
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdWriteInterface
+   */
+  native public static int registerWrite (String name,
+      CollectdWriteInterface object);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_register_flush
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdFlushInterface
+   */
+  native public static int registerFlush (String name,
+      CollectdFlushInterface object);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_register_shutdown
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdShutdownInterface
+   */
+  native public static int registerShutdown (String name,
+      CollectdShutdownInterface object);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_register_log
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdLogInterface
+   */
+  native public static int registerLog (String name,
+      CollectdLogInterface object);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_register_notification
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdNotificationInterface
+   */
+  native public static int registerNotification (String name,
+      CollectdNotificationInterface object);
+
+  /**
+   * Java representation of collectd/src/filter_chain.h:fc_register_match
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdMatchFactoryInterface
+   */
+  native public static int registerMatch (String name,
+      CollectdMatchFactoryInterface object);
+
+  /**
+   * Java representation of collectd/src/filter_chain.h:fc_register_target
+   *
+   * @return Zero when successful, non-zero otherwise.
+   * @see CollectdTargetFactoryInterface
+   */
+  native public static int registerTarget (String name,
+      CollectdTargetFactoryInterface object);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_dispatch_values
+   *
+   * @return Zero when successful, non-zero otherwise.
+   */
+  native public static int dispatchValues (ValueList vl);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_dispatch_notification
+   *
+   * @return Zero when successful, non-zero otherwise.
+   */
+  native public static int dispatchNotification (Notification n);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_get_ds
+   *
+   * @return The appropriate {@link DataSet} object or {@code null} if no such
+   * type is registered.
+   */
+  native public static DataSet getDS (String type);
+
+  /**
+   * Java representation of collectd/src/plugin.h:plugin_log
+   */
+  native private static void log (int severity, String message);
+
+  /**
+   * Prints an error message.
+   */
+  public static void logError (String message)
+  {
+    log (LOG_ERR, message);
+  } /* void logError */
+
+  /**
+   * Prints a warning message.
+   */
+  public static void logWarning (String message)
+  {
+    log (LOG_WARNING, message);
+  } /* void logWarning */
+
+  /**
+   * Prints a notice.
+   */
+  public static void logNotice (String message)
+  {
+    log (LOG_NOTICE, message);
+  } /* void logNotice */
+
+  /**
+   * Prints an info message.
+   */
+  public static void logInfo (String message)
+  {
+    log (LOG_INFO, message);
+  } /* void logInfo */
+
+  /**
+   * Prints a debug message.
+   */
+  public static void logDebug (String message)
+  {
+    log (LOG_DEBUG, message);
+  } /* void logDebug */
+} /* class Collectd */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
diff --git a/bindings/java/org/collectd/api/CollectdConfigInterface.java b/bindings/java/org/collectd/api/CollectdConfigInterface.java
new file mode 100644 (file)
index 0000000..060f944
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * collectd/java - org/collectd/api/CollectdConfigInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a config method.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see Collectd#registerConfig(String, CollectdConfigInterface)
+ */
+public interface CollectdConfigInterface
+{
+       public int config (OConfigItem ci);
+}
diff --git a/bindings/java/org/collectd/api/CollectdFlushInterface.java b/bindings/java/org/collectd/api/CollectdFlushInterface.java
new file mode 100644 (file)
index 0000000..3e492dd
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * collectd/java - org/collectd/api/CollectdFlushInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a flush method.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see Collectd#registerFlush
+ */
+public interface CollectdFlushInterface
+{
+       public int flush (int timeout, String identifier);
+}
diff --git a/bindings/java/org/collectd/api/CollectdInitInterface.java b/bindings/java/org/collectd/api/CollectdInitInterface.java
new file mode 100644 (file)
index 0000000..fbfd306
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * collectd/java - org/collectd/api/CollectdInitInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing an init method.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see Collectd#registerInit
+ */
+public interface CollectdInitInterface
+{
+       public int init ();
+}
diff --git a/bindings/java/org/collectd/api/CollectdLogInterface.java b/bindings/java/org/collectd/api/CollectdLogInterface.java
new file mode 100644 (file)
index 0000000..ba0350a
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * collectd/java - org/collectd/api/CollectdLogInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a log method.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see Collectd#registerLog
+ */
+public interface CollectdLogInterface
+{
+       public void log (int severity, String message);
+}
diff --git a/bindings/java/org/collectd/api/CollectdMatchFactoryInterface.java b/bindings/java/org/collectd/api/CollectdMatchFactoryInterface.java
new file mode 100644 (file)
index 0000000..7b1c71a
--- /dev/null
@@ -0,0 +1,49 @@
+/*
+ * collectd/java - org/collectd/api/CollectdMatchFactoryInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a "match factory".
+ *
+ * Objects implementing this interface are used to create objects implementing
+ * the CollectdMatchInterface interface.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see CollectdMatchInterface
+ * @see Collectd#registerMatch
+ */
+public interface CollectdMatchFactoryInterface
+{
+       /**
+        * Create a new "match" object.
+        *
+        * This method uses the configuration provided as argument to create a
+        * new object which must implement the {@link CollectdMatchInterface}
+        * interface.
+        *
+        * This function corresponds to the <code>create</code> member of the
+        * <code>src/filter_chain.h:match_proc_t</code> struct.
+        *
+        * @return New {@link CollectdMatchInterface} object.
+        */
+       public CollectdMatchInterface createMatch (OConfigItem ci);
+}
diff --git a/bindings/java/org/collectd/api/CollectdMatchInterface.java b/bindings/java/org/collectd/api/CollectdMatchInterface.java
new file mode 100644 (file)
index 0000000..cc8a99e
--- /dev/null
@@ -0,0 +1,48 @@
+/*
+ * collectd/java - org/collectd/api/CollectdMatchInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a match method.
+ *
+ * These objects are instantiated using objects which implement the
+ * CollectdMatchFactoryInterface interface. They are not instantiated by the
+ * daemon directly!
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see CollectdMatchFactoryInterface
+ * @see Collectd#registerMatch
+ */
+public interface CollectdMatchInterface
+{
+       /**
+        * Callback method for matches.
+        *
+        * This method is called to decide whether or not a given ValueList
+        * matches or not. How this is determined is the is the main part of
+        * this function.
+        *
+        * @return One of {@link Collectd#FC_MATCH_NO_MATCH} and {@link Collectd#FC_MATCH_MATCHES}.
+        * @see CollectdMatchFactoryInterface
+        */
+       public int match (DataSet ds, ValueList vl);
+} /* public interface CollectdMatchInterface */
diff --git a/bindings/java/org/collectd/api/CollectdNotificationInterface.java b/bindings/java/org/collectd/api/CollectdNotificationInterface.java
new file mode 100644 (file)
index 0000000..d278fe2
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * collectd/java - org/collectd/api/CollectdNotificationInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a notification method.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see Collectd#registerNotification
+ */
+public interface CollectdNotificationInterface
+{
+       public int notification (Notification n);
+}
diff --git a/bindings/java/org/collectd/api/CollectdReadInterface.java b/bindings/java/org/collectd/api/CollectdReadInterface.java
new file mode 100644 (file)
index 0000000..67f1898
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+ * collectd/java - org/collectd/api/CollectdReadInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a read method.
+ *
+ * Objects implementing this interface can be registered with the daemon. Their
+ * read method is then called periodically to acquire and submit values.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see Collectd#registerRead
+ */
+public interface CollectdReadInterface
+{
+       /**
+        * Callback method for read plugins.
+        *
+        * This method is called once every few seconds (depends on the
+        * configuration of the daemon). It is supposed to gather values in
+        * some way and submit them to the daemon using
+        * {@link Collectd#dispatchValues}.
+        *
+        * @return zero when successful, non-zero when an error occurred.
+        * @see Collectd#dispatchValues
+        */
+       public int read ();
+}
diff --git a/bindings/java/org/collectd/api/CollectdShutdownInterface.java b/bindings/java/org/collectd/api/CollectdShutdownInterface.java
new file mode 100644 (file)
index 0000000..108c54e
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * collectd/java - org/collectd/api/CollectdShutdownInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a shutdown method.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see Collectd#registerShutdown
+ */
+public interface CollectdShutdownInterface
+{
+       public int shutdown ();
+}
diff --git a/bindings/java/org/collectd/api/CollectdTargetFactoryInterface.java b/bindings/java/org/collectd/api/CollectdTargetFactoryInterface.java
new file mode 100644 (file)
index 0000000..65f6181
--- /dev/null
@@ -0,0 +1,49 @@
+/*
+ * collectd/java - org/collectd/api/CollectdTargetFactoryInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a "target factory".
+ *
+ * Objects implementing this interface are used to create objects implementing
+ * the CollectdTargetInterface interface.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see CollectdTargetInterface
+ * @see Collectd#registerTarget
+ */
+public interface CollectdTargetFactoryInterface
+{
+       /**
+        * Create a new "target" object.
+        *
+        * This method uses the configuration provided as argument to create a
+        * new object which must implement the {@link CollectdTargetInterface}
+        * interface.
+        *
+        * This function corresponds to the {@code create} member of the
+        * {@code src/filter_chain.h:target_proc_t} struct.
+        *
+        * @return New {@link CollectdTargetInterface} object.
+        */
+       public CollectdTargetInterface createTarget (OConfigItem ci);
+}
diff --git a/bindings/java/org/collectd/api/CollectdTargetInterface.java b/bindings/java/org/collectd/api/CollectdTargetInterface.java
new file mode 100644 (file)
index 0000000..74412a3
--- /dev/null
@@ -0,0 +1,48 @@
+/*
+ * collectd/java - org/collectd/api/CollectdTargetInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a target method.
+ *
+ * These objects are instantiated using objects which implement the
+ * CollectdTargetFactoryInterface interface. They are not instantiated by the
+ * daemon directly!
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see CollectdTargetFactoryInterface
+ * @see Collectd#registerTarget
+ */
+public interface CollectdTargetInterface
+{
+       /**
+        * Callback method for targets.
+        *
+        * This method is called to perform some action on the given ValueList.
+        * What precisely is done depends entirely on the implementing class.
+        *
+        * @return One of: {@link Collectd#FC_TARGET_CONTINUE},
+        * {@link Collectd#FC_TARGET_STOP}, {@link Collectd#FC_TARGET_RETURN}
+        * @see CollectdTargetFactoryInterface
+        */
+       public int invoke (DataSet ds, ValueList vl);
+} /* public interface CollectdTargetInterface */
diff --git a/bindings/java/org/collectd/api/CollectdWriteInterface.java b/bindings/java/org/collectd/api/CollectdWriteInterface.java
new file mode 100644 (file)
index 0000000..28e0230
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * collectd/java - org/collectd/api/CollectdWriteInterface.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a write method.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ * @see Collectd#registerWrite
+ */
+public interface CollectdWriteInterface
+{
+       public int write (ValueList vl);
+}
diff --git a/bindings/java/org/collectd/api/DataSet.java b/bindings/java/org/collectd/api/DataSet.java
new file mode 100644 (file)
index 0000000..9823073
--- /dev/null
@@ -0,0 +1,137 @@
+/*
+ * collectd/java - org/collectd/api/OConfigItem.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+import java.util.List;
+import java.util.ArrayList;
+
+/**
+ * Java representation of collectd/src/plugin.h:data_set_t structure.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ */
+public class DataSet
+{
+    private String _type;
+    private List<DataSource> _ds;
+
+    private DataSet ()
+    {
+        this._type = null;
+        this._ds = new ArrayList<DataSource> ();
+    }
+
+    public DataSet (String type)
+    {
+        this._type = type;
+        this._ds = new ArrayList<DataSource> ();
+    }
+
+    public DataSet (String type, DataSource dsrc)
+    {
+        this._type = type;
+        this._ds = new ArrayList<DataSource> ();
+        this._ds.add (dsrc);
+    }
+
+    public DataSet (String type, List<DataSource> ds)
+    {
+        this._type = type;
+        this._ds = ds;
+    }
+
+    public void setType (String type)
+    {
+        this._type = type;
+    }
+
+    public String getType ()
+    {
+        return (this._type);
+    }
+
+    public void addDataSource (DataSource dsrc)
+    {
+        this._ds.add (dsrc);
+    }
+
+    public List<DataSource> getDataSources ()
+    {
+        return (this._ds);
+    }
+
+    public String toString ()
+    {
+        StringBuffer sb = new StringBuffer ();
+        int i;
+
+        sb.append (this._type);
+        for (i = 0; i < this._ds.size (); i++)
+        {
+            if (i == 0)
+                sb.append ("\t");
+            else
+                sb.append (", ");
+            sb.append (this._ds.get (i).toString ());
+        }
+
+        return (sb.toString ());
+    }
+
+    static public DataSet parseDataSet (String str)
+    {
+        DataSet ds = new DataSet ();
+        String[] fields;
+        int i;
+
+        str = str.trim();
+        if (str.length() == 0) {
+            return (null);
+        }
+        if (str.charAt(0) == '#') {
+            return (null);
+        }
+
+        fields = str.split ("\\s+");
+        if (fields.length < 2)
+            return (null);
+
+        ds._type = fields[0];
+
+        for (i = 1; i < fields.length; i++) {
+            DataSource dsrc;
+
+            dsrc = DataSource.parseDataSource (fields[i]);
+            if (dsrc == null)
+                break;
+
+            ds._ds.add (dsrc);
+        }
+
+        if (i < fields.length)
+            return (null);
+
+        return (ds);
+    } /* DataSet parseDataSet */
+} /* class DataSet */
+
+/* vim: set sw=4 sts=4 et : */
diff --git a/bindings/java/org/collectd/api/DataSource.java b/bindings/java/org/collectd/api/DataSource.java
new file mode 100644 (file)
index 0000000..bfe8e2d
--- /dev/null
@@ -0,0 +1,145 @@
+/*
+ * jcollectd
+ * Copyright (C) 2009 Hyperic, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ * 
+ * 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
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+package org.collectd.api;
+
+/**
+ * Java representation of collectd/src/plugin.h:data_source_t structure. 
+ */
+public class DataSource {
+    public static final int TYPE_COUNTER = 0;
+    public static final int TYPE_GAUGE   = 1;
+
+    static final String COUNTER = "COUNTER";
+    static final String GAUGE = "GAUGE";
+
+    static final String NAN = "U";
+    private static final String[] TYPES = { COUNTER, GAUGE };
+
+    String _name;
+    int _type;
+    double _min;
+    double _max;
+
+    public DataSource (String name, int type, double min, double max) {
+        this._name = name;
+        this._type = TYPE_GAUGE;
+        if (type == TYPE_COUNTER)
+            this._type = TYPE_COUNTER;
+        this._min = min;
+        this._max = max;
+    }
+
+    /* Needed in parseDataSource below. Other code should use the above
+     * constructor or `parseDataSource'. */
+    private DataSource () {
+        this._type = TYPE_GAUGE;
+    }
+
+    public String getName() {
+        return _name;
+    }
+
+    public void setName(String name) {
+        _name = name;
+    }
+
+    public int getType() {
+        return _type;
+    }
+
+    public void setType(int type) {
+        _type = type;
+    }
+
+    public double getMin() {
+        return _min;
+    }
+
+    public void setMin(double min) {
+        _min = min;
+    }
+
+    public double getMax() {
+        return _max;
+    }
+
+    public void setMax(double max) {
+        _max = max;
+    }
+
+    static double toDouble(String val) {
+        if (val.equals(NAN)) {
+            return Double.NaN;
+        }
+        else {
+            return Double.parseDouble(val);
+        }
+    }
+
+    private String asString(double val) {
+        if (Double.isNaN(val)) {
+            return NAN;
+        }
+        else {
+            return String.valueOf(val);
+        }
+    }
+
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        final char DLM = ':';
+        sb.append(_name).append(DLM);
+        sb.append(TYPES[_type]).append(DLM);
+        sb.append(asString(_min)).append(DLM);
+        sb.append(asString(_max));
+        return sb.toString();
+    }
+
+    static public DataSource parseDataSource (String str)
+    {
+        String[] fields;
+        int str_len = str.length ();
+        DataSource dsrc = new DataSource ();
+
+        /* Ignore trailing commas. This makes it easier for parsing code. */
+        if (str.charAt (str_len - 1) == ',') {
+            str = str.substring (0, str_len - 1);
+        }
+
+        fields = str.split(":");
+        if (fields.length != 4)
+            return (null);
+
+        dsrc._name = fields[0];
+
+        if (fields[1].equals (DataSource.GAUGE)) {
+            dsrc._type  = TYPE_GAUGE;
+        }
+        else {
+            dsrc._type  = TYPE_COUNTER;
+        }
+
+        dsrc._min =  toDouble (fields[2]);
+        dsrc._max =  toDouble (fields[3]);
+
+        return (dsrc);
+    } /* DataSource parseDataSource */
+}
+
+/* vim: set sw=4 sts=4 et : */
diff --git a/bindings/java/org/collectd/api/Notification.java b/bindings/java/org/collectd/api/Notification.java
new file mode 100644 (file)
index 0000000..cfc2186
--- /dev/null
@@ -0,0 +1,88 @@
+/*
+ * jcollectd
+ * Copyright (C) 2009 Hyperic, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ * 
+ * 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
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+package org.collectd.api;
+
+/**
+ * Java representation of collectd/src/plugin.h:notfication_t structure.
+ */
+public class Notification extends PluginData {
+    public static final int FAILURE = 1;
+    public static final int WARNING = 2;
+    public static final int OKAY    = 4;
+
+    public static String[] SEVERITY = {
+        "FAILURE",
+        "WARNING",
+        "OKAY",
+        "UNKNOWN"
+    };
+
+    private int _severity;
+    private String _message;
+
+    public Notification () {
+        _severity = 0;
+        _message = "Initial notification message";
+    }
+
+    public Notification (PluginData pd) {
+        super (pd);
+        _severity = 0;
+        _message = "Initial notification message";
+    }
+
+    public void setSeverity (int severity) {
+        if ((severity == FAILURE)
+                || (severity == WARNING)
+                || (severity == OKAY))
+            this._severity = severity;
+    }
+
+    public int getSeverity() {
+        return _severity;
+    }
+
+    public String getSeverityString() {
+        switch (_severity) {
+            case FAILURE:
+                return SEVERITY[0];
+            case WARNING:
+                return SEVERITY[1];
+            case OKAY:
+                return SEVERITY[2];
+            default:
+                return SEVERITY[3];
+        }
+    }
+
+    public void setMessage (String message) {
+        this._message = message;
+    }
+
+    public String getMessage() {
+        return _message;
+    }
+
+    public String toString() {
+        StringBuffer sb = new StringBuffer(super.toString());
+        sb.append(" [").append(getSeverityString()).append("] ");
+        sb.append(_message);
+        return sb.toString();
+    }
+}
diff --git a/bindings/java/org/collectd/api/OConfigItem.java b/bindings/java/org/collectd/api/OConfigItem.java
new file mode 100644 (file)
index 0000000..4c6a778
--- /dev/null
@@ -0,0 +1,91 @@
+/*
+ * collectd/java - org/collectd/api/OConfigItem.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+import java.util.List;
+import java.util.ArrayList;
+
+/**
+ * Java representation of collectd/src/liboconfig/oconfig.h:oconfig_item_t structure.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ */
+public class OConfigItem
+{
+  private String _key = null;
+  private List<OConfigValue> _values   = new ArrayList<OConfigValue> ();
+  private List<OConfigItem>  _children = new ArrayList<OConfigItem> ();
+
+  public OConfigItem (String key)
+  {
+    _key = key;
+  } /* OConfigItem (String key) */
+
+  public String getKey ()
+  {
+    return (_key);
+  } /* String getKey () */
+
+  public void addValue (OConfigValue cv)
+  {
+    _values.add (cv);
+  } /* void addValue (OConfigValue cv) */
+
+  public void addValue (String s)
+  {
+    _values.add (new OConfigValue (s));
+  } /* void addValue (String s) */
+
+  public void addValue (Number n)
+  {
+    _values.add (new OConfigValue (n));
+  } /* void addValue (String s) */
+
+  public void addValue (boolean b)
+  {
+    _values.add (new OConfigValue (b));
+  } /* void addValue (String s) */
+
+  public List<OConfigValue> getValues ()
+  {
+    return (_values);
+  } /* List<OConfigValue> getValues () */
+
+  public void addChild (OConfigItem ci)
+  {
+    _children.add (ci);
+  } /* void addChild (OConfigItem ci) */
+
+  public List<OConfigItem> getChildren ()
+  {
+    return (_children);
+  } /* List<OConfigItem> getChildren () */
+
+  public String toString ()
+  {
+    return (new String ("{ key: " + _key + "; "
+          + "values: " + _values.toString () + "; "
+          + "children: " + _children.toString () + "; }"));
+  } /* String toString () */
+} /* class OConfigItem */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
diff --git a/bindings/java/org/collectd/api/OConfigValue.java b/bindings/java/org/collectd/api/OConfigValue.java
new file mode 100644 (file)
index 0000000..1ebafff
--- /dev/null
@@ -0,0 +1,96 @@
+/*
+ * collectd/java - org/collectd/api/OConfigValue.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Java representation of collectd/src/liboconfig/oconfig.h:oconfig_value_t structure.
+ *
+ * @author Florian Forster &lt;octo at verplant.org&gt;
+ */
+public class OConfigValue
+{
+  public static final int OCONFIG_TYPE_STRING  = 0;
+  public static final int OCONFIG_TYPE_NUMBER  = 1;
+  public static final int OCONFIG_TYPE_BOOLEAN = 2;
+
+  private int     _type;
+  private String  _value_string;
+  private Number  _value_number;
+  private boolean _value_boolean;
+
+  public OConfigValue (String s)
+  {
+    _type = OCONFIG_TYPE_STRING;
+    _value_string  = s;
+    _value_number  = null;
+    _value_boolean = false;
+  } /* OConfigValue (String s) */
+
+  public OConfigValue (Number n)
+  {
+    _type = OCONFIG_TYPE_NUMBER;
+    _value_string  = null;
+    _value_number  = n;
+    _value_boolean = false;
+  } /* OConfigValue (String s) */
+
+  public OConfigValue (boolean b)
+  {
+    _type = OCONFIG_TYPE_BOOLEAN;
+    _value_string  = null;
+    _value_number  = null;
+    _value_boolean = b;
+  } /* OConfigValue (String s) */
+
+  public int getType ()
+  {
+    return (_type);
+  } /* int getType */
+
+  public String getString ()
+  {
+    return (_value_string);
+  } /* String getString */
+
+  public Number getNumber ()
+  {
+    return (_value_number);
+  } /* String getString */
+
+  public boolean getBoolean ()
+  {
+    return (_value_boolean);
+  } /* String getString */
+
+  public String toString ()
+  {
+    if (_type == OCONFIG_TYPE_STRING)
+      return (_value_string);
+    else if (_type == OCONFIG_TYPE_NUMBER)
+      return (_value_number.toString ());
+    else if (_type == OCONFIG_TYPE_BOOLEAN)
+      return (Boolean.toString (_value_boolean));
+    return (null);
+  } /* String toString () */
+} /* class OConfigValue */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
diff --git a/bindings/java/org/collectd/api/PluginData.java b/bindings/java/org/collectd/api/PluginData.java
new file mode 100644 (file)
index 0000000..26b0206
--- /dev/null
@@ -0,0 +1,127 @@
+/*
+ * jcollectd
+ * Copyright (C) 2009 Hyperic, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ * 
+ * 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
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+package org.collectd.api;
+
+import java.util.Date;
+
+/**
+ * Shared members of value_list_t and notification_t structures.
+ */
+public class PluginData {
+
+    protected long _time = 0;
+    protected String _host;
+    protected String _plugin;
+    protected String _pluginInstance = "";
+    protected String _type = "";
+    protected String _typeInstance = "";
+
+    public PluginData() {
+        
+    }
+
+    public PluginData(PluginData pd) {
+        _time = pd._time;
+        _host = pd._host;
+        _plugin = pd._plugin;
+        _pluginInstance = pd._pluginInstance;
+        _type = pd._type;
+        _typeInstance = pd._typeInstance;
+    }
+
+    public long getTime() {
+        return _time;
+    }
+
+    public void setTime(long time) {
+        _time = time;
+    }
+
+    public String getHost() {
+        return _host;
+    }
+
+    public void setHost(String host) {
+        _host = host;
+    }
+
+    public String getPlugin() {
+        return _plugin;
+    }
+
+    public void setPlugin(String plugin) {
+        _plugin = plugin;
+    }
+
+    public String getPluginInstance() {
+        return _pluginInstance;
+    }
+
+    public void setPluginInstance(String pluginInstance) {
+        _pluginInstance = pluginInstance;
+    }
+
+    public String getType() {
+        return _type;
+    }
+
+    public void setType(String type) {
+        _type = type;
+    }
+
+    public String getTypeInstance() {
+        return _typeInstance;
+    }
+
+    public void setTypeInstance(String typeInstance) {
+        _typeInstance = typeInstance;
+    }
+
+    public boolean defined(String val) {
+        return (val != null) && (val.length() > 0);
+    }
+
+    public String getSource() {
+        final char DLM = '/';
+        StringBuffer sb = new StringBuffer();
+        if (defined(_host)) {
+            sb.append(_host);
+        }
+        if (defined(_plugin)) {
+            sb.append(DLM).append(_plugin);
+        }
+        if (defined(_pluginInstance)) {
+            sb.append(DLM).append(_pluginInstance);
+        }
+        if (defined(_type)) {
+            sb.append(DLM).append(_type);
+        }
+        if (defined(_typeInstance)) {
+            sb.append(DLM).append(_typeInstance);
+        }
+        return sb.toString();        
+    }
+
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append('[').append(new Date(_time)).append("] ");
+        sb.append(getSource());
+        return sb.toString();
+    }
+}
diff --git a/bindings/java/org/collectd/api/ValueList.java b/bindings/java/org/collectd/api/ValueList.java
new file mode 100644 (file)
index 0000000..1baeff2
--- /dev/null
@@ -0,0 +1,122 @@
+/*
+ * jcollectd
+ * Copyright (C) 2009 Hyperic, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ * 
+ * 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
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+package org.collectd.api;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Java representation of collectd/src/plugin.h:value_list_t structure.
+ */
+public class ValueList extends PluginData {
+
+    private List<Number> _values = new ArrayList<Number>();
+    private DataSet _ds;
+
+    private long _interval = 0;
+
+    public ValueList() {
+        
+    }
+
+    public ValueList(PluginData pd) {
+        super(pd);
+    }
+
+    public ValueList(ValueList vl) {
+        this((PluginData)vl);
+        _interval = vl._interval;
+        _values.addAll(vl.getValues());
+       _ds = vl._ds;
+    }
+
+    public List<Number> getValues() {
+        return _values;
+    }
+
+    public void setValues(List<Number> values) {
+        _values = values;
+    }
+
+    public void addValue(Number value) {
+        _values.add(value);
+    }
+
+    /* Used by the network parsing code */
+    public void clearValues () {
+        _values.clear ();
+    }
+
+    /**
+     * @deprecated Use {@link #getDataSet()} instead.
+     */
+    public List<DataSource> getDataSource() {
+        if (_ds == null)
+            return null;
+        return _ds.getDataSources ();
+    }
+
+    public DataSet getDataSet () {
+        return _ds;
+    }
+
+    public void setDataSet (DataSet ds) {
+        _ds = ds;
+    }
+
+    /**
+     * @deprecated Use {@link #setDataSet(DataSet)} instead.
+     */
+    public void setDataSource(List<DataSource> dsrc) {
+        _ds = new DataSet (_type, dsrc);
+    }
+
+    public long getInterval() {
+        return _interval;
+    }
+
+    public void setInterval(long interval) {
+        _interval = interval;
+    }
+
+    public String toString() {
+        StringBuffer sb = new StringBuffer(super.toString());
+        sb.append("=[");
+        List<DataSource> ds = getDataSource();
+        int size = _values.size();
+        for (int i=0; i<size; i++) {
+            Number val = _values.get(i);
+            String name;
+            if (ds == null) {
+                name = "unknown" + i;
+            }
+            else {
+                name = ds.get(i).getName();
+            }
+            sb.append(name).append('=').append(val);
+            if (i < size-1) {
+                sb.append(',');
+            }
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+}
+
+/* vim: set sw=4 sts=4 et : */
diff --git a/bindings/java/org/collectd/java/JMXMemory.java b/bindings/java/org/collectd/java/JMXMemory.java
new file mode 100644 (file)
index 0000000..d1666c0
--- /dev/null
@@ -0,0 +1,232 @@
+/*
+ * collectd/java - org/collectd/java/JMXMemory.java
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.java;
+
+import java.util.List;
+import java.util.Date;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryUsage;
+import java.lang.management.MemoryMXBean;
+
+import javax.management.MBeanServerConnection;
+import javax.management.remote.JMXConnector;
+import javax.management.remote.JMXConnectorFactory;
+import javax.management.remote.JMXServiceURL;
+
+import org.collectd.api.Collectd;
+import org.collectd.api.DataSet;
+import org.collectd.api.ValueList;
+import org.collectd.api.Notification;
+import org.collectd.api.OConfigItem;
+
+import org.collectd.api.CollectdConfigInterface;
+import org.collectd.api.CollectdInitInterface;
+import org.collectd.api.CollectdReadInterface;
+import org.collectd.api.CollectdShutdownInterface;
+
+import org.collectd.api.OConfigValue;
+import org.collectd.api.OConfigItem;
+
+public class JMXMemory implements CollectdConfigInterface, /* {{{ */
+       CollectdInitInterface,
+       CollectdReadInterface,
+       CollectdShutdownInterface
+{
+  private String _jmx_service_url = null;
+  private MemoryMXBean _mbean = null;
+
+  public JMXMemory ()
+  {
+    Collectd.registerConfig   ("JMXMemory", this);
+    Collectd.registerInit     ("JMXMemory", this);
+    Collectd.registerRead     ("JMXMemory", this);
+    Collectd.registerShutdown ("JMXMemory", this);
+  }
+
+  private void submit (String plugin_instance, MemoryUsage usage) /* {{{ */
+  {
+    ValueList vl;
+
+    long mem_init;
+    long mem_used;
+    long mem_committed;
+    long mem_max;
+
+    mem_init = usage.getInit ();
+    mem_used = usage.getUsed ();
+    mem_committed = usage.getCommitted ();
+    mem_max = usage.getMax ();
+
+    Collectd.logDebug ("JMXMemory plugin: plugin_instance = " + plugin_instance + "; "
+        + "mem_init = " + mem_init + "; "
+        + "mem_used = " + mem_used + "; "
+        + "mem_committed = " + mem_committed + "; "
+        + "mem_max = " + mem_max + ";");
+
+    vl = new ValueList ();
+
+    vl.setHost ("localhost");
+    vl.setPlugin ("JMXMemory");
+    vl.setPluginInstance (plugin_instance);
+    vl.setType ("memory");
+
+    if (mem_init >= 0)
+    {
+      vl.addValue (mem_init);
+      vl.setTypeInstance ("init");
+      Collectd.dispatchValues (vl);
+      vl.clearValues ();
+    }
+
+    if (mem_used >= 0)
+    {
+      vl.addValue (mem_used);
+      vl.setTypeInstance ("used");
+      Collectd.dispatchValues (vl);
+      vl.clearValues ();
+    }
+
+    if (mem_committed >= 0)
+    {
+      vl.addValue (mem_committed);
+      vl.setTypeInstance ("committed");
+      Collectd.dispatchValues (vl);
+      vl.clearValues ();
+    }
+
+    if (mem_max >= 0)
+    {
+      vl.addValue (mem_max);
+      vl.setTypeInstance ("max");
+      Collectd.dispatchValues (vl);
+      vl.clearValues ();
+    }
+  } /* }}} void submit */
+
+  private int configServiceURL (OConfigItem ci) /* {{{ */
+  {
+    List<OConfigValue> values;
+    OConfigValue cv;
+
+    values = ci.getValues ();
+    if (values.size () != 1)
+    {
+      Collectd.logError ("JMXMemory plugin: The JMXServiceURL option needs "
+          + "exactly one string argument.");
+      return (-1);
+    }
+
+    cv = values.get (0);
+    if (cv.getType () != OConfigValue.OCONFIG_TYPE_STRING)
+    {
+      Collectd.logError ("JMXMemory plugin: The JMXServiceURL option needs "
+          + "exactly one string argument.");
+      return (-1);
+    }
+
+    _jmx_service_url = cv.getString ();
+    return (0);
+  } /* }}} int configServiceURL */
+
+  public int config (OConfigItem ci) /* {{{ */
+  {
+    List<OConfigItem> children;
+    int i;
+
+    Collectd.logDebug ("JMXMemory plugin: config: ci = " + ci + ";");
+
+    children = ci.getChildren ();
+    for (i = 0; i < children.size (); i++)
+    {
+      OConfigItem child;
+      String key;
+
+      child = children.get (i);
+      key = child.getKey ();
+      if (key.equalsIgnoreCase ("JMXServiceURL"))
+      {
+        configServiceURL (child);
+      }
+      else
+      {
+        Collectd.logError ("JMXMemory plugin: Unknown config option: " + key);
+      }
+    }
+
+    return (0);
+  } /* }}} int config */
+
+  public int init () /* {{{ */
+  {
+    JMXServiceURL service_url;
+    JMXConnector connector;
+    MBeanServerConnection connection;
+
+    if (_jmx_service_url == null)
+    {
+      Collectd.logError ("JMXMemory: _jmx_service_url == null");
+      return (-1);
+    }
+
+    try
+    {
+      service_url = new JMXServiceURL (_jmx_service_url);
+      connector = JMXConnectorFactory.connect (service_url);
+      connection = connector.getMBeanServerConnection ();
+      _mbean = ManagementFactory.newPlatformMXBeanProxy (connection,
+          ManagementFactory.MEMORY_MXBEAN_NAME,
+          MemoryMXBean.class);
+    }
+    catch (Exception e)
+    {
+      Collectd.logError ("JMXMemory: Creating MBean failed: " + e);
+      return (-1);
+    }
+
+    return (0);
+  } /* }}} int init */
+
+  public int read () /* {{{ */
+  {
+    if (_mbean == null)
+    {
+      Collectd.logError ("JMXMemory: _mbean == null");
+      return (-1);
+    }
+
+    submit ("heap", _mbean.getHeapMemoryUsage ());
+    submit ("non_heap", _mbean.getNonHeapMemoryUsage ());
+
+    return (0);
+  } /* }}} int read */
+
+  public int shutdown () /* {{{ */
+  {
+    System.out.print ("org.collectd.java.JMXMemory.Shutdown ();\n");
+    _jmx_service_url = null;
+    _mbean = null;
+    return (0);
+  } /* }}} int shutdown */
+} /* }}} class JMXMemory */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
index 5733f2e..098669d 100755 (executable)
--- a/clean.sh
+++ b/clean.sh
@@ -43,4 +43,8 @@ true \
 && rm -f src/libping/config.h.in \
 && rm -f src/libping/Makefile \
 && rm -f src/libping/Makefile.in \
-&& rm -f src/libping/stamp-h2
+&& rm -f src/libping/stamp-h2 \
+&& rm -f -r src/libcollectdclient/.libs \
+&& rm -f src/libcollectdclient/*.o \
+&& rm -f src/libcollectdclient/*.la \
+&& rm -f src/libcollectdclient/*.lo
index 2344cdb..f0c4312 100644 (file)
@@ -1187,6 +1187,166 @@ AC_DEFINE_UNQUOTED(COLLECT_LIBESMTP, [$collect_libesmtp],
 AM_CONDITIONAL(BUILD_WITH_LIBESMTP, test "x$with_libesmtp" = "xyes")
 # }}}
 
+# --with-libganglia {{{
+AC_ARG_WITH(libganglia, [AS_HELP_STRING([--with-libganglia@<:@=PREFIX@:>@], [Path to libganglia.])],
+[
+ if test -f "$withval" && test -x "$withval"
+ then
+        with_libganglia_config="$withval"
+        with_libganglia="yes"
+ else if test -f "$withval/bin/ganglia-config" && test -x "$withval/bin/ganglia-config"
+ then
+        with_libganglia_config="$withval/bin/ganglia-config"
+        with_libganglia="yes"
+ else if test -d "$withval"
+ then
+        GANGLIA_CPPFLAGS="-I$withval/include"
+        GANGLIA_LDFLAGS="-L$withval/lib"
+        with_libganglia="yes"
+ else
+        with_libganglia_config="ganglia-config"
+        with_libganglia="$withval"
+ fi; fi; fi
+],
+[
+ with_libganglia_config="ganglia-config"
+ with_libganglia="yes"
+])
+
+if test "x$with_libganglia" = "xyes" && test "x$with_libganglia_config" != "x"
+then
+       if test "x$GANGLIA_CPPFLAGS" = "x"
+       then
+               GANGLIA_CPPFLAGS=`"$with_libganglia_config" --cflags 2>/dev/null`
+       fi
+
+       if test "x$GANGLIA_LDFLAGS" = "x"
+       then
+               GANGLIA_LDFLAGS=`"$with_libganglia_config" --ldflags 2>/dev/null`
+       fi
+
+       if test "x$GANGLIA_LIBS" = "x"
+       then
+               GANGLIA_LIBS=`"$with_libganglia_config" --libs 2>/dev/null`
+       fi
+fi
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+CPPFLAGS="$CPPFLAGS $GANGLIA_CPPFLAGS"
+LDFLAGS="$LDFLAGS $GANGLIA_LDFLAGS"
+
+if test "x$with_libganglia" = "xyes"
+then
+       AC_CHECK_HEADERS(gm_protocol.h,
+       [
+               AC_DEFINE(HAVE_GM_PROTOCOL_H, 1,
+                         [Define to 1 if you have the <gm_protocol.h> header file.])
+       ], [with_libganglia="no (gm_protocol.h not found)"])
+fi
+
+if test "x$with_libganglia" = "xyes"
+then
+       AC_CHECK_LIB(ganglia, xdr_Ganglia_value_msg,
+       [
+               AC_DEFINE(HAVE_LIBGANGLIA, 1,
+                         [Define to 1 if you have the ganglia library (-lganglia).])
+       ], [with_libganglia="no (symbol xdr_Ganglia_value_msg not found)"])
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
+
+AC_SUBST(GANGLIA_CPPFLAGS)
+AC_SUBST(GANGLIA_LDFLAGS)
+AC_SUBST(GANGLIA_LIBS)
+AM_CONDITIONAL(BUILD_WITH_LIBGANGLIA, test "x$with_libganglia" = "xyes")
+# }}}
+
+# --with-libgcrypt {{{
+GCRYPT_CPPFLAGS="$GCRYPT_CPPFLAGS"
+GCRYPT_LDFLAGS="$GCRYPT_LDFLAGS"
+GCRYPT_LIBS="$GCRYPT_LIBS"
+AC_ARG_WITH(libgcrypt, [AS_HELP_STRING([--with-libgcrypt@<:@=PREFIX@:>@], [Path to libgcrypt.])],
+[
+ if test -f "$withval" && test -x "$withval"
+ then
+        with_libgcrypt_config="$withval"
+        with_libgcrypt="yes"
+ else if test -f "$withval/bin/gcrypt-config" && test -x "$withval/bin/gcrypt-config"
+ then
+        with_libgcrypt_config="$withval/bin/gcrypt-config"
+        with_libgcrypt="yes"
+ else if test -d "$withval"
+ then
+        GCRYPT_CPPFLAGS="$GCRYPT_CPPFLAGS -I$withval/include"
+        GCRYPT_LDFLAGS="$GCRYPT_LDFLAGS -L$withval/lib"
+        with_libgcrypt="yes"
+ else
+        with_libgcrypt_config="gcrypt-config"
+        with_libgcrypt="$withval"
+ fi; fi; fi
+],
+[
+ with_libgcrypt_config="libgcrypt-config"
+ with_libgcrypt="yes"
+])
+
+if test "x$with_libgcrypt" = "xyes" && test "x$with_libgcrypt_config" != "x"
+then
+       if test "x$GCRYPT_CPPFLAGS" = "x"
+       then
+               GCRYPT_CPPFLAGS=`"$with_libgcrypt_config" --cflags 2>/dev/null`
+       fi
+
+       if test "x$GCRYPT_LDFLAGS" = "x"
+       then
+               gcrypt_exec_prefix=`"$with_libgcrypt_config" --exec-prefix 2>/dev/null`
+               GCRYPT_LDFLAGS="-L$gcrypt_exec_prefix/lib"
+       fi
+
+       if test "x$GCRYPT_LIBS" = "x"
+       then
+               GCRYPT_LIBS=`"$with_libgcrypt_config" --libs 2>/dev/null`
+       fi
+fi
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+CPPFLAGS="$CPPFLAGS $GCRYPT_CPPFLAGS"
+LDFLAGS="$LDFLAGS $GCRYPT_LDFLAGS"
+
+if test "x$with_libgcrypt" = "xyes"
+then
+       if test "x$GCRYPT_CPPFLAGS" != "x"
+       then
+               AC_MSG_NOTICE([gcrypt CPPFLAGS: $GCRYPT_CPPFLAGS])
+       fi
+       AC_CHECK_HEADERS(gcrypt.h,
+               [with_libgcrypt="yes"],
+               [with_libgcrypt="no (gcrypt.h not found)"])
+fi
+
+if test "x$with_libgcrypt" = "xyes"
+then
+       if test "x$GCRYPT_LDFLAGS" != "x"
+       then
+               AC_MSG_NOTICE([gcrypt LDFLAGS: $GCRYPT_LDFLAGS])
+       fi
+       AC_CHECK_LIB(gcrypt, gcry_md_hash_buffer,
+               [with_libgcrypt="yes"],
+               [with_libgcrypt="no (symbol gcry_md_hash_buffer not found)"])
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
+
+AC_SUBST(GCRYPT_CPPFLAGS)
+AC_SUBST(GCRYPT_LDFLAGS)
+AC_SUBST(GCRYPT_LIBS)
+AM_CONDITIONAL(BUILD_WITH_LIBGCRYPT, test "x$with_libgcrypt" = "xyes")
+# }}}
+
 # --with-libiptc {{{
 with_own_libiptc="no"
 AC_ARG_WITH(libiptc, [AS_HELP_STRING([--with-libiptc@<:@=PREFIX@:>@], [Path to libiptc.])],
@@ -1254,6 +1414,147 @@ then
 fi
 # }}}
 
+# --with-java {{{
+with_java_home="$JAVA_HOME"
+with_java_vmtype="client"
+with_java_cflags=""
+with_java_libs=""
+AC_ARG_WITH(java, [AS_HELP_STRING([--with-java@<:@=PREFIX@:>@], [Path to Java home.])],
+[
+       if test "x$withval" = "xno"
+       then
+               with_java="no"
+       else if test "x$withval" = "xyes"
+       then
+               with_java="yes"
+       else
+               with_java_home="$withval"
+               with_java="yes"
+       fi; fi
+],
+[with_java="yes"])
+if test "x$with_java" = "xyes"
+then
+       if test -d "$with_java_home"
+       then
+               if test -d "$with_java_home/include"
+               then
+                       JAVA_CPPFLAGS="$JAVA_CPPFLAGS -I$with_java_home/include"
+               else
+                       JAVA_CPPFLAGS="$JAVA_CPPFLAGS -I$with_java_home"
+               fi
+               
+               if test -d "$with_java_home/lib"
+               then
+                       JAVA_LDFLAGS="$JAVA_LDFLAGS -L$with_java_home/lib"
+               else
+                       JAVA_LDFLAGS="$JAVA_LDFLAGS -L$with_java_home"
+               fi
+       else if test "x$with_java_home" != "x"
+       then
+               AC_MSG_WARN([JAVA_HOME: No such directory: $with_java_home])
+       fi; fi
+fi
+
+if test "x$JAVA_CPPFLAGS" != "x"
+then
+       AC_MSG_NOTICE([Building with JAVA_CPPFLAGS set to: $JAVA_CPPFLAGS])
+fi
+if test "x$JAVA_CFLAGS" != "x"
+then
+       AC_MSG_NOTICE([Building with JAVA_CFLAGS set to: $JAVA_CFLAGS])
+fi
+if test "x$JAVA_LDFLAGS" != "x"
+then
+       AC_MSG_NOTICE([Building with JAVA_LDFLAGS set to: $JAVA_LDFLAGS])
+fi
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_CFLAGS="$CFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+CPPFLAGS="$CPPFLAGS $JAVA_CPPFLAGS"
+CFLAGS="$CFLAGS $JAVA_CFLAGS"
+LDFLAGS="$LDFLAGS $JAVA_LDFLAGS"
+
+if test "x$with_java" = "xyes"
+then
+       AC_CHECK_HEADERS(jni.h, [], [with_java="no (jni.h not found)"])
+fi
+if test "x$with_java" = "xyes"
+then
+       AC_CHECK_LIB(jvm, JNI_CreateJavaVM,
+       [with_java="yes"],
+       [with_java="no (libjvm not found)"],
+       [$JAVA_LIBS])
+fi
+if test "x$with_java" = "xyes"
+then
+       JAVA_LIBS="$JAVA_LIBS -ljvm"
+       AC_MSG_NOTICE([Building with JAVA_LIBS set to: $JAVA_LIBS])
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+CFLAGS="$SAVE_CFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
+
+AC_SUBST(JAVA_CPPFLAGS)
+AC_SUBST(JAVA_CFLAGS)
+AC_SUBST(JAVA_LDFLAGS)
+AC_SUBST(JAVA_LIBS)
+AM_CONDITIONAL(BUILD_WITH_JAVA, test "x$with_java" = "xyes")
+# }}}
+
+# --with-libmemcached {{{
+with_libmemcached_cppflags=""
+with_libmemcached_ldflags=""
+AC_ARG_WITH(libmemcached, [AS_HELP_STRING([--with-libmemcached@<:@=PREFIX@:>@], [Path to libmemcached.])],
+[
+       if test "x$withval" != "xno" && test "x$withval" != "xyes"
+       then
+               with_libmemcached_cppflags="-I$withval/include"
+               with_libmemcached_ldflags="-L$withval/lib"
+               with_libmemcached="yes"
+       else
+               with_libmemcached="$withval"
+       fi
+],
+[
+       with_libmemcached="yes"
+])
+if test "x$with_libmemcached" = "xyes"
+then
+       SAVE_CPPFLAGS="$CPPFLAGS"
+       CPPFLAGS="$CPPFLAGS $with_libmemcached_cppflags"
+
+       AC_CHECK_HEADERS(libmemcached/memcached.h, [with_libmemcached="yes"], [with_libmemcached="no (libmemcached/memcached.h not found)"])
+
+       CPPFLAGS="$SAVE_CPPFLAGS"
+fi
+if test "x$with_libmemcached" = "xyes"
+then
+       SAVE_CPPFLAGS="$CPPFLAGS"
+       SAVE_LDFLAGS="$LDFLAGS"
+       CPPFLAGS="$CPPFLAGS $with_libmemcached_cppflags"
+       LDFLAGS="$LDFLAGS $with_libmemcached_ldflags"
+
+       AC_CHECK_LIB(memcached, memcached_create, [with_libmemcached="yes"], [with_libmemcached="no (Symbol 'memcached_create' not found)"])
+
+       CPPFLAGS="$SAVE_CPPFLAGS"
+       LDFLAGS="$SAVE_LDFLAGS"
+fi
+if test "x$with_libmemcached" = "xyes"
+then
+       BUILD_WITH_LIBMEMCACHED_CPPFLAGS="$with_libmemcached_cppflags"
+       BUILD_WITH_LIBMEMCACHED_LDFLAGS="$with_libmemcached_ldflags"
+       BUILD_WITH_LIBMEMCACHED_LIBS="-lmemcached"
+       AC_SUBST(BUILD_WITH_LIBMEMCACHED_CPPFLAGS)
+       AC_SUBST(BUILD_WITH_LIBMEMCACHED_LDFLAGS)
+       AC_SUBST(BUILD_WITH_LIBMEMCACHED_LIBS)
+       AC_DEFINE(HAVE_LIBMEMCACHED, 1, [Define if libmemcached is present and usable.])
+fi
+AM_CONDITIONAL(BUILD_WITH_LIBMEMCACHED, test "x$with_libmemcached" = "xyes")
+# }}}
+
 # --with-libmysql {{{
 with_mysql_config="mysql_config"
 with_mysql_cflags=""
@@ -1556,55 +1857,60 @@ fi
 # }}}
 
 # --with-liboping {{{
-with_own_liboping="no"
-liboping_LDFLAGS="$LDFLAGS"
-liboping_CPPFLAGS="$CPPFLAGS"
 AC_ARG_WITH(liboping, [AS_HELP_STRING([--with-liboping@<:@=PREFIX@:>@], [Path to liboping.])],
 [
-       if test "x$withval" != "xno" && test "x$withval" != "xyes"
+ if test "x$withval" = "xyes"
+ then
+        with_liboping="yes"
+ else if test "x$withval" = "xno"
+ then
+        with_liboping="no"
+ else
+        with_liboping="yes"
+        LIBOPING_CPPFLAGS="$LIBOPING_CPPFLAGS -I$withval/include"
+        LIBOPING_LDFLAGS="$LIBOPING_LDFLAGS -L$withval/lib"
+ fi; fi
+],
+[with_liboping="yes"])
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+
+CPPFLAGS="$CPPFLAGS $LIBOPING_CPPFLAGS"
+LDFLAGS="$LDFLAGS $LIBOPING_LDFLAGS"
+
+if test "x$with_liboping" = "xyes"
+then
+       if test "x$LIBOPING_CPPFLAGS" != "x"
        then
-               if test -d "$withval/lib"
-               then
-                       liboping_LDFLAGS="$LDFLAGS -L$withval/lib"
-               fi
-               if test -d "$withval/include"
-               then
-                       liboping_CPPFLAGS="$CPPFLAGS -I$withval/include"
-               fi
+               AC_MSG_NOTICE([liboping CPPFLAGS: $LIBOPING_CPPFLAGS])
        fi
-       if test "x$withval" = "xno"
-       then
-               with_liboping="no"
-               with_own_liboping="no"
-       else if test "x$withval" = "xyes"
+       AC_CHECK_HEADERS(oping.h,
+       [with_liboping="yes"],
+       [with_liboping="no ('oping.h' not found)"])
+fi
+if test "x$with_liboping" = "xyes"
+then
+       if test "x$LIBOPING_LDFLAGS" != "x"
        then
-               with_liboping="yes"
-       fi; fi
-],
-[
-       with_liboping="yes"
-])
+               AC_MSG_NOTICE([liboping LDFLAGS: $LIBOPING_LDFLAGS])
+       fi
+       AC_CHECK_LIB(oping, ping_construct,
+       [with_liboping="yes"],
+       [with_liboping="no (symbol 'ping_construct' not found)"])
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
 
 if test "x$with_liboping" = "xyes"
 then
-       save_LDFLAGS="$LDFLAGS"
-       save_CPPFLAGS="$CPPFLAGS"
-       LDFLAGS="$liboping_LDFLAGS"
-       CPPFLAGS="$liboping_CPPFLAGS"
-       AC_CHECK_LIB(oping, ping_construct,
-       [
-               with_liboping="yes"
-               with_own_liboping="no"
-       ],
-       [
-               with_liboping="yes"
-               with_own_liboping="yes"
-               LDFLAGS="$save_LDFLAGS"
-               CPPFLAGS="$save_CPPFLAGS"
-       ])
+       BUILD_WITH_LIBOPING_CPPFLAGS="$LIBOPING_CPPFLAGS"
+       BUILD_WITH_LIBOPING_LDFLAGS="$LIBOPING_LDFLAGS"
+       AC_SUBST(BUILD_WITH_LIBOPING_CPPFLAGS)
+       AC_SUBST(BUILD_WITH_LIBOPING_LDFLAGS)
 fi
 AM_CONDITIONAL(BUILD_WITH_LIBOPING, test "x$with_liboping" = "xyes")
-AM_CONDITIONAL(BUILD_WITH_OWN_LIBOPING, test "x$with_own_liboping" = "xyes")
 # }}}
 
 # --with-oracle {{{
@@ -2022,6 +2328,10 @@ then
                [with_libpq="yes"],
                [with_libpq="no (symbol 'PQconnectdb' not found)"])
 
+       AC_CHECK_LIB(pq, PQserverVersion,
+               [with_libpq="yes"],
+               [with_libpq="no (symbol 'PQserverVersion' not found)"])
+
        LDFLAGS="$SAVE_LDFLAGS"
 fi
 if test "x$with_libpq" = "xyes"
@@ -2858,12 +3168,15 @@ plugin_multimeter="no"
 plugin_nfs="no"
 plugin_perl="no"
 plugin_processes="no"
+plugin_protocols="no"
 plugin_serial="no"
 plugin_swap="no"
 plugin_tape="no"
 plugin_tcpconns="no"
+plugin_ted="no"
 plugin_thermal="no"
 plugin_users="no"
+plugin_uptime="no"
 plugin_vmem="no"
 plugin_vserver="no"
 plugin_wireless="no"
@@ -2882,10 +3195,12 @@ then
        plugin_memory="yes"
        plugin_nfs="yes"
        plugin_processes="yes"
+       plugin_protocols="yes"
        plugin_serial="yes"
        plugin_swap="yes"
        plugin_tcpconns="yes"
        plugin_thermal="yes"
+       plugin_uptime="yes"
        plugin_vmem="yes"
        plugin_vserver="yes"
        plugin_wireless="yes"
@@ -2909,6 +3224,11 @@ then
 fi
 
 # Solaris
+if test "x$with_kstat" = "xyes"
+then
+       plugin_uptime="yes"
+fi
+
 if test "x$with_devinfo$with_kstat" = "xyesyes"
 then
        plugin_cpu="yes"
@@ -2954,6 +3274,7 @@ if test "x$have_sysctl" = "xyes"
 then
        plugin_cpu="yes"
        plugin_swap="yes"
+       plugin_uptime="yes"
 fi
 if test "x$have_sysctlbyname" = "xyes"
 then
@@ -3000,6 +3321,7 @@ fi
 if test "x$have_termios_h" = "xyes"
 then
        plugin_multimeter="yes"
+       plugin_ted="yes"
 fi
 
 if test "x$have_thread_info" = "xyes"
@@ -3057,12 +3379,14 @@ AC_PLUGIN([email],       [yes],                [EMail statistics])
 AC_PLUGIN([entropy],     [$plugin_entropy],    [Entropy statistics])
 AC_PLUGIN([exec],        [yes],                [Execution of external programs])
 AC_PLUGIN([filecount],   [yes],                [Count files in directories])
+AC_PLUGIN([gmond],       [$with_libganglia],   [Ganglia plugin])
 AC_PLUGIN([hddtemp],     [yes],                [Query hddtempd])
 AC_PLUGIN([interface],   [$plugin_interface],  [Interface traffic statistics])
 AC_PLUGIN([ipmi],        [$plugin_ipmi],       [IPMI sensor statistics])
 AC_PLUGIN([iptables],    [$with_libiptc],      [IPTables rule counters])
 AC_PLUGIN([ipvs],        [$plugin_ipvs],       [IPVS connection statistics])
 AC_PLUGIN([irq],         [$plugin_irq],        [IRQ statistics])
+AC_PLUGIN([java],        [$with_java],         [Embed the Java Virtual Machine])
 AC_PLUGIN([libvirt],     [$plugin_libvirt],    [Virtual machine statistics])
 AC_PLUGIN([load],        [$plugin_load],       [System load])
 AC_PLUGIN([logfile],     [yes],                [File logging plugin])
@@ -3070,6 +3394,7 @@ AC_PLUGIN([match_regex], [yes],                [The regex match])
 AC_PLUGIN([match_timediff], [yes],             [The timediff match])
 AC_PLUGIN([match_value], [yes],                [The value match])
 AC_PLUGIN([mbmon],       [yes],                [Query mbmond])
+AC_PLUGIN([memcachec],   [$with_libmemcached], [memcachec statistics])
 AC_PLUGIN([memcached],   [yes],                [memcached statistics])
 AC_PLUGIN([memory],      [$plugin_memory],     [Memory usage])
 AC_PLUGIN([multimeter],  [$plugin_multimeter], [Read multimeter values])
@@ -3090,6 +3415,7 @@ AC_PLUGIN([ping],        [$with_liboping],     [Network latency statistics])
 AC_PLUGIN([postgresql],  [$with_libpq],        [PostgreSQL database statistics])
 AC_PLUGIN([powerdns],    [yes],                [PowerDNS statistics])
 AC_PLUGIN([processes],   [$plugin_processes],  [Process statistics])
+AC_PLUGIN([protocols],   [$plugin_protocols],  [Protocol (IP, TCP, ...) statistics])
 AC_PLUGIN([rrdcached],   [$librrd_rrdc_update], [RRDTool output plugin])
 AC_PLUGIN([rrdtool],     [$with_librrd],       [RRDTool output plugin])
 AC_PLUGIN([sensors],     [$with_libsensors],   [lm_sensors statistics])
@@ -3097,6 +3423,7 @@ AC_PLUGIN([serial],      [$plugin_serial],     [serial port traffic])
 AC_PLUGIN([snmp],        [$with_libnetsnmp],   [SNMP querying plugin])
 AC_PLUGIN([swap],        [$plugin_swap],       [Swap usage statistics])
 AC_PLUGIN([syslog],      [$have_syslog],       [Syslog logging plugin])
+AC_PLUGIN([table],       [yes],                [Parsing of tabular data])
 AC_PLUGIN([tail],        [yes],                [Parsing of logfiles])
 AC_PLUGIN([tape],        [$plugin_tape],       [Tape drive statistics])
 AC_PLUGIN([target_notification], [yes],        [The notification target])
@@ -3104,8 +3431,10 @@ AC_PLUGIN([target_replace], [yes],             [The replace target])
 AC_PLUGIN([target_set],  [yes],                [The set target])
 AC_PLUGIN([tcpconns],    [$plugin_tcpconns],   [TCP connection statistics])
 AC_PLUGIN([teamspeak2],  [yes],                [TeamSpeak2 server statistics])
+AC_PLUGIN([ted],         [$plugin_ted],        [Read The Energy Detective values])
 AC_PLUGIN([thermal],     [$plugin_thermal],    [Linux ACPI thermal zone statistics])
 AC_PLUGIN([unixsock],    [yes],                [Unixsock communication plugin])
+AC_PLUGIN([uptime],      [$plugin_uptime],     [Uptime statistics])
 AC_PLUGIN([users],       [$plugin_users],      [User statistics])
 AC_PLUGIN([uuid],        [yes],                [UUID as hostname plugin])
 AC_PLUGIN([vmem],        [$plugin_vmem],       [Virtual memory statistics])
@@ -3113,6 +3442,86 @@ AC_PLUGIN([vserver],     [$plugin_vserver],    [Linux VServer statistics])
 AC_PLUGIN([wireless],    [$plugin_wireless],   [Wireless statistics])
 AC_PLUGIN([xmms],        [$with_libxmms],      [XMMS statistics])
 
+dnl Default configuration file
+# Load either syslog or logfile
+LOAD_PLUGIN_SYSLOG=""
+LOAD_PLUGIN_LOGFILE=""
+
+AC_MSG_CHECKING([which default log plugin to load])
+default_log_plugin="none"
+if test "x$enable_syslog" = "xyes"
+then
+       default_log_plugin="syslog"
+else
+       LOAD_PLUGIN_SYSLOG="##"
+fi
+
+if test "x$enable_logfile" = "xyes"
+then
+       if test "x$default_log_plugin" = "xnone"
+       then
+               default_log_plugin="logfile"
+       else
+               LOAD_PLUGIN_LOGFILE="#"
+       fi
+else
+       LOAD_PLUGIN_LOGFILE="##"
+fi
+AC_MSG_RESULT([$default_log_plugin])
+
+AC_SUBST(LOAD_PLUGIN_SYSLOG)
+AC_SUBST(LOAD_PLUGIN_LOGFILE)
+
+DEFAULT_LOG_LEVEL="info"
+if test "x$enable_debug" = "xyes"
+then
+       DEFAULT_LOG_LEVEL="debug"
+fi
+AC_SUBST(DEFAULT_LOG_LEVEL)
+
+# Load only one of rrdtool, network, csv in the default config.
+LOAD_PLUGIN_RRDTOOL=""
+LOAD_PLUGIN_NETWORK=""
+LOAD_PLUGIN_CSV=""
+
+AC_MSG_CHECKING([which default write plugin to load])
+default_write_plugin="none"
+if test "x$enable_rrdtool" = "xyes"
+then
+       default_write_plugin="rrdtool"
+else
+       LOAD_PLUGIN_RRDTOOL="##"
+fi
+
+if test "x$enable_network" = "xyes"
+then
+       if test "x$default_write_plugin" = "xnone"
+       then
+               default_write_plugin="network"
+       else
+               LOAD_PLUGIN_NETWORK="#"
+       fi
+else
+       LOAD_PLUGIN_NETWORK="##"
+fi
+
+if test "x$enable_csv" = "xyes"
+then
+       if test "x$default_write_plugin" = "xnone"
+       then
+               default_write_plugin="csv"
+       else
+               LOAD_PLUGIN_CSV="#"
+       fi
+else
+       LOAD_PLUGIN_CSV="##"
+fi
+AC_MSG_RESULT([$default_write_plugin])
+
+AC_SUBST(LOAD_PLUGIN_RRDTOOL)
+AC_SUBST(LOAD_PLUGIN_NETWORK)
+AC_SUBST(LOAD_PLUGIN_CSV)
+
 dnl ip_vs.h
 if test "x$ac_system" = "xLinux" \
        && test "x$have_net_ip_vs_h$have_ip_vs_h" = "xnono"
@@ -3167,7 +3576,7 @@ AC_SUBST(LCC_VERSION_STRING)
 
 AC_CONFIG_FILES(src/libcollectdclient/lcc_features.h)
 
-AC_OUTPUT(Makefile src/Makefile src/collectd.conf src/libiptc/Makefile src/libcollectdclient/Makefile src/libcollectdclient/libcollectdclient.pc src/liboconfig/Makefile src/liboping/Makefile bindings/Makefile)
+AC_OUTPUT(Makefile src/Makefile src/collectd.conf src/libiptc/Makefile src/libcollectdclient/Makefile src/libcollectdclient/libcollectdclient.pc src/liboconfig/Makefile bindings/Makefile)
 
 if test "x$with_librrd" = "xyes" \
        && test "x$librrd_threadsafe" != "xyes"
@@ -3175,12 +3584,6 @@ then
        with_librrd="yes (warning: librrd is not thread-safe)"
 fi
 
-if test "x$with_liboping" = "xyes" \
-       && test "x$with_own_liboping" = "xyes"
-then
-       with_liboping="yes (shipped version)"
-fi
-
 if test "x$with_libiptc" = "xyes" -a "x$with_own_libiptc" = "xyes"
 then
        with_libiptc="yes (shipped version)"
@@ -3208,6 +3611,7 @@ Configuration:
     libesmtp  . . . . . . $with_libesmtp
     libiokit  . . . . . . $with_libiokit
     libiptc . . . . . . . $with_libiptc
+    libjvm  . . . . . . . $with_java
     libkstat  . . . . . . $with_kstat
     libkvm  . . . . . . . $with_libkvm
     libmysql  . . . . . . $with_libmysql
@@ -3256,12 +3660,14 @@ Configuration:
     entropy . . . . . . . $enable_entropy
     exec  . . . . . . . . $enable_exec
     filecount . . . . . . $enable_filecount
+    gmond . . . . . . . . $enable_gmond
     hddtemp . . . . . . . $enable_hddtemp
     interface . . . . . . $enable_interface
     ipmi  . . . . . . . . $enable_ipmi
     iptables  . . . . . . $enable_iptables
     ipvs  . . . . . . . . $enable_ipvs
     irq . . . . . . . . . $enable_irq
+    java  . . . . . . . . $enable_java
     libvirt . . . . . . . $enable_libvirt
     load  . . . . . . . . $enable_load
     logfile . . . . . . . $enable_logfile
@@ -3269,6 +3675,7 @@ Configuration:
     match_timediff  . . . $enable_match_timediff
     match_value . . . . . $enable_match_value
     mbmon . . . . . . . . $enable_mbmon
+    memcachec . . . . . . $enable_memcachec
     memcached . . . . . . $enable_memcached
     memory  . . . . . . . $enable_memory
     multimeter  . . . . . $enable_multimeter
@@ -3289,6 +3696,7 @@ Configuration:
     postgresql  . . . . . $enable_postgresql
     powerdns  . . . . . . $enable_powerdns
     processes . . . . . . $enable_processes
+    protocols . . . . . . $enable_protocols
     rrdcached . . . . . . $enable_rrdcached
     rrdtool . . . . . . . $enable_rrdtool
     sensors . . . . . . . $enable_sensors
@@ -3296,6 +3704,7 @@ Configuration:
     snmp  . . . . . . . . $enable_snmp
     swap  . . . . . . . . $enable_swap
     syslog  . . . . . . . $enable_syslog
+    table . . . . . . . . $enable_table
     tail  . . . . . . . . $enable_tail
     tape  . . . . . . . . $enable_tape
     target_notification . $enable_target_notification
@@ -3303,8 +3712,10 @@ Configuration:
     target_set  . . . . . $enable_target_set
     tcpconns  . . . . . . $enable_tcpconns
     teamspeak2  . . . . . $enable_teamspeak2
+    ted . . . . . . . . . $enable_ted
     thermal . . . . . . . $enable_thermal
     unixsock  . . . . . . $enable_unixsock
+    uptime  . . . . . . . $enable_uptime
     users . . . . . . . . $enable_users
     uuid  . . . . . . . . $enable_uuid
     vmem  . . . . . . . . $enable_vmem
diff --git a/contrib/collectd-unixsock.py b/contrib/collectd-unixsock.py
new file mode 100644 (file)
index 0000000..2d7430d
--- /dev/null
@@ -0,0 +1,111 @@
+#-*- coding: ISO-8859-1 -*-
+# collect.py: the python collectd-unixsock module.
+#
+# Requires collectd to be configured with the unixsock plugin, like so:
+#
+# LoadPlugin unixsock
+# <Plugin unixsock>
+#   SocketFile "/var/run/collectd-unixsock"
+#   SocketPerms "0775"
+# </Plugin>
+#
+# Copyright (C) 2008 Clay Loveless <clay@killersoft.com>
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the author be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+import socket, string
+
+class Collect(object):
+
+    def __init__(self, path='/var/run/collectd-unixsock'):
+        self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self._path =  path
+        self._sock.connect(self._path)
+        
+    def list(self):
+        numvalues = self._cmd('LISTVAL')
+        lines = []
+        if numvalues:
+            lines = self._readlines(numvalues)
+        return lines
+        
+    def get(self, val, flush=True):
+        numvalues = self._cmd('GETVAL "' + val + '"')
+        lines = []
+        if numvalues:
+            lines = self._readlines(numvalues)
+        if flush:
+            self._cmd('FLUSH identifier="' + val + '"')
+        return lines
+            
+    def _cmd(self, c):
+        self._sock.send(c + "\n")
+        stat = string.split(self._readline())
+        status = int(stat[0])
+        if status:
+            return status
+        return False
+    
+    '''
+    _readline and _readlines methods borrowed from the _fileobject class 
+    in sockets.py, tweaked a little bit for use in the collectd context.
+    '''
+    def _readline(self):
+        data = ''
+        buf = []
+        recv = self._sock.recv
+        while data != "\n":
+            data = recv(1)
+            if not data:
+                break
+            if data != "\n":
+                buf.append(data)
+        return ''.join(buf)
+        
+    def _readlines(self, sizehint=0):
+        total = 0
+        list = []
+        while True:
+            line = self._readline()
+            if not line:
+                break
+            list.append(line)
+            total = len(list)
+            if sizehint and total >= sizehint:
+                break
+        return list
+    
+    def __del__(self):
+        self._sock.close()    
+
+
+
+if __name__ == '__main__':
+    
+    '''
+    Example usage:
+    Collect values from socket and dump to STDOUT.
+    '''
+    
+    c = Collect('/var/run/collectd-unixsock')
+    list = c.list()
+
+    for val in list:
+        stamp, key = string.split(val)
+        glines = c.get(key)
+        print stamp + ' ' + key + ' ' + ', '.join(glines)
+    
index 9497d8e..2511221 100644 (file)
@@ -277,7 +277,7 @@ GraphWidth 400
 <Type mysql_commands>
   Module GenericStacked
   DataSources value
-  RRDTitle "MySQL commands"
+  RRDTitle "MySQL commands ({plugin_instance})"
   RRDVerticalLabel "Invocations"
   RRDFormat "%6.2lf"
 
@@ -361,7 +361,7 @@ GraphWidth 400
 <Type mysql_handler>
   Module GenericStacked
   DataSources value
-  RRDTitle "MySQL handler"
+  RRDTitle "MySQL handler ({plugin_instance})"
   RRDVerticalLabel "Invocations"
   RRDFormat "%6.2lf"
   DSName commit commit
@@ -391,7 +391,7 @@ GraphWidth 400
   DataSources rx tx
   DSName rx RX
   DSName tx TX
-  RRDTitle "MySQL Traffic"
+  RRDTitle "MySQL Traffic ({plugin_instance})"
   RRDVerticalLabel "Bits per second"
   RRDFormat "%5.1lf%s"
   Scale 8
index f81fbbd..9b85144 100644 (file)
@@ -5,9 +5,6 @@ endif
 if BUILD_WITH_OWN_LIBOCONFIG
 SUBDIRS += liboconfig
 endif
-if BUILD_WITH_OWN_LIBOPING
-SUBDIRS += liboping
-endif
 
 if COMPILER_IS_GCC
 AM_CFLAGS = -Wall -Werror
@@ -35,6 +32,7 @@ collectd_SOURCES = collectd.c collectd.h \
                   utils_avltree.c utils_avltree.h \
                   utils_cache.c utils_cache.h \
                   utils_complain.c utils_complain.h \
+                  utils_heap.c utils_heap.h \
                   utils_ignorelist.c utils_ignorelist.h \
                   utils_llist.c utils_llist.h \
                   utils_parse_option.c utils_parse_option.h \
@@ -90,11 +88,11 @@ collectdmon_SOURCES = collectdmon.c
 collectdmon_CPPFLAGS = $(AM_CPPFLAGS)
 
 collectd_nagios_SOURCES = collectd-nagios.c
-collectd_nagios_LDFLAGS =
+collectd_nagios_LDADD =
 if BUILD_WITH_LIBSOCKET
-collectd_nagios_LDFLAGS += -lsocket
+collectd_nagios_LDADD += -lsocket
 endif
-collectd_nagios_LDADD = libcollectdclient/libcollectdclient.la
+collectd_nagios_LDADD += libcollectdclient/libcollectdclient.la
 collectd_nagios_DEPENDENCIES = libcollectdclient/libcollectdclient.la
 
 pkglib_LTLIBRARIES = 
@@ -117,8 +115,9 @@ if BUILD_PLUGIN_APCUPS
 pkglib_LTLIBRARIES += apcups.la
 apcups_la_SOURCES = apcups.c
 apcups_la_LDFLAGS = -module -avoid-version
+apcups_la_LIBADD =
 if BUILD_WITH_LIBSOCKET
-apcups_la_LDFLAGS += -lsocket
+apcups_la_LIBADD += -lsocket
 endif
 collectd_LDADD += "-dlopen" apcups.la
 collectd_DEPENDENCIES += apcups.la
@@ -127,7 +126,8 @@ endif
 if BUILD_PLUGIN_APPLE_SENSORS
 pkglib_LTLIBRARIES += apple_sensors.la
 apple_sensors_la_SOURCES = apple_sensors.c
-apple_sensors_la_LDFLAGS = -module -avoid-version -lIOKit
+apple_sensors_la_LDFLAGS = -module -avoid-version
+apple_sensors_la_LIBADD = -lIOKit
 collectd_LDADD += "-dlopen" apple_sensors.la
 collectd_DEPENDENCIES += apple_sensors.la
 endif
@@ -147,8 +147,9 @@ if BUILD_PLUGIN_BATTERY
 pkglib_LTLIBRARIES += battery.la
 battery_la_SOURCES = battery.c
 battery_la_LDFLAGS = -module -avoid-version
+battery_la_LIBADD =
 if BUILD_WITH_LIBIOKIT
-battery_la_LDFLAGS += -lIOKit
+battery_la_LIBADD += -lIOKit
 endif
 collectd_LDADD += "-dlopen" battery.la
 collectd_DEPENDENCIES += battery.la
@@ -172,10 +173,10 @@ cpu_la_CFLAGS = $(AM_CFLAGS)
 cpu_la_LDFLAGS = -module -avoid-version
 cpu_la_LIBADD = 
 if BUILD_WITH_LIBKSTAT
-cpu_la_LDFLAGS += -lkstat
+cpu_la_LIBADD += -lkstat
 endif
 if BUILD_WITH_LIBDEVINFO
-cpu_la_LDFLAGS += -ldevinfo
+cpu_la_LIBADD += -ldevinfo
 endif
 if BUILD_WITH_LIBSTATGRAB
 cpu_la_CFLAGS += $(BUILD_WITH_LIBSTATGRAB_CFLAGS)
@@ -241,13 +242,13 @@ disk_la_CFLAGS = $(AM_CFLAGS)
 disk_la_LDFLAGS = -module -avoid-version
 disk_la_LIBADD = 
 if BUILD_WITH_LIBKSTAT
-disk_la_LDFLAGS += -lkstat
+disk_la_LIBADD += -lkstat
 endif
 if BUILD_WITH_LIBDEVINFO
-disk_la_LDFLAGS += -ldevinfo
+disk_la_LIBADD += -ldevinfo
 endif
 if BUILD_WITH_LIBIOKIT
-disk_la_LDFLAGS += -lIOKit
+disk_la_LIBADD += -lIOKit
 endif
 if BUILD_WITH_LIBSTATGRAB
 disk_la_CFLAGS += $(BUILD_WITH_LIBSTATGRAB_CFLAGS)  
@@ -260,7 +261,8 @@ endif
 if BUILD_PLUGIN_DNS
 pkglib_LTLIBRARIES += dns.la
 dns_la_SOURCES = dns.c utils_dns.c utils_dns.h
-dns_la_LDFLAGS = -module -avoid-version -lpcap -lpthread
+dns_la_LDFLAGS = -module -avoid-version
+dns_la_LIBADD = -lpcap -lpthread
 collectd_LDADD += "-dlopen" dns.la
 collectd_DEPENDENCIES += dns.la
 endif
@@ -269,9 +271,7 @@ if BUILD_PLUGIN_EMAIL
 pkglib_LTLIBRARIES += email.la
 email_la_SOURCES = email.c
 email_la_LDFLAGS = -module -avoid-version
-if BUILD_WITH_LIBPTHREAD
-email_la_LDFLAGS += -lpthread
-endif
+email_la_LIBADD = -lpthread
 collectd_LDADD += "-dlopen" email.la
 collectd_DEPENDENCIES += email.la
 endif
@@ -290,9 +290,7 @@ exec_la_SOURCES = exec.c \
                  utils_cmd_putnotif.c utils_cmd_putnotif.h \
                  utils_cmd_putval.c utils_cmd_putval.h
 exec_la_LDFLAGS = -module -avoid-version
-if BUILD_WITH_LIBPTHREAD
-exec_la_LDFLAGS += -lpthread
-endif
+exec_la_LIBADD = -lpthread
 collectd_LDADD += "-dlopen" exec.la
 collectd_DEPENDENCIES += exec.la
 endif
@@ -305,12 +303,23 @@ collectd_LDADD += "-dlopen" filecount.la
 collectd_DEPENDENCIES += filecount.la
 endif
 
+if BUILD_PLUGIN_GMOND
+pkglib_LTLIBRARIES += gmond.la
+gmond_la_SOURCES = gmond.c
+gmond_la_CPPFLAGS = $(AM_CPPFLAGS) $(GANGLIA_CPPFLAGS)
+gmond_la_LDFLAGS = -module -avoid-version $(GANGLIA_LDFLAGS)
+gmond_la_LIBADD = $(GANGLIA_LIBS)
+collectd_LDADD += "-dlopen" gmond.la
+collectd_DEPENDENCIES += gmond.la
+endif
+
 if BUILD_PLUGIN_HDDTEMP
 pkglib_LTLIBRARIES += hddtemp.la
 hddtemp_la_SOURCES = hddtemp.c
 hddtemp_la_LDFLAGS = -module -avoid-version
+hddtemp_la_LIBADD =
 if BUILD_WITH_LIBSOCKET
-hddtemp_la_LDFLAGS += -lsocket
+hddtemp_la_LIBADD += -lsocket
 endif
 collectd_LDADD += "-dlopen" hddtemp.la
 collectd_DEPENDENCIES += hddtemp.la
@@ -329,10 +338,10 @@ interface_la_CFLAGS += $(BUILD_WITH_LIBSTATGRAB_CFLAGS)
 interface_la_LIBADD += $(BUILD_WITH_LIBSTATGRAB_LDFLAGS)
 else
 if BUILD_WITH_LIBKSTAT
-interface_la_LDFLAGS += -lkstat
+interface_la_LIBADD += -lkstat
 endif
 if BUILD_WITH_LIBDEVINFO
-interface_la_LDFLAGS += -ldevinfo
+interface_la_LIBADD += -ldevinfo
 endif # BUILD_WITH_LIBDEVINFO
 endif # !BUILD_WITH_LIBSTATGRAB
 endif # BUILD_PLUGIN_INTERFACE
@@ -345,7 +354,7 @@ if BUILD_WITH_OWN_LIBIPTC
 iptables_la_LIBADD  = libiptc/libiptc.la
 iptables_la_DEPENDENCIES = libiptc/libiptc.la
 else
-iptables_la_LDFLAGS += -liptc
+iptables_la_LIBADD = -liptc
 endif
 collectd_LDADD += "-dlopen" iptables.la
 collectd_DEPENDENCIES += iptables.la
@@ -378,6 +387,17 @@ collectd_LDADD += "-dlopen" irq.la
 collectd_DEPENDENCIES += irq.la
 endif
 
+if BUILD_PLUGIN_JAVA
+pkglib_LTLIBRARIES += java.la
+java_la_SOURCES = java.c
+java_la_CPPFLAGS = $(AM_CPPFLAGS) $(JAVA_CPPFLAGS)
+java_la_CFLAGS = $(AM_CFLAGS) $(JAVA_CFLAGS)
+java_la_LDFLAGS = -module -avoid-version $(JAVA_LDFLAGS)
+java_la_LIBADD = $(JAVA_LIBS)
+collectd_LDADD += "-dlopen" java.la
+collectd_DEPENDENCIES += java.la
+endif
+
 if BUILD_PLUGIN_LIBVIRT
 pkglib_LTLIBRARIES += libvirt.la
 libvirt_la_SOURCES = libvirt.c
@@ -439,20 +459,31 @@ if BUILD_PLUGIN_MBMON
 pkglib_LTLIBRARIES += mbmon.la
 mbmon_la_SOURCES = mbmon.c
 mbmon_la_LDFLAGS = -module -avoid-version
+mbmon_la_LIBADD =
 if BUILD_WITH_LIBSOCKET
-mbmon_la_LDFLAGS += -lsocket
+mbmon_la_LIBADD += -lsocket
 endif
 collectd_LDADD += "-dlopen" mbmon.la
 collectd_DEPENDENCIES += mbmon.la
 endif
 
+if BUILD_PLUGIN_MEMCACHEC
+pkglib_LTLIBRARIES += memcachec.la
+memcachec_la_SOURCES = memcachec.c
+memcachec_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBMEMCACHED_LDFLAGS)
+memcachec_la_CPPFLAGS = $(BUILD_WITH_LIBMEMCACHED_CPPFLAGS)
+memcachec_la_LIBADD = $(BUILD_WITH_LIBMEMCACHED_LIBS)
+collectd_LDADD += "-dlopen" memcachec.la
+collectd_DEPENDENCIES += memcachec.la
+endif
+
 if BUILD_PLUGIN_MEMCACHED
 pkglib_LTLIBRARIES += memcached.la
 memcached_la_SOURCES = memcached.c
 memcached_la_LDFLAGS = -module -avoid-version
 memcached_la_LIBADD =
 if BUILD_WITH_LIBSOCKET
-memcached_la_LDFLAGS += -lsocket
+memcached_la_LIBADD += -lsocket
 endif
 collectd_LDADD += "-dlopen" memcached.la
 collectd_DEPENDENCIES += memcached.la
@@ -513,12 +544,16 @@ endif
 if BUILD_PLUGIN_NETWORK
 pkglib_LTLIBRARIES += network.la
 network_la_SOURCES = network.c network.h
+network_la_CPPFLAGS = $(AM_CPPFLAGS)
 network_la_LDFLAGS = -module -avoid-version
+network_la_LIBADD = -lpthread
 if BUILD_WITH_LIBSOCKET
-network_la_LDFLAGS += -lsocket
+network_la_LIBADD += -lsocket
 endif
-if BUILD_WITH_LIBPTHREAD
-network_la_LDFLAGS += -lpthread
+if BUILD_WITH_LIBGCRYPT
+network_la_CPPFLAGS += $(GCRYPT_CPPFLAGS)
+network_la_LDFLAGS += $(GCRYPT_LDFLAGS)
+network_la_LIBADD += $(GCRYPT_LIBS)
 endif
 collectd_LDADD += "-dlopen" network.la
 collectd_DEPENDENCIES += network.la
@@ -550,7 +585,8 @@ if BUILD_PLUGIN_NOTIFY_DESKTOP
 pkglib_LTLIBRARIES += notify_desktop.la
 notify_desktop_la_SOURCES = notify_desktop.c
 notify_desktop_la_CFLAGS = $(AM_CFLAGS) $(LIBNOTIFY_CFLAGS)
-notify_desktop_la_LDFLAGS = -module -avoid-version $(LIBNOTIFY_LIBS)
+notify_desktop_la_LDFLAGS = -module -avoid-version
+notify_desktop_la_LIBADD = $(LIBNOTIFY_LIBS)
 collectd_LDADD += "-dlopen" notify_desktop.la
 collectd_DEPENDENCIES += notify_desktop.la
 endif
@@ -558,7 +594,8 @@ endif
 if BUILD_PLUGIN_NOTIFY_EMAIL
 pkglib_LTLIBRARIES += notify_email.la
 notify_email_la_SOURCES = notify_email.c
-notify_email_la_LDFLAGS = -L/usr/local/lib -lesmtp -lssl -lcrypto -pthread -module -avoid-version
+notify_email_la_LDFLAGS = -module -avoid-version
+notify_email_la_LIBADD = -lesmtp -lssl -lcrypto -lpthread -ldl
 collectd_LDADD += "-dlopen" notify_email.la
 collectd_DEPENDENCIES += notify_email.la
 endif
@@ -567,8 +604,9 @@ if BUILD_PLUGIN_NTPD
 pkglib_LTLIBRARIES += ntpd.la
 ntpd_la_SOURCES = ntpd.c
 ntpd_la_LDFLAGS = -module -avoid-version
+ntpd_la_LIBADD =
 if BUILD_WITH_LIBSOCKET
-ntpd_la_LDFLAGS += -lsocket
+ntpd_la_LIBADD += -lsocket
 endif
 collectd_LDADD += "-dlopen" ntpd.la
 collectd_DEPENDENCIES += ntpd.la
@@ -578,7 +616,8 @@ if BUILD_PLUGIN_NUT
 pkglib_LTLIBRARIES += nut.la
 nut_la_SOURCES = nut.c
 nut_la_CFLAGS = $(AM_CFLAGS) $(BUILD_WITH_LIBUPSCLIENT_CFLAGS)
-nut_la_LDFLAGS = -module -avoid-version -lpthread $(BUILD_WITH_LIBUPSCLIENT_LIBS)
+nut_la_LDFLAGS = -module -avoid-version
+nut_la_LIBADD = -lpthread $(BUILD_WITH_LIBUPSCLIENT_LIBS)
 collectd_LDADD += "-dlopen" nut.la
 collectd_DEPENDENCIES += nut.la
 endif
@@ -638,13 +677,9 @@ endif
 if BUILD_PLUGIN_PING
 pkglib_LTLIBRARIES += ping.la
 ping_la_SOURCES = ping.c
-ping_la_LDFLAGS = -module -avoid-version
-if BUILD_WITH_OWN_LIBOPING
-ping_la_LIBADD  = liboping/liboping.la
-ping_la_DEPENDENCIES = liboping/liboping.la
-else
-ping_la_LDFLAGS += -loping
-endif
+ping_la_CPPFLAGS = $(AM_CPPFLAGS) $(BUILD_WITH_LIBOPING_CPPFLAGS)
+ping_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBOPING_LDFLAGS)
+ping_la_LIBADD = -loping
 collectd_LDADD += "-dlopen" ping.la
 collectd_DEPENDENCIES += ping.la
 endif
@@ -655,7 +690,8 @@ postgresql_la_SOURCES = postgresql.c \
                 utils_db_query.c utils_db_query.h
 postgresql_la_CPPFLAGS = $(AM_CPPFLAGS) $(BUILD_WITH_LIBPQ_CPPFLAGS)
 postgresql_la_LDFLAGS = -module -avoid-version \
-               $(BUILD_WITH_LIBPQ_LDFLAGS) -lpq
+               $(BUILD_WITH_LIBPQ_LDFLAGS)
+postgresql_la_LIBADD = -lpq
 collectd_LDADD += "-dlopen" postgresql.la
 collectd_DEPENDENCIES += postgresql.la
 endif
@@ -680,6 +716,14 @@ processes_la_LIBADD += -lkvm
 endif
 endif
 
+if BUILD_PLUGIN_PROTOCOLS
+pkglib_LTLIBRARIES += protocols.la
+protocols_la_SOURCES = protocols.c
+protocols_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" protocols.la
+collectd_DEPENDENCIES += protocols.la
+endif
+
 if BUILD_PLUGIN_RRDCACHED
 pkglib_LTLIBRARIES += rrdcached.la
 rrdcached_la_SOURCES = rrdcached.c utils_rrdcreate.c utils_rrdcreate.h
@@ -704,8 +748,8 @@ if BUILD_PLUGIN_SENSORS
 pkglib_LTLIBRARIES += sensors.la
 sensors_la_SOURCES = sensors.c
 sensors_la_CFLAGS = $(AM_CFLAGS) $(BUILD_WITH_LIBSENSORS_CFLAGS)
-sensors_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBSENSORS_LDFLAGS)
-sensors_la_LIBADD = -lsensors
+sensors_la_LDFLAGS = -module -avoid-version
+sensors_la_LIBADD = $(BUILD_WITH_LIBSENSORS_LDFLAGS)
 collectd_LDADD += "-dlopen" sensors.la
 collectd_DEPENDENCIES += sensors.la
 endif
@@ -766,6 +810,14 @@ collectd_LDADD += "-dlopen" syslog.la
 collectd_DEPENDENCIES += syslog.la
 endif
 
+if BUILD_PLUGIN_TABLE
+pkglib_LTLIBRARIES += table.la
+table_la_SOURCES = table.c
+table_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" table.la
+collectd_DEPENDENCIES += table.la
+endif
+
 if BUILD_PLUGIN_TAIL
 pkglib_LTLIBRARIES += tail.la
 tail_la_SOURCES = tail.c
@@ -777,7 +829,8 @@ endif
 if BUILD_PLUGIN_TAPE
 pkglib_LTLIBRARIES += tape.la
 tape_la_SOURCES = tape.c
-tape_la_LDFLAGS = -module -avoid-version -lkstat -ldevinfo
+tape_la_LDFLAGS = -module -avoid-version
+tape_la_LIBADD = -lkstat -ldevinfo
 collectd_LDADD += "-dlopen" tape.la
 collectd_DEPENDENCIES += tape.la
 endif
@@ -826,6 +879,14 @@ collectd_LDADD += "-dlopen" teamspeak2.la
 collectd_DEPENDENCIES += teamspeak2.la
 endif
 
+if BUILD_PLUGIN_TED
+pkglib_LTLIBRARIES += ted.la
+ted_la_SOURCES = ted.c
+ted_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" ted.la
+collectd_DEPENDENCIES += ted.la
+endif
+
 if BUILD_PLUGIN_THERMAL
 pkglib_LTLIBRARIES += thermal.la
 thermal_la_SOURCES = thermal.c
@@ -842,11 +903,25 @@ unixsock_la_SOURCES = unixsock.c \
                      utils_cmd_listval.h utils_cmd_listval.c \
                      utils_cmd_putval.h utils_cmd_putval.c \
                      utils_cmd_putnotif.h utils_cmd_putnotif.c
-unixsock_la_LDFLAGS = -module -avoid-version -lpthread
+unixsock_la_LDFLAGS = -module -avoid-version
+unixsock_la_LIBADD = -lpthread
 collectd_LDADD += "-dlopen" unixsock.la
 collectd_DEPENDENCIES += unixsock.la
 endif
 
+if BUILD_PLUGIN_UPTIME
+pkglib_LTLIBRARIES += uptime.la
+uptime_la_SOURCES = uptime.c
+uptime_la_CFLAGS = $(AM_CFLAGS)
+uptime_la_LDFLAGS = -module -avoid-version
+uptime_la_LIBADD =
+if BUILD_WITH_LIBKSTAT
+uptime_la_LIBADD += -lkstat
+endif
+collectd_LDADD += "-dlopen" uptime.la
+collectd_DEPENDENCIES += uptime.la
+endif
+
 if BUILD_PLUGIN_USERS
 pkglib_LTLIBRARIES += users.la
 users_la_SOURCES = users.c
@@ -899,25 +974,41 @@ if BUILD_PLUGIN_XMMS
 pkglib_LTLIBRARIES += xmms.la
 xmms_la_SOURCES = xmms.c
 xmms_la_CFLAGS = $(AM_CFLAGS) $(BUILD_WITH_LIBXMMS_CFLAGS)
-xmms_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBXMMS_LIBS)
+xmms_la_LDFLAGS = -module -avoid-version
+xmms_la_LIBADD = $(BUILD_WITH_LIBXMMS_LIBS)
 collectd_LDADD += "-dlopen" xmms.la
 collectd_DEPENDENCIES += xmms.la
 endif
 
 
-dist_man_MANS = collectd.1 collectd-nagios.1 collectd.conf.5 \
-               collectd-email.5 collectd-exec.5 collectd-perl.5 \
-               collectd-snmp.5 collectd-unixsock.5 collectdmon.1 \
+dist_man_MANS = collectd.1 \
+               collectd.conf.5 \
+               collectd-email.5 \
+               collectd-exec.5 \
+               collectd-java.5
+               collectdmon.1 \
+               collectd-nagios.1 \
+               collectd-perl.5 \
+               collectd-snmp.5 \
+               collectd-unixsock.5 \
                types.db.5
 
 #collectd_1_SOURCES = collectd.pod
 
 EXTRA_DIST = types.db
 
-EXTRA_DIST += collectd-email.pod collectd-exec.pod collectd-nagios.pod \
-       collectd-perl.pod collectd-snmp.pod collectd-unixsock.pod \
-       collectd.conf.pod collectd.pod collectdmon.pod types.db.pod \
-       postgresql_default.conf
+EXTRA_DIST +=   collectd.conf.pod \
+               collectd-email.pod \
+               collectd-exec.pod \
+               collectd-java.pod \
+               collectdmon.pod \
+               collectd-nagios.pod \
+               collectd-perl.pod \
+               collectd.pod \
+               collectd-snmp.pod \
+               collectd-unixsock.pod \
+               postgresql_default.conf \
+               types.db.pod
 
 .pod.1:
        pod2man --release=$(VERSION) --center=$(PACKAGE) $< \
index c0b1832..783d2b0 100644 (file)
@@ -239,19 +239,6 @@ static int memsummary_translation_table_length =
   STATIC_ARRAY_SIZE (memsummary_translation_table);
 /* }}} */
 
-static void remove_special (char *buffer, size_t buffer_size) /* {{{ */
-{
-  size_t i;
-
-  for (i = 0; i < buffer_size; i++)
-  {
-    if (buffer[i] == 0)
-      return;
-    if ((!isalnum ((int) buffer[i])) && (buffer[i] != '-'))
-      buffer[i] = '_';
-  }
-} /* }}} void remove_special */
-
 static void submit (time_t ts, const char *plugin_instance, /* {{{ */
     const char *type, const char *type_instance, value_t value)
 {
@@ -268,13 +255,13 @@ static void submit (time_t ts, const char *plugin_instance, /* {{{ */
   if (plugin_instance) {
     sstrncpy(vl.plugin_instance, plugin_instance,
         sizeof(vl.plugin_instance));
-    remove_special (vl.plugin_instance, sizeof (vl.plugin_instance));
+    replace_special (vl.plugin_instance, sizeof (vl.plugin_instance));
   }
   sstrncpy(vl.type, type, sizeof(vl.type));
   if (type_instance) {
     sstrncpy(vl.type_instance, type_instance,
         sizeof(vl.type_instance));
-    remove_special (vl.plugin_instance, sizeof (vl.plugin_instance));
+    replace_special (vl.plugin_instance, sizeof (vl.plugin_instance));
   }
   plugin_dispatch_values(&vl);
 } /* }}} void submit */
diff --git a/src/collectd-java.pod b/src/collectd-java.pod
new file mode 100644 (file)
index 0000000..f441c82
--- /dev/null
@@ -0,0 +1,555 @@
+=head1 NAME
+
+collectd-java - Documentation of collectd's "java plugin"
+
+=head1 SYNOPSIS
+
+ LoadPlugin "java"
+ <Plugin "java">
+   JVMArg "-verbose:jni"
+   JVMArg "-Djava.class.path=/opt/collectd/lib/collectd/bindings/java"
+   
+   LoadPlugin "org.collectd.java.Foobar"
+   <Plugin "org.collectd.java.Foobar">
+     # To be parsed by the plugin
+   </Plugin>
+ </Plugin>
+
+=head1 DESCRIPTION
+
+The I<Java> plugin embeds a I<Java Virtual Machine> (JVM) into I<collectd> and
+provides a Java interface to part of collectd's API. This makes it possible to
+write additions to the daemon in Java.
+
+This plugin is similar in nature to, but shares no code with, the I<Perl>
+plugin by Sebastian Harl, see L<collectd-perl(5)> for details.
+
+=head1 CONFIGURATION
+
+A short outline of this plugin's configuration can be seen in L<"SYNOPSIS">
+above. For a complete list of all configuration options and their semantics
+please read L<collectd.conf(5)/Plugin C<java>>.
+
+=head1 OVERVIEW
+
+When writing additions for collectd in Java, the underlying C base is mostly
+hidden from you. All complex data types are converted to their Java counterparts
+before they're passed to your functions. These Java classes reside in the
+I<org.collectd.api> namespace.
+
+The I<Java> plugin will create one object of each class configured with the
+B<LoadPlugin> option. The constructor of this class can then register "callback
+methods", i.E<nbsp>e. methods that will be called by the daemon when
+appropriate.
+
+The available classes are:
+
+=over 4
+
+=item B<org.collectd.api.Collectd>
+
+All API functions exported to Java are implemented as static functions of this
+class. See L<"EXPORTED API FUNCTIONS"> below.
+
+=item B<org.collectd.api.OConfigValue>
+
+Corresponds to C<oconfig_value_t>, defined in F<src/liboconfig/oconfig.h>.
+
+=item B<org.collectd.api.OConfigItem>
+
+Corresponds to C<oconfig_item_t>, defined in F<src/liboconfig/oconfig.h>.
+
+=item B<org.collectd.api.DataSource>
+
+Corresponds to C<data_source_t>, defined in F<src/plugin.h>.
+
+=item B<org.collectd.api.DataSet>
+
+Corresponds to C<data_set_t>, defined in F<src/plugin.h>.
+
+=item B<org.collectd.api.ValueList>
+
+Corresponds to C<value_list_t>, defined in F<src/plugin.h>.
+
+=item B<org.collectd.api.Notification>
+
+Corresponds to C<notification_t>, defined in F<src/plugin.h>.
+
+=back
+
+In the remainder of this document, we'll use the short form of these names, for
+example B<ValueList>. In order to be able to use these abbreviated names, you
+need to B<import> the classes.
+
+=head1 EXPORTED API FUNCTIONS
+
+All collectd API functions that are available to Java plugins are implemented
+as I<publicE<nbsp>static> functions of the B<Collectd> class. This makes
+calling these functions pretty straight forward. For example, to send an error
+message to the daemon, you'd do something like this:
+
+  Collectd.logError ("That wasn't chicken!");
+
+The following are the currently exported functions.
+
+=head2 registerConfig
+
+Signature: I<int> B<registerConfig> (I<String> name,
+I<CollectdConfigInterface> object);
+
+Registers the B<config> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"config callback"> below.
+
+=head2 registerInit
+
+Signature: I<int> B<registerInit> (I<String> name,
+I<CollectdInitInterface> object);
+
+Registers the B<init> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"init callback"> below.
+
+=head2 registerRead
+
+Signature: I<int> B<registerRead> (I<String> name,
+I<CollectdReadInterface> object)
+
+Registers the B<read> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"read callback"> below.
+
+=head2 registerWrite
+
+Signature: I<int> B<registerWrite> (I<String> name,
+I<CollectdWriteInterface> object)
+
+Registers the B<write> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"write callback"> below.
+
+=head2 registerFlush
+
+Signature: I<int> B<registerFlush> (I<String> name,
+I<CollectdFlushInterface> object)
+
+Registers the B<flush> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"flush callback"> below.
+
+=head2 registerShutdown
+
+Signature: I<int> B<registerShutdown> (I<String> name,
+I<CollectdShutdownInterface> object);
+
+Registers the B<shutdown> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"shutdown callback"> below.
+
+=head2 registerLog
+
+Signature: I<int> B<registerLog> (I<String> name,
+I<CollectdLogInterface> object);
+
+Registers the B<log> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"log callback"> below.
+
+=head2 registerNotification
+
+Signature: I<int> B<registerNotification> (I<String> name,
+I<CollectdNotificationInterface> object);
+
+Registers the B<notification> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"notification callback"> below.
+
+=head2 registerMatch
+
+Signature: I<int> B<registerMatch> (I<String> name,
+I<CollectdMatchFactoryInterface> object);
+
+Registers the B<createMatch> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"match callback"> below.
+
+=head2 registerTarget
+
+Signature: I<int> B<registerTarget> (I<String> name,
+I<CollectdTargetFactoryInterface> object);
+
+Registers the B<createTarget> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"target callback"> below.
+
+=head2 dispatchValues
+
+Signature: I<int> B<dispatchValues> (I<ValueList>)
+
+Passes the values represented by the B<ValueList> object to the
+C<plugin_dispatch_values> function of the daemon. The "data set" (or list of
+"data sources") associated with the object are ignored, because
+C<plugin_dispatch_values> will automatically lookup the required data set. It
+is therefore absolutely okay to leave this blank.
+
+Returns zero upon success or non-zero upon failure.
+
+=head2 getDS
+
+Signature: I<DataSet> B<getDS> (I<String>)
+
+Returns the appropriate I<type> or B<null> if the type is not defined.
+
+=head2 logError
+
+Signature: I<void> B<logError> (I<String>)
+
+Sends a log message with severity B<ERROR> to the daemon.
+
+=head2 logWarning
+
+Signature: I<void> B<logWarning> (I<String>)
+
+Sends a log message with severity B<WARNING> to the daemon.
+
+=head2 logNotice
+
+Signature: I<void> B<logNotice> (I<String>)
+
+Sends a log message with severity B<NOTICE> to the daemon.
+
+=head2 logInfo
+
+Signature: I<void> B<logInfo> (I<String>)
+
+Sends a log message with severity B<INFO> to the daemon.
+
+=head2 logDebug
+
+Signature: I<void> B<logDebug> (I<String>)
+
+Sends a log message with severity B<DEBUG> to the daemon.
+
+=head1 REGISTERING CALLBACKS
+
+When starting up, collectd creates an object of each configured class. The
+constructor of this class should then register "callbacks" with the daemon,
+using the appropriate static functions in B<Collectd>,
+see L<"EXPORTED API FUNCTIONS"> above. To register a callback, the object being
+passed to one of the register functions must implement an appropriate
+interface, which are all in the B<org.collectd.api> namespace.
+
+A constructor may register any number of these callbacks, even none. An object
+without callback methods is never actively called by collectd, but may still
+call the exported API functions. One could, for example, start a new thread in
+the constructor and dispatch (submit to the daemon) values asynchronously,
+whenever one is available.
+
+Each callback method is now explained in more detail:
+
+=head2 config callback
+
+Interface: B<org.collectd.api.CollectdConfigInterface>
+
+Signature: I<int> B<config> (I<OConfigItem> ci)
+
+This method is passed a B<OConfigItem> object, if both, method and
+configuration, are available. B<OConfigItem> is the root of a tree representing
+the configuration for this plugin. The root itself is the representation of the
+B<E<lt>PluginE<nbsp>/E<gt>> block, so in next to all cases the children of the
+root are the first interesting objects.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and the plugin will be disabled entirely.
+
+See L<"registerConfig"> above.
+
+=head2 init callback
+
+Interface: B<org.collectd.api.CollectdInitInterface>
+
+Signature: I<int> B<init> ()
+
+This method is called after the configuration has been handled. It is
+supposed to set up the plugin. e.E<nbsp>g. start threads, open connections, or
+check if can do anything useful at all.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and the plugin will be disabled entirely.
+
+See L<"registerInit"> above.
+
+=head2 read callback
+
+Interface: B<org.collectd.api.CollectdReadInterface>
+
+Signature: I<int> B<read> ()
+
+This method is called periodically and is supposed to gather statistics in
+whatever fashion. These statistics are represented as a B<ValueList> object and
+sent to the daemon using L<dispatchValues|"dispatchValues">.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+Currently, returning non-zero does not have any other effects. In particular,
+Java "read"-methods are not suspended for increasing intervals like C
+"read"-functions.
+
+See L<"registerRead"> above.
+
+=head2 write callback
+
+Interface: B<org.collectd.api.CollectdWriteInterface>
+
+Signature: I<int> B<write> (I<ValueList> vl)
+
+This method is called whenever a value is dispatched to the daemon. The
+corresponding C "write"-functions are passed a C<data_set_t>, so they can
+decide which values are absolute values (gauge) and which are counter values.
+To get the corresponding C<ListE<lt>DataSourceE<gt>>, call the B<getDataSource>
+method of the B<ValueList> object.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+
+See L<"registerWrite"> above.
+
+=head2 flush callback
+
+Interface: B<org.collectd.api.CollectdFlushInterface>
+
+Signature: I<int> B<flush> (I<int> timeout, I<String> identifier)
+
+This method is called when the daemon received a flush command. This can either
+be done using the C<USR1> signal (see L<collectd(1)>) or using the I<unixsock>
+plugin (see L<collectd-unixsock(5)>).
+
+If I<timeout> is greater than zero, only values older than this number of
+seconds should be flushed. To signal that all values should be flushed
+regardless of age, this argument is set to a negative number.
+
+The I<identifier> specifies which value should be flushed. If it is not
+possible to flush one specific value, flush all values. To signal that all
+values should be flushed, this argument is set to I<null>.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+
+See L<"registerFlush"> above.
+
+=head2 shutdown callback
+
+Interface: B<org.collectd.api.CollectdShutdownInterface>
+
+Signature: I<int> B<shutdown> ()
+
+This method is called when the daemon is shutting down. You should not rely on
+the destructor to clean up behind the object but use this function instead.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+
+See L<"registerShutdown"> above.
+
+=head2 log callback
+
+Interface: B<org.collectd.api.CollectdLogInterface>
+
+Signature: I<void> B<log> (I<int> severity, I<String> message)
+
+This callback can be used to receive log messages from the daemon.
+
+The argument I<severity> is one of:
+
+=over 4
+
+=item *
+
+org.collectd.api.Collectd.LOG_ERR
+
+=item *
+
+org.collectd.api.Collectd.LOG_WARNING
+
+=item *
+
+org.collectd.api.Collectd.LOG_NOTICE
+
+=item *
+
+org.collectd.api.Collectd.LOG_INFO
+
+=item *
+
+org.collectd.api.Collectd.LOG_DEBUG
+
+=back
+
+The function does not return any value.
+
+See L<"registerLog"> above.
+
+=head2 notification callback
+
+Interface: B<org.collectd.api.CollectdNotificationInterface>
+
+Signature: I<int> B<notification> (I<Notification> n)
+
+This callback can be used to receive notifications from the daemon.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+
+See L<"registerNotification"> above.
+
+=head2 match callback
+
+The match (and target, see L<"target callback"> below) callbacks work a bit
+different from the other callbacks above: You don't register a match callback
+with the daemon directly, but you register a function which, when called,
+creates an appropriate object. The object creating the "match" objects is
+called "match factory".
+
+See L<"registerMatch"> above.
+
+=head3 Factory object
+
+Interface: B<org.collectd.api.CollectdMatchFactoryInterface>
+
+Signature: I<CollectdMatchInterface> B<createMatch>
+(I<OConfigItem> ci);
+
+Called by the daemon to create "match" objects.
+
+Returns: A new object which implements the B<CollectdMatchInterface> interface.
+
+=head3 Match object
+
+Interface: B<org.collectd.api.CollectdMatchInterface>
+
+Signature: I<int> B<match> (I<DataSet> ds, I<ValueList> vl);
+
+Called when processing a chain to determine whether or not a I<ValueList>
+matches. How values are matches is up to the implementing class.
+
+Has to return one of:
+
+=over 4
+
+=item *
+
+B<Collectd.FC_MATCH_NO_MATCH>
+
+=item *
+
+B<Collectd.FC_MATCH_MATCHES>
+
+=back
+
+=head2 target callback
+
+The target (and match, see L<"match callback"> above) callbacks work a bit
+different from the other callbacks above: You don't register a target callback
+with the daemon directly, but you register a function which, when called,
+creates an appropriate object. The object creating the "target" objects is
+called "target factory".
+
+See L<"registerTarget"> above.
+
+=head3 Factory object
+
+Interface: B<org.collectd.api.CollectdTargetFactoryInterface>
+
+Signature: I<CollectdTargetInterface> B<createTarget>
+(I<OConfigItem> ci);
+
+Called by the daemon to create "target" objects.
+
+Returns: A new object which implements the B<CollectdTargetInterface>
+interface.
+
+=head3 Target object
+
+Interface: B<org.collectd.api.CollectdTargetInterface>
+
+Signature: I<int> B<invoke> (I<DataSet> ds, I<ValueList> vl);
+
+Called when processing a chain to perform some action. The action performed is
+up to the implementing class.
+
+Has to return one of:
+
+=over 4
+
+=item *
+
+B<Collectd.FC_TARGET_CONTINUE>
+
+=item *
+
+B<Collectd.FC_TARGET_STOP>
+
+=item *
+
+B<Collectd.FC_TARGET_RETURN>
+
+=back
+
+=head1 EXAMPLE
+
+This short example demonstrates how to register a read callback with the
+daemon:
+
+  import org.collectd.api.Collectd;
+  import org.collectd.api.ValueList;
+  
+  import org.collectd.api.CollectdReadInterface;
+  
+  public class Foobar implements CollectdReadInterface
+  {
+    public Foobar ()
+    {
+      Collectd.registerRead ("Foobar", this);
+    }
+    
+    public int read ()
+    {
+      ValueList vl;
+      
+      /* Do something... */
+      
+      Collectd.dispatchValues (vl);
+    }
+  }
+
+=head1 SEE ALSO
+
+L<collectd(1)>,
+L<collectd.conf(5)>,
+L<collectd-perl(5)>,
+L<types.db(5)>
+
+=head1 AUTHOR
+
+Florian Forster E<lt>octoE<nbsp>atE<nbsp>verplant.orgE<gt>
+
index acb8abd..0f48ba5 100644 (file)
@@ -297,6 +297,10 @@ there is a large number of predefined data-sets available in the B<types.db>
 file which are automatically registered with collectd - see L<types.db(5)> for
 a description of the format of this file.
 
+B<Note>: Using B<plugin_register> to register a data-set is deprecated. Add
+the new type to a custom L<types.db(5)> file instead. This functionality might
+be removed in a future version of collectd.
+
 If the I<type> argument is any of the other types (B<TYPE_INIT>, B<TYPE_READ>,
 ...) then I<data> is expected to be a function name. If the name is not
 prefixed with the plugin's package name collectd will add it automatically.
index d0acc06..f34113d 100644 (file)
@@ -221,16 +221,11 @@ before using it here.
 
 =item B<Interval> I<Seconds>
 
-Collect data from this host every I<Seconds> seconds. This value needs to be a
-multiple of the global B<Interval> setting and, if it is not, will be rounded
-B<down> to one and a warning is logged in this case. So if your global
-B<Interval> is set to I<10> and you configure I<25> here, it's rounded down to
-I<20>. By default the global B<Interval> setting will be used.
-
-This option is meant for devices with not much CPU power, e.E<nbsp>g. network
-equipment such as switches, embedded devices, rack monitoring systems and so
-on. Since the B<Step> of generated RRD files depends on this setting it's
-wise to select a reasonable value once and never change it.
+Collect data from this host every I<Seconds> seconds. This option is meant for
+devices with not much CPU power, e.E<nbsp>g. network equipment such as
+switches, embedded devices, rack monitoring systems and so on. Since the
+B<Step> of generated RRD files depends on this setting it's wise to select a
+reasonable value once and never change it.
 
 =back
 
index 8a05912..6783a15 100644 (file)
@@ -4,6 +4,12 @@
 # http://collectd.org/
 #
 
+##############################################################################
+# Global                                                                     #
+#----------------------------------------------------------------------------#
+# Global settings for the daemon.                                            #
+##############################################################################
+
 #Hostname    "localhost"
 FQDNLookup   true
 #BaseDir     "@prefix@/var/lib/@PACKAGE_NAME@"
@@ -13,84 +19,113 @@ FQDNLookup   true
 #Interval     10
 #ReadThreads  5
 
-@BUILD_PLUGIN_LOGFILE_TRUE@LoadPlugin logfile
-@BUILD_PLUGIN_SYSLOG_TRUE@LoadPlugin syslog
+##############################################################################
+# Logging                                                                    #
+#----------------------------------------------------------------------------#
+# Plugins which provide logging functions should be loaded first, so log     #
+# messages generated when loading or configuring other plugins can be        #
+# accessed.                                                                  #
+##############################################################################
+
+@LOAD_PLUGIN_SYSLOG@LoadPlugin syslog
+@LOAD_PLUGIN_LOGFILE@LoadPlugin logfile
 
 #<Plugin logfile>
-#      LogLevel info
+#      LogLevel @DEFAULT_LOG_LEVEL@
 #      File STDOUT
 #      Timestamp true
 #</Plugin>
 
 #<Plugin syslog>
-#      LogLevel info
-#</Plugin>
-
-@BUILD_PLUGIN_APACHE_TRUE@LoadPlugin apache
-@BUILD_PLUGIN_APCUPS_TRUE@LoadPlugin apcups
-@BUILD_PLUGIN_APPLE_SENSORS_TRUE@LoadPlugin apple_sensors
-@BUILD_PLUGIN_ASCENT_TRUE@LoadPlugin ascent
-@BUILD_PLUGIN_BATTERY_TRUE@LoadPlugin battery
-@BUILD_PLUGIN_BIND_TRUE@LoadPlugin bind
-@BUILD_PLUGIN_CPU_TRUE@LoadPlugin cpu
-@BUILD_PLUGIN_CPUFREQ_TRUE@LoadPlugin cpufreq
-@BUILD_PLUGIN_CSV_TRUE@LoadPlugin csv
-@BUILD_PLUGIN_CURL_TRUE@LoadPlugin curl
-@BUILD_PLUGIN_DBI_TRUE@LoadPlugin dbi
-@BUILD_PLUGIN_DF_TRUE@LoadPlugin df
-@BUILD_PLUGIN_DISK_TRUE@LoadPlugin disk
-@BUILD_PLUGIN_DNS_TRUE@LoadPlugin dns
-@BUILD_PLUGIN_EMAIL_TRUE@LoadPlugin email
-@BUILD_PLUGIN_ENTROPY_TRUE@LoadPlugin entropy
-@BUILD_PLUGIN_EXEC_TRUE@LoadPlugin exec
-@BUILD_PLUGIN_FILECOUNT_TRUE@LoadPlugin filecount
-@BUILD_PLUGIN_HDDTEMP_TRUE@LoadPlugin hddtemp
-@BUILD_PLUGIN_INTERFACE_TRUE@LoadPlugin interface
-@BUILD_PLUGIN_IPTABLES_TRUE@LoadPlugin iptables
-@BUILD_PLUGIN_IPMI_TRUE@LoadPlugin ipmi
-@BUILD_PLUGIN_IPVS_TRUE@LoadPlugin ipvs
-@BUILD_PLUGIN_IRQ_TRUE@LoadPlugin irq
-@BUILD_PLUGIN_LIBVIRT_TRUE@LoadPlugin libvirt
-@BUILD_PLUGIN_LOAD_TRUE@LoadPlugin load
-@BUILD_PLUGIN_MBMON_TRUE@LoadPlugin mbmon
-@BUILD_PLUGIN_MEMCACHED_TRUE@LoadPlugin memcached
-@BUILD_PLUGIN_MEMORY_TRUE@LoadPlugin memory
-@BUILD_PLUGIN_MULTIMETER_TRUE@LoadPlugin multimeter
-@BUILD_PLUGIN_MYSQL_TRUE@LoadPlugin mysql
-@BUILD_PLUGIN_NETLINK_TRUE@LoadPlugin netlink
-@BUILD_PLUGIN_NETWORK_TRUE@LoadPlugin network
-@BUILD_PLUGIN_NFS_TRUE@LoadPlugin nfs
-@BUILD_PLUGIN_NGINX_TRUE@LoadPlugin nginx
-@BUILD_PLUGIN_NOTIFY_DESKTOP_TRUE@LoadPlugin notify_desktop
-@BUILD_PLUGIN_NOTIFY_EMAIL_TRUE@LoadPlugin notify_email
-@BUILD_PLUGIN_NTPD_TRUE@LoadPlugin ntpd
-@BUILD_PLUGIN_NUT_TRUE@LoadPlugin nut
-@BUILD_PLUGIN_ONEWIRE_TRUE@LoadPlugin onewire
-@BUILD_PLUGIN_OPENVPN_TRUE@LoadPlugin openvpn
-@BUILD_PLUGIN_ORACLE_TRUE@LoadPlugin oracle
-@BUILD_PLUGIN_PERL_TRUE@LoadPlugin perl
-@BUILD_PLUGIN_PING_TRUE@LoadPlugin ping
-@BUILD_PLUGIN_POSTGRESQL_TRUE@LoadPlugin postgresql
-@BUILD_PLUGIN_POWERDNS_TRUE@LoadPlugin powerdns
-@BUILD_PLUGIN_PROCESSES_TRUE@LoadPlugin processes
-@BUILD_PLUGIN_RRDCACHED_TRUE@LoadPlugin rrdcached
-@BUILD_PLUGIN_RRDTOOL_TRUE@LoadPlugin rrdtool
-@BUILD_PLUGIN_SENSORS_TRUE@LoadPlugin sensors
-@BUILD_PLUGIN_SERIAL_TRUE@LoadPlugin serial
-@BUILD_PLUGIN_SNMP_TRUE@LoadPlugin snmp
-@BUILD_PLUGIN_SWAP_TRUE@LoadPlugin swap
-@BUILD_PLUGIN_TAIL_TRUE@LoadPlugin tail
-@BUILD_PLUGIN_TAPE_TRUE@LoadPlugin tape
-@BUILD_PLUGIN_TCPCONNS_TRUE@LoadPlugin tcpconns
-@BUILD_PLUGIN_TEAMSPEAK2_TRUE@LoadPlugin teamspeak2
-@BUILD_PLUGIN_THERMAL_TRUE@LoadPlugin thermal
-@BUILD_PLUGIN_UNIXSOCK_TRUE@LoadPlugin unixsock
-@BUILD_PLUGIN_USERS_TRUE@LoadPlugin users
-#LoadPlugin uuid
-@BUILD_PLUGIN_VMEM_TRUE@LoadPlugin vmem
-@BUILD_PLUGIN_VSERVER_TRUE@LoadPlugin vserver
-@BUILD_PLUGIN_WIRELESS_TRUE@LoadPlugin wireless
-@BUILD_PLUGIN_XMMS_TRUE@LoadPlugin xmms
+#      LogLevel @DEFAULT_LOG_LEVEL@
+#</Plugin>
+
+##############################################################################
+# LoadPlugin section                                                         #
+#----------------------------------------------------------------------------#
+# Lines beginning with a single `#' belong to plugins which have been built  #
+# but are disabled by default.                                               #
+#                                                                            #
+# Lines begnning with `##' belong to plugins which have not been built due   #
+# to missing dependencies or because they have been deactivated explicitly.  #
+##############################################################################
+
+#@BUILD_PLUGIN_APACHE_TRUE@LoadPlugin apache
+#@BUILD_PLUGIN_APCUPS_TRUE@LoadPlugin apcups
+#@BUILD_PLUGIN_APPLE_SENSORS_TRUE@LoadPlugin apple_sensors
+#@BUILD_PLUGIN_ASCENT_TRUE@LoadPlugin ascent
+#@BUILD_PLUGIN_BATTERY_TRUE@LoadPlugin battery
+#@BUILD_PLUGIN_BIND_TRUE@LoadPlugin bind
+@BUILD_PLUGIN_CPU_TRUE@@BUILD_PLUGIN_CPU_TRUE@LoadPlugin cpu
+#@BUILD_PLUGIN_CPUFREQ_TRUE@LoadPlugin cpufreq
+@LOAD_PLUGIN_CSV@LoadPlugin csv
+#@BUILD_PLUGIN_CURL_TRUE@LoadPlugin curl
+#@BUILD_PLUGIN_DBI_TRUE@LoadPlugin dbi
+#@BUILD_PLUGIN_DF_TRUE@LoadPlugin df
+#@BUILD_PLUGIN_DISK_TRUE@LoadPlugin disk
+#@BUILD_PLUGIN_DNS_TRUE@LoadPlugin dns
+#@BUILD_PLUGIN_EMAIL_TRUE@LoadPlugin email
+#@BUILD_PLUGIN_ENTROPY_TRUE@LoadPlugin entropy
+#@BUILD_PLUGIN_EXEC_TRUE@LoadPlugin exec
+#@BUILD_PLUGIN_FILECOUNT_TRUE@LoadPlugin filecount
+#@BUILD_PLUGIN_GMOND_TRUE@LoadPlugin gmond
+#@BUILD_PLUGIN_HDDTEMP_TRUE@LoadPlugin hddtemp
+@BUILD_PLUGIN_INTERFACE_TRUE@@BUILD_PLUGIN_INTERFACE_TRUE@LoadPlugin interface
+#@BUILD_PLUGIN_IPTABLES_TRUE@LoadPlugin iptables
+#@BUILD_PLUGIN_IPMI_TRUE@LoadPlugin ipmi
+#@BUILD_PLUGIN_IPVS_TRUE@LoadPlugin ipvs
+#@BUILD_PLUGIN_IRQ_TRUE@LoadPlugin irq
+#@BUILD_PLUGIN_JAVA_TRUE@LoadPlugin java
+#@BUILD_PLUGIN_LIBVIRT_TRUE@LoadPlugin libvirt
+@BUILD_PLUGIN_LOAD_TRUE@@BUILD_PLUGIN_LOAD_TRUE@LoadPlugin load
+#@BUILD_PLUGIN_MBMON_TRUE@LoadPlugin mbmon
+#@BUILD_PLUGIN_MEMCACHED_TRUE@LoadPlugin memcached
+@BUILD_PLUGIN_MEMORY_TRUE@@BUILD_PLUGIN_MEMORY_TRUE@LoadPlugin memory
+#@BUILD_PLUGIN_MULTIMETER_TRUE@LoadPlugin multimeter
+#@BUILD_PLUGIN_MYSQL_TRUE@LoadPlugin mysql
+#@BUILD_PLUGIN_NETLINK_TRUE@LoadPlugin netlink
+@LOAD_PLUGIN_NETWORK@LoadPlugin network
+#@BUILD_PLUGIN_NFS_TRUE@LoadPlugin nfs
+#@BUILD_PLUGIN_NGINX_TRUE@LoadPlugin nginx
+#@BUILD_PLUGIN_NOTIFY_DESKTOP_TRUE@LoadPlugin notify_desktop
+#@BUILD_PLUGIN_NOTIFY_EMAIL_TRUE@LoadPlugin notify_email
+#@BUILD_PLUGIN_NTPD_TRUE@LoadPlugin ntpd
+#@BUILD_PLUGIN_NUT_TRUE@LoadPlugin nut
+#@BUILD_PLUGIN_ONEWIRE_TRUE@LoadPlugin onewire
+#@BUILD_PLUGIN_OPENVPN_TRUE@LoadPlugin openvpn
+#@BUILD_PLUGIN_ORACLE_TRUE@LoadPlugin oracle
+#@BUILD_PLUGIN_PERL_TRUE@LoadPlugin perl
+#@BUILD_PLUGIN_PING_TRUE@LoadPlugin ping
+#@BUILD_PLUGIN_POSTGRESQL_TRUE@LoadPlugin postgresql
+#@BUILD_PLUGIN_POWERDNS_TRUE@LoadPlugin powerdns
+#@BUILD_PLUGIN_PROCESSES_TRUE@LoadPlugin processes
+#@BUILD_PLUGIN_PROTOCOLS_TRUE@LoadPlugin protocols
+#@BUILD_PLUGIN_RRDCACHED_TRUE@LoadPlugin rrdcached
+@LOAD_PLUGIN_RRDTOOL@LoadPlugin rrdtool
+#@BUILD_PLUGIN_SENSORS_TRUE@LoadPlugin sensors
+#@BUILD_PLUGIN_SERIAL_TRUE@LoadPlugin serial
+#@BUILD_PLUGIN_SNMP_TRUE@LoadPlugin snmp
+#@BUILD_PLUGIN_SWAP_TRUE@LoadPlugin swap
+#@BUILD_PLUGIN_TAIL_TRUE@LoadPlugin tail
+#@BUILD_PLUGIN_TAPE_TRUE@LoadPlugin tape
+#@BUILD_PLUGIN_TCPCONNS_TRUE@LoadPlugin tcpconns
+#@BUILD_PLUGIN_TEAMSPEAK2_TRUE@LoadPlugin teamspeak2
+#@BUILD_PLUGIN_THERMAL_TRUE@LoadPlugin thermal
+#@BUILD_PLUGIN_UNIXSOCK_TRUE@LoadPlugin unixsock
+#@BUILD_PLUGIN_UPTIME_TRUE@LoadPlugin uptime
+#@BUILD_PLUGIN_USERS_TRUE@LoadPlugin users
+#@BUILD_PLUGIN_UUID_TRUE@LoadPlugin uuid
+#@BUILD_PLUGIN_VMEM_TRUE@LoadPlugin vmem
+#@BUILD_PLUGIN_VSERVER_TRUE@LoadPlugin vserver
+#@BUILD_PLUGIN_WIRELESS_TRUE@LoadPlugin wireless
+#@BUILD_PLUGIN_XMMS_TRUE@LoadPlugin xmms
+
+##############################################################################
+# Plugin configuration                                                       #
+#----------------------------------------------------------------------------#
+# In this section configuration stubs for each plugin are provided. A desc-  #
+# ription of those options is available in the collectd.conf(5) manual page. #
+##############################################################################
 
 #<Plugin apache>
 #      URL "http://localhost/status?auto"
@@ -210,11 +245,31 @@ FQDNLookup   true
 #      </Directory>
 #</Plugin>
 
-@BUILD_PLUGIN_HDDTEMP_TRUE@<Plugin hddtemp>
-#      Host "127.0.0.1"
-#      Port "7634"
-@BUILD_PLUGIN_HDDTEMP_TRUE@    TranslateDevicename false
-@BUILD_PLUGIN_HDDTEMP_TRUE@</Plugin>
+#<Plugin "gmond">
+#  MCReceiveFrom "239.2.11.71" "8649"
+#  <Metric "swap_total">
+#    Type "swap"
+#    TypeInstance "total"
+#    DataSource "value"
+#  </Metric>
+#  <Metric "swap_free">
+#    Type "swap"
+#    TypeInstance "free"
+#    DataSource "value"
+#  </Metric>
+#</Plugin>
+
+#<Plugin hddtemp>
+#  Host "127.0.0.1"
+#  Port "7634"
+#
+#  #----------------------------------------------------------------#
+#  # `TranslateDevicename' enabled backwards compatibility behavior #
+#  # and is enabled by default. Setting this option to `false' is   #
+#  # highly recommended.                                            #
+#  #----------------------------------------------------------------#
+#  TranslateDevicename false
+#</Plugin>
 
 #<Plugin interface>
 #      Interface "eth0"
@@ -232,6 +287,16 @@ FQDNLookup   true
 #      IgnoreSelected true
 #</Plugin>
 
+#<Plugin "java">
+#      JVMArg "-verbose:jni"
+#      JVMArg "-Djava.class.path=/opt/collectd/lib/collectd/bindings/java"
+#
+#      LoadPlugin "org.collectd.java.Foobar"
+#      <Plugin "org.collectd.java.Foobar">
+#        # To be parsed by the plugin
+#      </Plugin>
+#</Plugin>
+
 #<Plugin libvirt>
 #      Connection "xen:///"
 #      RefreshInterval 60
@@ -253,10 +318,20 @@ FQDNLookup   true
 #</Plugin>
 
 #<Plugin mysql>
-#      Host "database.serv.er"
-#      User "db_user"
-#      Password "secret"
-#      Database "db_name"
+#      <Database db_name>
+#              Host "database.serv.er"
+#              User "db_user"
+#              Password "secret"
+#              Database "db_name"
+#              MasterStats true
+#      </Database>
+#
+#      <Database db_name2>
+#              Host "localhost"
+#              Socket "/var/run/mysql/mysqld.sock"
+#              SlaveStats true
+#              SlaveNotifications true
+#      </Database>
 #</Plugin>
 
 #<Plugin netlink>
@@ -268,15 +343,15 @@ FQDNLookup   true
 #      IgnoreSelected false
 #</Plugin>
 
-#<Plugin network>
-#      Server "ff18::efc0:4a42" "25826"
-#      Server "239.192.74.66" "25826"
+@LOAD_PLUGIN_NETWORK@<Plugin network>
+@LOAD_PLUGIN_NETWORK@  Server "ff18::efc0:4a42" "25826"
+@LOAD_PLUGIN_NETWORK@  Server "239.192.74.66" "25826"
 #      Listen "ff18::efc0:4a42" "25826"
 #      Listen "239.192.74.66" "25826"
 #      TimeToLive "128"
 #      Forward false
 #      CacheFlush 1800
-#</Plugin>
+@LOAD_PLUGIN_NETWORK@</Plugin>
 
 #<Plugin nginx>
 #      URL "http://localhost/status?auto"
@@ -415,6 +490,11 @@ FQDNLookup   true
 #      Process "name"
 #</Plugin>
 
+#<Plugin protocols>
+#      Value "/^Tcp:/"
+#      IgnoreSelected false
+#</Plugin>
+
 #<Plugin rrdcached>
 #      DaemonAddress "unix:/tmp/rrdcached.sock"
 #      DataDir "@prefix@/var/lib/@PACKAGE_NAME@/rrd"
@@ -454,7 +534,7 @@ FQDNLookup   true
 #       Instance "IF-MIB::ifDescr"
 #       Values "IF-MIB::ifInOctets" "IF-MIB::ifOutOctets"
 #   </Data>
-#   
+#
 #   <Host "some.switch.mydomain.org">
 #       Address "192.168.0.2"
 #       Version 1
@@ -527,13 +607,13 @@ FQDNLookup   true
 #      Verbose false
 #</Plugin>
 
-# * * * * * * * * * * * * *
-# * FILTER CONFIGURATION  *
-# * * * * * * * * * * * * *
-
-# The following configures collectd's filtering mechanism. Before changing
-# anything in this section, please read the `FILTER CONFIGURATION' section in
-# the collectd.conf(5) manual page.
+##############################################################################
+# Filter configuration                                                       #
+#----------------------------------------------------------------------------#
+# The following configures collectd's filtering mechanism. Before changing   #
+# anything in this section, please read the `FILTER CONFIGURATION' section   #
+# in the collectd.conf(5) manual page.                                       #
+##############################################################################
 
 # Load required matches:
 #@BUILD_PLUGIN_MATCH_REGEX_TRUE@LoadPlugin match_regex
@@ -544,9 +624,11 @@ FQDNLookup   true
 #@BUILD_PLUGIN_TARGET_NOTIFICATION_TRUE@LoadPlugin target_notification
 #@BUILD_PLUGIN_TARGET_REPLACE_TRUE@LoadPlugin target_replace
 #@BUILD_PLUGIN_TARGET_SET_TRUE@LoadPlugin target_set
-# The following block demonstrates the default behavior if no filtering is
-# configured at all: All values will be sent to all available write plugins.
+
+#----------------------------------------------------------------------------#
+# The following block demonstrates the default behavior if no filtering is   #
+# configured at all: All values will be sent to all available write plugins. #
+#----------------------------------------------------------------------------#
 
 #<Chain "Main">
 #  Target "write"
index 43946bd..581da28 100644 (file)
@@ -665,7 +665,7 @@ separated by dashes I<("-")>.
 
 Specifies the columns whose values will be used to create the "type-instance"
 for each row. If you specify more than one column, the value of all columns
-will be join together with the dashes I<("-")> as separation character.
+will be joined together with dashes I<("-")> as separation characters.
 
 The plugin itself does not check whether or not all built instances are
 different. It's your responsibility to assure that each is unique. This is
@@ -962,6 +962,88 @@ Controls whether or not to recurse into subdirectories. Enabled by default.
 
 =back
 
+=head2 Plugin C<gmond>
+
+The I<gmond> plugin received the multicast traffic sent by B<gmond>, the
+statistics collection daemon of Ganglia. Mappings for the standard "metrics"
+are built-in, custom mappings may be added via B<Metric> blocks, see below.
+
+Synopsis:
+
+ <Plugin "gmond">
+   MCReceiveFrom "239.2.11.71" "8649"
+   <Metric "swap_total">
+     Type "swap"
+     TypeInstance "total"
+     DataSource "value"
+   </Metric>
+   <Metric "swap_free">
+     Type "swap"
+     TypeInstance "free"
+     DataSource "value"
+   </Metric>
+ </Plugin>
+
+The following metrics are built-in:
+
+=over 4
+
+=item *
+
+load_one, load_five, load_fifteen
+
+=item *
+
+cpu_user, cpu_system, cpu_idle, cpu_nice, cpu_wio
+
+=item *
+
+mem_free, mem_shared, mem_buffers, mem_cached, mem_total
+
+=item *
+
+bytes_in, bytes_out
+
+=item *
+
+pkts_in, pkts_out
+
+=back
+
+Available configuration options:
+
+=over 4
+
+=item B<MCReceiveFrom> I<MCGroup> [I<Port>]
+
+Sets sets the multicast group and UDP port to which to subscribe.
+
+Default: B<239.2.11.71>E<nbsp>/E<nbsp>B<8649>
+
+=item E<lt>B<Metric> I<Name>E<gt>
+
+These blocks add a new metric conversion to the internal table. I<Name>, the
+string argument to the B<Metric> block, is the metric name as used by Ganglia.
+
+=over 4
+
+=item B<Type> I<Type>
+
+Type to map this metric to. Required.
+
+=item B<TypeInstance> I<Instance>
+
+Type-instance to use. Optional.
+
+=item B<DataSource> I<Name>
+
+Data source to map this metric to. If the configured type has exactly one data
+source, this is optional. Otherwise the option is required.
+
+=back
+
+=back
+
 =head2 Plugin C<hddtemp>
 
 To get values from B<hddtemp> collectd connects to B<localhost> (127.0.0.1),
@@ -1086,6 +1168,62 @@ and all other interrupts are collected.
 
 =back
 
+=head2 Plugin C<java>
+
+The I<Java> plugin makes it possible to write extensions for collectd in Java.
+This section only discusses the syntax and semantic of the configuration
+options. For more in-depth information on the I<Java> plugin, please read
+L<collectd-java(5)>.
+
+Synopsis:
+
+ <Plugin "java">
+   JVMArg "-verbose:jni"
+   JVMArg "-Djava.class.path=/opt/collectd/lib/collectd/bindings/java"
+   LoadPlugin "org.collectd.java.Foobar"
+   <Plugin "org.collectd.java.Foobar">
+     # To be parsed by the plugin
+   </Plugin>
+ </Plugin>
+
+Available configuration options:
+
+=over 4
+
+=item B<JVMArg> I<Argument>
+
+Argument that is to be passed to the I<Java Virtual Machine> (JVM). This works
+exactly the way the arguments to the I<java> binary on the command line work.
+Execute C<javaE<nbsp>--help> for details.
+
+Please note that B<all> these options must appear B<before> (i.E<nbsp>e. above)
+any other options! When another option is found, the JVM will be started and
+later options will have to be ignored!
+
+=item B<LoadPlugin> I<JavaClass>
+
+Instantiates a new I<JavaClass> object. The constructor of this object very
+likely then registers one or more callback methods with the server.
+
+See L<collectd-java(5)> for details.
+
+When the first such option is found, the virtual machine (JVM) is created. This
+means that all B<JVMArg> options must appear before (i.E<nbsp>e. above) all
+B<LoadPlugin> options!
+
+=item B<Plugin> I<Name>
+
+The entire block is passed to the Java plugin as an
+I<org.collectd.api.OConfigItem> object.
+
+For this to work, the plugin has to register a configuration callback first,
+see L<collectd-java(5)/"config callback">. This means, that the B<Plugin> block
+must appear after the appropriate B<LoadPlugin> block. Also note, that I<Name>
+depends on the (Java) plugin registering the callback and is completely
+independent from the I<JavaClass> argument passed to B<LoadPlugin>.
+
+=back
+
 =head2 Plugin C<libvirt>
 
 This plugin allows CPU, disk and network load to be collected for virtualized
@@ -1237,19 +1375,50 @@ TCP-Port to connect to. Defaults to B<11211>.
 
 =head2 Plugin C<mysql>
 
-The C<mysql plugin> requires B<mysqlclient> to be installed. It connects to the
-database when started and keeps the connection up as long as possible. When the
-connection is interrupted for whatever reason it will try to re-connect. The
-plugin will complaint loudly in case anything goes wrong.
+The C<mysql plugin> requires B<mysqlclient> to be installed. It connects to
+one or more databases when started and keeps the connection up as long as
+possible. When the connection is interrupted for whatever reason it will try
+to re-connect. The plugin will complaint loudly in case anything goes wrong.
+
+This plugin issues the MySQL C<SHOW STATUS> / C<SHOW GLOBAL STATUS> command
+and collects information about MySQL network traffic, executed statements,
+requests, the query cache and threads by evaluating the
+C<Bytes_{received,sent}>, C<Com_*>, C<Handler_*>, C<Qcache_*> and C<Threads_*>
+return values. Please refer to the B<MySQL reference manual>, I<5.1.6. Server
+Status Variables> for an explanation of these values.
+
+Optionally, master and slave statistics may be collected in a MySQL
+replication setup. In that case, information about the synchronization state
+of the nodes are collected by evaluating the C<Position> return value of the
+C<SHOW MASTER STATUS> command and the C<Seconds_Behind_Master>,
+C<Read_Master_Log_Pos> and C<Exec_Master_Log_Pos> return values of the
+C<SHOW SLAVE STATUS> command. See the B<MySQL reference manual>,
+I<12.5.5.21 SHOW MASTER STATUS Syntax> and
+I<12.5.5.31 SHOW SLAVE STATUS Syntax> for details.
 
-This plugin issues the MySQL C<SHOW STATUS> command and collects information
-about MySQL network traffic, executed statements, requests, the query cache
-and threads by evaluating the C<Bytes_{received,sent}>, C<Com_*>,
-C<Handler_*>, C<Qcache_*> and C<Threads_*> return values. Please refer to the
-B<MySQL reference manual>, I<5.1.6. Server Status Variables> for an
-explanation of these values.
+Synopsis:
 
-Use the following options to configure the plugin:
+  <Plugin mysql>
+    <Database foo>
+      Host "hostname"
+      User "username"
+      Password "password"
+      Port "3306"
+      MasterStats true
+    </Database>
+
+    <Database bar>
+      Host "localhost"
+      Socket "/var/run/mysql/mysqld.sock"
+      SlaveStats true
+      SlaveNotifications true
+    </Database>
+  </Plugin>
+
+A B<Database> block defines one connection to a MySQL database. It accepts a
+single argument which specifies the name of the database. None of the other
+options are required. MySQL will use default values as documented in the
+section "mysql_real_connect()" in the B<MySQL reference manual>.
 
 =over 4
 
@@ -1289,6 +1458,17 @@ only has any effect, if B<Host> is set to B<localhost> (the default).
 Otherwise, use the B<Port> option above. See the documentation for the
 C<mysql_real_connect> function for details.
 
+=item B<MasterStats> I<true|false>
+
+=item B<SlaveStats> I<true|false>
+
+Enable the collection of master / slave statistics in a replication setup.
+
+=item B<SlaveNotifications> I<true|false>
+
+If enabled, the plugin sends a notification if the replication slave I/O and /
+or SQL threads are not running.
+
 =back
 
 =head2 Plugin C<netlink>
@@ -1397,6 +1577,45 @@ The optional I<Port> argument sets the port to use. It can either be given
 using a numeric port number or a service name. If the argument is omitted the
 default port B<25826> is assumed.
 
+Both, B<Server> and B<Listen> can be used as block, too, to provide
+configuration options for this socket only. For example:
+
+ <Plugin "network">
+   <Server "my.server.tld">
+     SecurityLevel "sign"
+     Secret "ohl0eQue"
+   </Server>
+ </Plugin>
+
+The following options are understood within B<E<lt>ServerE<gt>> and
+B<E<lt>ListenE<gt>> blocks:
+
+=over 4
+
+=item B<SecurityLevel> B<Encrypt>|B<Sign>|B<None>
+
+Set the security you require for network communication. When the security level
+has been set to B<Encrypt>, data sent over the network will be encrypted using
+I<AES-256> and only encrypted data will be accepted when receiving. When set to
+B<Sign>, transmitted data is signed using I<SHA-256> and only signed and
+encrypted data is accepted when receiving. When set to B<None>, data is sent
+without any security and all data is accepted when receiving.
+
+This feature is only available if the I<network> plugin was linked with
+I<libgcrypt>.
+
+=item B<Secret> I<Secret>
+
+Sets a shared secret for this socket. All security levels except B<None>
+require this setting. For B<None> this setting is only required if you want to
+be able to decrypt encrypted data (B<SecurityLevel> is set to B<Encrypt> on the
+client).
+
+This feature is only available if the I<network> plugin was linked with
+I<libgcrypt>.
+
+=back
+
 =item B<TimeToLive> I<1-255>
 
 Set the time-to-live of sent packets. This applies to all, unicast and
@@ -1633,6 +1852,11 @@ enables you to do that: By setting B<IgnoreSelected> to I<true> the effect of
 B<Sensor> is inverted: All selected interfaces are ignored and all other
 interfaces are collected.
 
+=item B<Interval> I<Seconds>
+
+Sets the interval in which all sensors should be read. If not specified, the
+global B<Interval> setting is used.
+
 =back
 
 B<EXPERIMENTAL!> The C<onewire> plugin is experimental, because it doesn't yet
@@ -1741,6 +1965,13 @@ to collectd's plugin system. See L<collectd-perl(5)> for its documentation.
 
 =head2 Plugin C<ping>
 
+The I<Ping> plugin starts a new thread which sends ICMP "ping" packets to the
+configured hosts periodically and measures the network latency. Whenever the
+C<read> function of the plugin is called, it submits the average latency, the
+standard deviation and the drop rate for each host.
+
+Available configuration options:
+
 =over 4
 
 =item B<Host> I<IP-address>
@@ -1748,6 +1979,26 @@ to collectd's plugin system. See L<collectd-perl(5)> for its documentation.
 Host to ping periodically. This option may be repeated several times to ping
 multiple hosts.
 
+=item B<Interval> I<Seconds>
+
+Sets the interval in which to send ICMP echo packets to the configured hosts.
+This is B<not> the interval in which statistics are queries from the plugin but
+the interval in which the hosts are "pinged". Therefore, the setting here
+should be smaller than or equal to the global B<Interval> setting. Fractional
+times, such as "1.24" are allowed.
+
+Default: B<1.0>
+
+=item B<Timeout> I<Seconds>
+
+Time to wait for a response from the host to which an ICMP packet had been
+sent. If a reply was not received after I<Seconds> seconds, the host is assumed
+to be down or the packet to be dropped. This setting must be smaller than the
+B<Interval> setting above for the plugin to work correctly. Fractional
+arguments are accepted.
+
+Default: B<0.9>
+
 =item B<TTL> I<0-255>
 
 Sets the Time-To-Live of generated ICMP packets.
@@ -2234,6 +2485,39 @@ slashes.
 
 =back
 
+=head2 Plugin C<protocols>
+
+Collects a lot of information about various network protocols, such as I<IP>,
+I<TCP>, I<UDP>, etc.
+
+Available configuration options:
+
+=over 4
+
+=item B<Value> I<Selector>
+
+Selects whether or not to select a specific value. The string being matched is
+of the form "I<Protocol>:I<ValueName>", where I<Protocol> will be used as the
+plugin instance and I<ValueName> will be used as type instance. An example of
+the string being used would be C<Tcp:RetransSegs>.
+
+You can use regular expressions to match a large number of values with just one
+configuration option. To select all "extended" I<TCP> values, you could use the
+following statement:
+
+  Value "/^TcpExt:/"
+
+Whether only matched values are selected or all matched values are ignored
+depends on the B<IgnoreSelected>. By default, only matched values are selected.
+If no value is configured at all, all values will be selected.
+
+=item B<IgnoreSelected> B<true>|B<false>
+
+If set to B<true>, inverts the selection made by B<Value>, i.E<nbsp>e. all
+matching values will be ignored.
+
+=back
+
 =head2 Plugin C<rrdcached>
 
 The C<rrdcached> plugin uses the RRDTool accelerator daemon, L<rrdcached(1)>,
@@ -2439,9 +2723,109 @@ debugging support.
 
 =back
 
+=head2 Plugin C<table>
+
+The C<table plugin> provides generic means to parse tabular data and dispatch
+user specified values. Values are selected based on column numbers. For
+example, this plugin may be used to get values from the Linux L<proc(5)>
+filesystem or CSV (comma separated values) files.
+
+  <Plugin table>
+    <Table "/proc/slabinfo">
+      Instance "slabinfo"
+      Separator " "
+      <Result>
+        Type gauge
+        InstancePrefix "active_objs"
+        InstancesFrom 0
+        ValuesFrom 1
+      </Result>
+      <Result>
+        Type gauge
+        InstancePrefix "objperslab"
+        InstancesFrom 0
+        ValuesFrom 4
+      </Result>
+    </Table>
+  </Plugin>
+
+The configuration consists of one or more B<Table> blocks, each of which
+configures one file to parse. Within each B<Table> block, there are one or
+more B<Result> blocks, which configure which data to select and how to
+interpret it.
+
+The following options are available inside a B<Table> block:
+
+=over 4
+
+=item B<Instance> I<instance>
+
+If specified, I<instance> is used as the plugin instance. So, in the above
+example, the plugin name C<table-slabinfo> would be used. If omitted, the
+filename of the table is used instead, with all special characters replaced
+with an underscore (C<_>).
+
+=item B<Separator> I<string>
+
+Any character of I<string> is interpreted as a delimiter between the different
+columns of the table. A sequence of two or more contiguous delimiters in the
+table is considered to be a single delimiter, i.E<nbsp>e. there cannot be any
+empty columns. The plugin uses the L<strtok_r(3)> function to parse the lines
+of a table - see its documentation for more details. This option is mandatory.
+
+A horizontal tab, newline and carriage return may be specified by C<\\t>,
+C<\\n> and C<\\r> respectively. Please note that the double backslashes are
+required because of collectd's config parsing.
+
+=back
+
+The following options are available inside a B<Result> block:
+
+=over 4
+
+=item B<Type> I<type>
+
+Sets the type used to dispatch the values to the daemon. Detailed information
+about types and their configuration can be found in L<types.db(5)>. This
+option is mandatory.
+
+=item B<InstancePrefix> I<prefix>
+
+If specified, prepend I<prefix> to the type instance. If omitted, only the
+B<InstancesFrom> option is considered for the type instance.
+
+=item B<InstancesFrom> I<column0> [I<column1> ...]
+
+If specified, the content of the given columns (identified by the column
+number starting at zero) will be used to create the type instance for each
+row. Multiple values (and the instance prefix) will be joined together with
+dashes (I<->) as separation character. If omitted, only the B<InstancePrefix>
+option is considered for the type instance.
+
+The plugin itself does not check whether or not all built instances are
+different. It’s your responsibility to assure that each is unique. This is
+especially true, if you do not specify B<InstancesFrom>: B<You> have to make
+sure that the table only contains one row.
+
+If neither B<InstancePrefix> nor B<InstancesFrom> is given, the type instance
+will be empty.
+
+=item B<ValuesFrom> I<column0> [I<column1> ...]
+
+Specifies the columns (identified by the column numbers starting at zero)
+whose content is used as the actual data for the data sets that are dispatched
+to the daemon. How many such columns you need is determined by the B<Type>
+setting above. If you specify too many or not enough columns, the plugin will
+complain about that and no data will be submitted to the daemon. The plugin
+uses L<strtoll(3)> and L<strtod(3)> to parse counter and gauge values
+respectively, so anything supported by those functions is supported by the
+plugin as well. This option is mandatory.
+
+=back
+
 =head2 Plugin C<tail>
 
-The C<tail plugin> plugins follows logfiles, just like L<tail(1)> does, parses
+The C<tail plugin> follows logfiles, just like L<tail(1)> does, parses
 each line and dispatches found values. What is matched can be configured by the
 user using (extended) regular expressions, as described in L<regex(7)>.
 
@@ -2578,6 +2962,37 @@ will be collected.
 
 =back
 
+=head2 Plugin C<ted>
+
+The I<TED> plugin connects to a device of "The Energy Detective", a device to
+measure power consumption. These devices are usually connected to a serial
+(RS232) or USB port. The plugin opens a configured device and tries to read the
+current energy readings. For more information on TED, visit
+L<http://www.theenergydetective.com/>.
+
+Available configuration options:
+
+=over 4
+
+=item B<Device> I<Path>
+
+Path to the device on which TED is connected. collectd will need read and write
+permissions on that file.
+
+Default: B</dev/ttyUSB0>
+
+=item B<Retries> I<Num>
+
+Apparently reading from TED is not that reliable. You can therefore configure a
+number of retries here. You only configure the I<retries> here, to if you
+specify zero, one reading will be performed (but no retries if that fails); if
+you specify three, a maximum of four readings are performed. Negative values
+are illegal.
+
+Default: B<0>
+
+=back
+
 =head2 Plugin C<tcpconns>
 
 The C<tcpconns plugin> counts the number of currently established TCP
index 1af2f14..d42453e 100644 (file)
@@ -253,7 +253,7 @@ int strsplit (char *string, char **fields, size_t size)
                        break;
        }
 
-       return (i);
+       return ((int) i);
 }
 
 int strjoin (char *dst, size_t dst_len,
@@ -317,6 +317,40 @@ int strsubstitute (char *str, char c_from, char c_to)
        return (ret);
 } /* int strsubstitute */
 
+int strunescape (char *buf, size_t buf_len)
+{
+       size_t i;
+
+       for (i = 0; (i < buf_len) && (buf[i] != '\0'); ++i)
+       {
+               if (buf[i] != '\\')
+                       continue;
+
+               if ((i >= buf_len) || (buf[i + 1] == '\0')) {
+                       ERROR ("string unescape: backslash found at end of string.");
+                       return (-1);
+               }
+
+               switch (buf[i + 1]) {
+                       case 't':
+                               buf[i] = '\t';
+                               break;
+                       case 'n':
+                               buf[i] = '\n';
+                               break;
+                       case 'r':
+                               buf[i] = '\r';
+                               break;
+                       default:
+                               buf[i] = buf[i + 1];
+                               break;
+               }
+
+               memmove (buf + i + 1, buf + i + 2, buf_len - i - 2);
+       }
+       return (0);
+} /* int strunescape */
+
 int escape_slashes (char *buf, int buf_len)
 {
        int i;
@@ -349,6 +383,19 @@ int escape_slashes (char *buf, int buf_len)
        return (0);
 } /* int escape_slashes */
 
+void replace_special (char *buffer, size_t buffer_size)
+{
+       size_t i;
+
+       for (i = 0; i < buffer_size; i++)
+       {
+               if (buffer[i] == 0)
+                       return;
+               if ((!isalnum ((int) buffer[i])) && (buffer[i] != '-'))
+                       buffer[i] = '_';
+       }
+} /* void replace_special */
+
 int timeval_cmp (struct timeval tv0, struct timeval tv1, struct timeval *delta)
 {
        struct timeval *larger;
@@ -790,6 +837,30 @@ int parse_identifier (char *str, char **ret_host,
        return (0);
 } /* int parse_identifier */
 
+int parse_value (const char *value, value_t *ret_value, const data_source_t ds)
+{
+       char *endptr = NULL;
+
+       if (DS_TYPE_COUNTER == ds.type)
+               ret_value->counter = (counter_t)strtoll (value, &endptr, 0);
+       else if (DS_TYPE_GAUGE == ds.type)
+               ret_value->gauge = (gauge_t)strtod (value, &endptr);
+       else {
+               ERROR ("parse_value: Invalid data source \"%s\" "
+                               "(type = %i).", ds.name, ds.type);
+               return -1;
+       }
+
+       if (value == endptr) {
+               ERROR ("parse_value: Failed to parse string as number: %s.", value);
+               return -1;
+       }
+       else if ((NULL != endptr) && ('\0' != *endptr))
+               WARNING ("parse_value: Ignoring trailing garbage after number: %s.",
+                               endptr);
+       return 0;
+} /* int parse_value */
+
 int parse_values (char *buffer, value_list_t *vl, const data_set_t *ds)
 {
        int i;
@@ -816,12 +887,10 @@ int parse_values (char *buffer, value_list_t *vl, const data_set_t *ds)
                }
                else
                {
-                       if (strcmp ("U", ptr) == 0)
+                       if ((strcmp ("U", ptr) == 0) && (ds->ds[i].type == DS_TYPE_GAUGE))
                                vl->values[i].gauge = NAN;
-                       else if (ds->ds[i].type == DS_TYPE_COUNTER)
-                               vl->values[i].counter = atoll (ptr);
-                       else if (ds->ds[i].type == DS_TYPE_GAUGE)
-                               vl->values[i].gauge = atof (ptr);
+                       else if (0 != parse_value (ptr, &vl->values[i], ds->ds[i]))
+                               return -1;
                }
 
                i++;
index 85db3ad..d0cc4e8 100644 (file)
@@ -98,7 +98,7 @@ ssize_t swrite (int fd, const void *buf, size_t count);
  *
  * DESCRIPTION
  *   Splits a string into parts and stores pointers to the parts in `fields'.
- *   The characters split at are ` ' (space) and "\t" (tab).
+ *   The characters split at are: " ", "\t", "\r", and "\n".
  *
  * PARAMETERS
  *   `string'      String to split. This string will be modified. `fields' will
@@ -158,10 +158,50 @@ int strjoin (char *dst, size_t dst_len, char **fields, size_t fields_num, const
  */
 int escape_slashes (char *buf, int buf_len);
 
+/*
+ * NAME
+ *   replace_special
+ *
+ * DESCRIPTION
+ *   Replaces any special characters (anything that's not alpha-numeric or a
+ *   dash) with an underscore.
+ *
+ *   E.g. "foo$bar&" would become "foo_bar_".
+ *
+ * PARAMETERS
+ *   `buffer'      String to be handled.
+ *   `buffer_size' Length of the string. The function returns after
+ *                 encountering a null-byte or reading this many bytes.
+ */
+void replace_special (char *buffer, size_t buffer_size);
+
 int strsubstitute (char *str, char c_from, char c_to);
 
 /*
  * NAME
+ *   strunescape
+ *
+ * DESCRIPTION
+ *   Replaces any escaped characters in a string with the appropriate special
+ *   characters. The following escaped characters are recognized:
+ *
+ *     \t -> <tab>
+ *     \n -> <newline>
+ *     \r -> <carriage return>
+ *
+ *   For all other escacped characters only the backslash will be removed.
+ *
+ * PARAMETERS
+ *   `buf'         String to be unescaped.
+ *   `buf_len'     Length of the string, including the terminating null-byte.
+ *
+ * RETURN VALUE
+ *   Returns zero upon success, a value less than zero else.
+ */
+int strunescape (char *buf, size_t buf_len);
+
+/*
+ * NAME
  *   timeval_cmp
  *
  * DESCRIPTION
@@ -182,6 +222,13 @@ int timeval_cmp (struct timeval tv0, struct timeval tv1, struct timeval *delta);
                (tv).tv_usec = (tv).tv_usec % 1000000; \
        } while (0)
 
+/* make sure tv_sec stores less than a second */
+#define NORMALIZE_TIMESPEC(tv) \
+       do { \
+               (tv).tv_sec += (tv).tv_nsec / 1000000000; \
+               (tv).tv_nsec = (tv).tv_nsec % 1000000000; \
+       } while (0)
+
 int check_create_dir (const char *file_orig);
 
 #ifdef HAVE_LIBKSTAT
@@ -213,6 +260,7 @@ int format_name (char *ret, int ret_len,
 int parse_identifier (char *str, char **ret_host,
                char **ret_plugin, char **ret_plugin_instance,
                char **ret_type, char **ret_type_instance);
+int parse_value (const char *value, value_t *ret_value, const data_source_t ds);
 int parse_values (char *buffer, value_list_t *vl, const data_set_t *ds);
 
 #if !HAVE_GETPWNAM_R
index c929d00..0e28e92 100644 (file)
@@ -172,7 +172,7 @@ static int cf_dispatch (const char *type, const char *orig_key,
        free (key);
        free (value);
 
-       DEBUG ("return (%i)", ret);
+       DEBUG ("cf_dispatch: return (%i)", ret);
 
        return (ret);
 } /* int cf_dispatch */
index 352557a..d01f47d 100644 (file)
--- a/src/csv.c
+++ b/src/csv.c
@@ -249,7 +249,8 @@ static int csv_config (const char *key, const char *value)
        return (0);
 } /* int csv_config */
 
-static int csv_write (const data_set_t *ds, const value_list_t *vl)
+static int csv_write (const data_set_t *ds, const value_list_t *vl,
+               user_data_t __attribute__((unused)) *user_data)
 {
        struct stat  statbuf;
        char         filename[512];
@@ -356,5 +357,5 @@ void module_register (void)
 {
        plugin_register_config ("csv", csv_config,
                        config_keys, config_keys_num);
-       plugin_register_write ("csv", csv_write);
+       plugin_register_write ("csv", csv_write, /* user_data = */ NULL);
 } /* void module_register */
index c2d42ee..82aeb29 100644 (file)
@@ -773,7 +773,8 @@ static int exec_read (void) /* {{{ */
   return (0);
 } /* int exec_read }}} */
 
-static int exec_notification (const notification_t *n)
+static int exec_notification (const notification_t *n,
+    user_data_t __attribute__((unused)) *user_data)
 {
   program_list_t *pl;
   program_list_and_notification_t *pln;
@@ -813,7 +814,7 @@ static int exec_notification (const notification_t *n)
   } /* for (pl) */
 
   return (0);
-} /* int exec_notification */
+} /* }}} int exec_notification */
 
 static int exec_shutdown (void) /* {{{ */
 {
@@ -846,7 +847,8 @@ void module_register (void)
   plugin_register_complex_config ("exec", exec_config);
   plugin_register_init ("exec", exec_init);
   plugin_register_read ("exec", exec_read);
-  plugin_register_notification ("exec", exec_notification);
+  plugin_register_notification ("exec", exec_notification,
+      /* user_data = */ NULL);
   plugin_register_shutdown ("exec", exec_shutdown);
 } /* void module_register */
 
diff --git a/src/gmond.c b/src/gmond.c
new file mode 100644 (file)
index 0000000..93bbc95
--- /dev/null
@@ -0,0 +1,1100 @@
+/**
+ * collectd - src/gmond.c
+ * Copyright (C) 2005-2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ **/
+
+#include "collectd.h"
+#include "plugin.h"
+#include "common.h"
+#include "configfile.h"
+#include "utils_avltree.h"
+
+#if HAVE_PTHREAD_H
+# include <pthread.h>
+#endif
+#if HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+#if HAVE_NETDB_H
+# include <netdb.h>
+#endif
+#if HAVE_NETINET_IN_H
+# include <netinet/in.h>
+#endif
+#if HAVE_ARPA_INET_H
+# include <arpa/inet.h>
+#endif
+#if HAVE_POLL_H
+# include <poll.h>
+#endif
+
+#include <gm_protocol.h>
+
+#ifndef IPV6_ADD_MEMBERSHIP
+# ifdef IPV6_JOIN_GROUP
+#  define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
+# else
+#  error "Neither IP_ADD_MEMBERSHIP nor IPV6_JOIN_GROUP is defined"
+# endif
+#endif /* !IP_ADD_MEMBERSHIP */
+
+#ifdef GANGLIA_MAX_MESSAGE_LEN
+# define BUFF_SIZE GANGLIA_MAX_MESSAGE_LEN
+#else
+# define BUFF_SIZE 1400
+#endif
+
+struct socket_entry_s
+{
+  int                     fd;
+  struct sockaddr_storage addr;
+  socklen_t               addrlen;
+};
+typedef struct socket_entry_s socket_entry_t;
+
+struct staging_entry_s
+{
+  char key[2 * DATA_MAX_NAME_LEN];
+  value_list_t vl;
+  int flags;
+};
+typedef struct staging_entry_s staging_entry_t;
+
+struct metric_map_s
+{
+  char *ganglia_name;
+  char *type;
+  char *type_instance;
+  char *ds_name;
+  int   ds_type;
+  int   ds_index;
+};
+typedef struct metric_map_s metric_map_t;
+
+#define MC_RECEIVE_GROUP_DEFAULT "239.2.11.71"
+static char          *mc_receive_group = NULL;
+#define MC_RECEIVE_PORT_DEFAULT "8649"
+static char          *mc_receive_port = NULL;
+
+static struct pollfd *mc_receive_sockets = NULL;
+static size_t         mc_receive_sockets_num = 0;
+
+static socket_entry_t  *mc_send_sockets = NULL;
+static size_t           mc_send_sockets_num = 0;
+static pthread_mutex_t  mc_send_sockets_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static int            mc_receive_thread_loop    = 0;
+static int            mc_receive_thread_running = 0;
+static pthread_t      mc_receive_thread_id;
+
+static metric_map_t metric_map_default[] =
+{ /*---------------+-------------+-----------+-------------+------+-----*
+   * ganglia_name  ! type        ! type_inst ! data_source ! type ! idx *
+   *---------------+-------------+-----------+-------------+------+-----*/
+  { "load_one",     "load",       "",         "shortterm",     -1,   -1 },
+  { "load_five",    "load",       "",         "midterm",       -1,   -1 },
+  { "load_fifteen", "load",       "",         "longterm",      -1,   -1 },
+  { "cpu_user",     "cpu",        "user",     "value",         -1,   -1 },
+  { "cpu_system",   "cpu",        "system",   "value",         -1,   -1 },
+  { "cpu_idle",     "cpu",        "idle",     "value",         -1,   -1 },
+  { "cpu_nice",     "cpu",        "nice",     "value",         -1,   -1 },
+  { "cpu_wio",      "cpu",        "wait",     "value",         -1,   -1 },
+  { "mem_free",     "memory",     "free",     "value",         -1,   -1 },
+  { "mem_shared",   "memory",     "shared",   "value",         -1,   -1 },
+  { "mem_buffers",  "memory",     "buffered", "value",         -1,   -1 },
+  { "mem_cached",   "memory",     "cached",   "value",         -1,   -1 },
+  { "mem_total",    "memory",     "total",    "value",         -1,   -1 },
+  { "bytes_in",     "if_octets",  "",         "rx",            -1,   -1 },
+  { "bytes_out",    "if_octets",  "",         "tx",            -1,   -1 },
+  { "pkts_in",      "if_packets", "",         "rx",            -1,   -1 },
+  { "pkts_out",     "if_packets", "",         "tx",            -1,   -1 }
+};
+static size_t metric_map_len_default = STATIC_ARRAY_SIZE (metric_map_default);
+
+static metric_map_t *metric_map = NULL;
+static size_t        metric_map_len = 0;
+
+static c_avl_tree_t   *staging_tree;
+static pthread_mutex_t staging_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static metric_map_t *metric_lookup (const char *key) /* {{{ */
+{
+  metric_map_t *map;
+  size_t map_len;
+  size_t i;
+
+  /* Search the user-supplied table first.. */
+  map = metric_map;
+  map_len = metric_map_len;
+  for (i = 0; i < map_len; i++)
+    if (strcmp (map[i].ganglia_name, key) == 0)
+      break;
+
+  /* .. and fall back to the built-in table if nothing is found. */
+  if (i >= map_len)
+  {
+    map = metric_map_default;
+    map_len = metric_map_len_default;
+
+    for (i = 0; i < map_len; i++)
+      if (strcmp (map[i].ganglia_name, key) == 0)
+        break;
+  }
+
+  if (i >= map_len)
+    return (NULL);
+
+  /* Look up the DS type and ds_index. */
+  if ((map[i].ds_type < 0) || (map[i].ds_index < 0)) /* {{{ */
+  {
+    const data_set_t *ds;
+
+    ds = plugin_get_ds (map[i].type);
+    if (ds == NULL)
+    {
+      WARNING ("gmond plugin: Type not defined: %s", map[i].type);
+      return (NULL);
+    }
+
+    if ((map[i].ds_name == NULL) && (ds->ds_num != 1))
+    {
+      WARNING ("gmond plugin: No data source name defined for metric %s, "
+          "but type %s has more than one data source.",
+          map[i].ganglia_name, map[i].type);
+      return (NULL);
+    }
+
+    if (map[i].ds_name == NULL)
+    {
+      map[i].ds_index = 0;
+    }
+    else
+    {
+      int j;
+
+      for (j = 0; j < ds->ds_num; j++)
+        if (strcasecmp (ds->ds[j].name, map[i].ds_name) == 0)
+          break;
+
+      if (j >= ds->ds_num)
+      {
+        WARNING ("gmond plugin: There is no data source "
+            "named `%s' in type `%s'.",
+            map[i].ds_name, ds->type);
+        return (NULL);
+      }
+      map[i].ds_index = j;
+    }
+
+    map[i].ds_type = ds->ds[map[i].ds_index].type;
+  } /* }}} if ((map[i].ds_type < 0) || (map[i].ds_index < 0)) */
+
+  return (map + i);
+} /* }}} metric_map_t *metric_lookup */
+
+static int create_sockets (socket_entry_t **ret_sockets, /* {{{ */
+    size_t *ret_sockets_num,
+    const char *node, const char *service, int listen)
+{
+  struct addrinfo  ai_hints;
+  struct addrinfo *ai_list;
+  struct addrinfo *ai_ptr;
+  int              ai_return;
+
+  socket_entry_t *sockets;
+  size_t          sockets_num;
+
+  int status;
+    
+  sockets     = *ret_sockets;
+  sockets_num = *ret_sockets_num;
+
+  memset (&ai_hints, 0, sizeof (ai_hints));
+  ai_hints.ai_flags    = 0;
+#ifdef AI_PASSIVE
+  ai_hints.ai_flags |= AI_PASSIVE;
+#endif
+#ifdef AI_ADDRCONFIG
+  ai_hints.ai_flags |= AI_ADDRCONFIG;
+#endif
+  ai_hints.ai_family   = AF_UNSPEC;
+  ai_hints.ai_socktype = SOCK_DGRAM;
+  ai_hints.ai_protocol = IPPROTO_UDP;
+
+  ai_return = getaddrinfo (node, service, &ai_hints, &ai_list);
+  if (ai_return != 0)
+  {
+    char errbuf[1024];
+    ERROR ("gmond plugin: getaddrinfo (%s, %s) failed: %s",
+        (node == NULL) ? "(null)" : node,
+        (service == NULL) ? "(null)" : service,
+        (ai_return == EAI_SYSTEM)
+        ? sstrerror (errno, errbuf, sizeof (errbuf))
+        : gai_strerror (ai_return));
+    return (-1);
+  }
+
+  for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) /* {{{ */
+  {
+    socket_entry_t *tmp;
+
+    tmp = realloc (sockets, (sockets_num + 1) * sizeof (*sockets));
+    if (tmp == NULL)
+    {
+      ERROR ("gmond plugin: realloc failed.");
+      continue;
+    }
+    sockets = tmp;
+
+    sockets[sockets_num].fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype,
+        ai_ptr->ai_protocol);
+    if (sockets[sockets_num].fd < 0)
+    {
+      char errbuf[1024];
+      ERROR ("gmond plugin: socket failed: %s",
+          sstrerror (errno, errbuf, sizeof (errbuf)));
+      continue;
+    }
+
+    assert (sizeof (sockets[sockets_num].addr) >= ai_ptr->ai_addrlen);
+    memcpy (&sockets[sockets_num].addr, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
+    sockets[sockets_num].addrlen = ai_ptr->ai_addrlen;
+
+    /* Sending socket: Open only one socket and don't bind it. */
+    if (listen == 0)
+    {
+      sockets_num++;
+      break;
+    }
+    else
+    {
+      int yes = 1;
+
+      setsockopt (sockets[sockets_num].fd, SOL_SOCKET, SO_REUSEADDR,
+          (void *) &yes, sizeof (yes));
+    }
+
+    status = bind (sockets[sockets_num].fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
+    if (status != 0)
+    {
+      char errbuf[1024];
+      ERROR ("gmond plugin: bind failed: %s",
+          sstrerror (errno, errbuf, sizeof (errbuf)));
+      close (sockets[sockets_num].fd);
+      continue;
+    }
+
+    if (ai_ptr->ai_family == AF_INET)
+    {
+      struct sockaddr_in *addr;
+      struct ip_mreq mreq;
+      int loop;
+
+      addr = (struct sockaddr_in *) ai_ptr->ai_addr;
+
+      if (!IN_MULTICAST (ntohl (addr->sin_addr.s_addr)))
+      {
+        sockets_num++;
+        continue;
+      }
+
+      loop = 1;
+      setsockopt (sockets[sockets_num].fd, IPPROTO_IP, IP_MULTICAST_LOOP,
+          (void *) &loop, sizeof (loop));
+
+      memset (&mreq, 0, sizeof (mreq));
+      mreq.imr_multiaddr.s_addr = addr->sin_addr.s_addr;
+      mreq.imr_interface.s_addr = htonl (INADDR_ANY);
+      setsockopt (sockets[sockets_num].fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+          (void *) &mreq, sizeof (mreq));
+    } /* if (ai_ptr->ai_family == AF_INET) */
+    else if (ai_ptr->ai_family == AF_INET6)
+    {
+      struct sockaddr_in6 *addr;
+      struct ipv6_mreq mreq;
+      int loop;
+
+      addr = (struct sockaddr_in6 *) ai_ptr->ai_addr;
+
+      if (!IN6_IS_ADDR_MULTICAST (&addr->sin6_addr))
+      {
+        sockets_num++;
+        continue;
+      }
+
+      loop = 1;
+      setsockopt (sockets[sockets_num].fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
+          (void *) &loop, sizeof (loop));
+
+      memset (&mreq, 0, sizeof (mreq));
+      memcpy (&mreq.ipv6mr_multiaddr,
+          &addr->sin6_addr, sizeof (addr->sin6_addr));
+      mreq.ipv6mr_interface = 0; /* any */
+      setsockopt (sockets[sockets_num].fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
+          (void *) &mreq, sizeof (mreq));
+    } /* if (ai_ptr->ai_family == AF_INET6) */
+
+    sockets_num++;
+  } /* }}} for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) */
+
+  freeaddrinfo (ai_list);
+
+  if ((*ret_sockets_num) >= sockets_num)
+    return (-1);
+
+  *ret_sockets = sockets;
+  *ret_sockets_num = sockets_num;
+  return (0);
+} /* }}} int create_sockets */
+
+static int request_meta_data (const char *host, const char *name) /* {{{ */
+{
+  Ganglia_metadata_msg msg;
+  char buffer[BUFF_SIZE];
+  unsigned int buffer_size;
+  XDR xdr;
+  size_t i;
+
+  memset (&msg, 0, sizeof (msg));
+
+  msg.id = gmetadata_request;
+  msg.Ganglia_metadata_msg_u.grequest.metric_id.host = strdup (host);
+  msg.Ganglia_metadata_msg_u.grequest.metric_id.name = strdup (name);
+
+  if ((msg.Ganglia_metadata_msg_u.grequest.metric_id.host == NULL)
+      || (msg.Ganglia_metadata_msg_u.grequest.metric_id.name == NULL))
+  {
+    sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
+    sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
+    return (-1);
+  }
+
+  memset (buffer, 0, sizeof (buffer));
+  xdrmem_create (&xdr, buffer, sizeof (buffer), XDR_ENCODE);
+
+  if (!xdr_Ganglia_metadata_msg (&xdr, &msg))
+  {
+    sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
+    sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
+    return (-1);
+  }
+
+  buffer_size = xdr_getpos (&xdr);
+
+  DEBUG ("gmond plugin: Requesting meta data for %s/%s.",
+      host, name);
+
+  pthread_mutex_lock (&mc_send_sockets_lock);
+  for (i = 0; i < mc_send_sockets_num; i++)
+    sendto (mc_send_sockets[i].fd, buffer, (size_t) buffer_size,
+        /* flags = */ 0,
+        (struct sockaddr *) &mc_send_sockets[i].addr,
+        mc_send_sockets[i].addrlen);
+  pthread_mutex_unlock (&mc_send_sockets_lock);
+
+  sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
+  sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
+  return (0);
+} /* }}} int request_meta_data */
+
+static staging_entry_t *staging_entry_get (const char *host, /* {{{ */
+    const char *name,
+    const char *type, const char *type_instance,
+    int values_len)
+{
+  char key[2 * DATA_MAX_NAME_LEN];
+  staging_entry_t *se;
+  int status;
+
+  if (staging_tree == NULL)
+    return (NULL);
+
+  ssnprintf (key, sizeof (key), "%s/%s/%s", host, type,
+      (type_instance != NULL) ? type_instance : "");
+
+  se = NULL;
+  status = c_avl_get (staging_tree, key, (void *) &se);
+  if (status == 0)
+    return (se);
+
+  /* insert new entry */
+  se = (staging_entry_t *) malloc (sizeof (*se));
+  if (se == NULL)
+    return (NULL);
+  memset (se, 0, sizeof (*se));
+
+  sstrncpy (se->key, key, sizeof (se->key));
+  se->flags = 0;
+
+  se->vl.values = (value_t *) calloc (values_len, sizeof (*se->vl.values));
+  if (se->vl.values == NULL)
+  {
+    sfree (se);
+    return (NULL);
+  }
+  se->vl.values_len = values_len;
+
+  se->vl.time = 0;
+  se->vl.interval = 0;
+  sstrncpy (se->vl.host, host, sizeof (se->vl.host));
+  sstrncpy (se->vl.plugin, "gmond", sizeof (se->vl.plugin));
+  sstrncpy (se->vl.type, type, sizeof (se->vl.type));
+  if (type_instance != NULL)
+    sstrncpy (se->vl.type_instance, type_instance,
+        sizeof (se->vl.type_instance));
+
+  status = c_avl_insert (staging_tree, se->key, se);
+  if (status != 0)
+  {
+    ERROR ("gmond plugin: c_avl_insert failed.");
+    sfree (se->vl.values);
+    sfree (se);
+    return (NULL);
+  }
+
+  return (se);
+} /* }}} staging_entry_t *staging_entry_get */
+
+static int staging_entry_submit (const char *host, const char *name, /* {{{ */
+    staging_entry_t *se)
+{
+  value_list_t vl;
+  value_t values[se->vl.values_len];
+
+  if (se->vl.interval == 0)
+  {
+    /* No meta data has been received for this metric yet. */
+    se->flags = 0;
+    pthread_mutex_unlock (&staging_lock);
+    request_meta_data (host, name);
+    return (0);
+  }
+
+  se->flags = 0;
+
+  memcpy (values, se->vl.values, sizeof (values));
+  memcpy (&vl, &se->vl, sizeof (vl));
+
+  /* Unlock before calling `plugin_dispatch_values'.. */
+  pthread_mutex_unlock (&staging_lock);
+
+  vl.values = values;
+
+  plugin_dispatch_values (&vl);
+
+  return (0);
+} /* }}} int staging_entry_submit */
+
+static int staging_entry_update (const char *host, const char *name, /* {{{ */
+    const char *type, const char *type_instance,
+    int ds_index, int ds_type, value_t value)
+{
+  const data_set_t *ds;
+  staging_entry_t *se;
+
+  ds = plugin_get_ds (type);
+  if (ds == NULL)
+  {
+    ERROR ("gmond plugin: Looking up type %s failed.", type);
+    return (-1);
+  }
+
+  if (ds->ds_num <= ds_index)
+  {
+    ERROR ("gmond plugin: Invalid index %i: %s has only %i data source(s).",
+        ds_index, ds->type, ds->ds_num);
+    return (-1);
+  }
+
+  pthread_mutex_lock (&staging_lock);
+
+  se = staging_entry_get (host, name, type, type_instance, ds->ds_num);
+  if (se == NULL)
+  {
+    pthread_mutex_unlock (&staging_lock);
+    ERROR ("gmond plugin: staging_entry_get failed.");
+    return (-1);
+  }
+  if (se->vl.values_len != ds->ds_num)
+  {
+    pthread_mutex_unlock (&staging_lock);
+    return (-1);
+  }
+
+  if (ds_type == DS_TYPE_COUNTER)
+    se->vl.values[ds_index].counter += value.counter;
+  else if (ds_type == DS_TYPE_GAUGE)
+    se->vl.values[ds_index].gauge = value.gauge;
+  se->flags |= (0x01 << ds_index);
+
+  /* Check if all values have been set and submit if so. */
+  if (se->flags == ((0x01 << se->vl.values_len) - 1))
+  {
+    /* `staging_lock' is unlocked in `staging_entry_submit'. */
+    staging_entry_submit (host, name, se);
+  }
+  else
+  {
+    pthread_mutex_unlock (&staging_lock);
+  }
+
+  return (0);
+} /* }}} int staging_entry_update */
+
+static int mc_handle_value_msg (Ganglia_value_msg *msg) /* {{{ */
+{
+  const char *host;
+  const char *name;
+  metric_map_t *map;
+
+  value_t value_counter;
+  value_t value_gauge;
+
+  /* Fill in `host', `name', `value_counter', and `value_gauge' according to
+   * the value type, or return with an error. */
+  switch (msg->id) /* {{{ */
+  {
+    case gmetric_uint:
+    {
+      Ganglia_gmetric_uint msg_uint;
+
+      msg_uint = msg->Ganglia_value_msg_u.gu_int;
+
+      host = msg_uint.metric_id.host;
+      name = msg_uint.metric_id.name;
+      value_counter.counter = (counter_t) msg_uint.ui;
+      value_gauge.gauge = (gauge_t) msg_uint.ui;
+      break;
+    }
+
+    case gmetric_string:
+    {
+      Ganglia_gmetric_string msg_string;
+      char *endptr;
+
+      msg_string = msg->Ganglia_value_msg_u.gstr;
+
+      host = msg_string.metric_id.host;
+      name = msg_string.metric_id.name;
+
+      endptr = NULL;
+      errno = 0;
+      value_counter.counter = (counter_t) strtoll (msg_string.str,
+          &endptr, /* base = */ 0);
+      if ((endptr == msg_string.str) || (errno != 0))
+        value_counter.counter = -1;
+
+      endptr = NULL;
+      errno = 0;
+      value_gauge.gauge = (gauge_t) strtod (msg_string.str, &endptr);
+      if ((endptr == msg_string.str) || (errno != 0))
+        value_gauge.gauge = NAN;
+
+      break;
+    }
+
+    case gmetric_float:
+    {
+      Ganglia_gmetric_float msg_float;
+
+      msg_float = msg->Ganglia_value_msg_u.gf;
+
+      host = msg_float.metric_id.host;
+      name = msg_float.metric_id.name;
+      value_counter.counter = (counter_t) msg_float.f;
+      value_gauge.gauge = (gauge_t) msg_float.f;
+      break;
+    }
+
+    case gmetric_double:
+    {
+      Ganglia_gmetric_double msg_double;
+
+      msg_double = msg->Ganglia_value_msg_u.gd;
+
+      host = msg_double.metric_id.host;
+      name = msg_double.metric_id.name;
+      value_counter.counter = (counter_t) msg_double.d;
+      value_gauge.gauge = (gauge_t) msg_double.d;
+      break;
+    }
+    default:
+      DEBUG ("gmond plugin: Value type not handled: %i", msg->id);
+      return (-1);
+  } /* }}} switch (msg->id) */
+
+  assert (host != NULL);
+  assert (name != NULL);
+
+  map = metric_lookup (name);
+  if (map != NULL)
+    return (staging_entry_update (host, name,
+          map->type, map->type_instance,
+          map->ds_index, map->ds_type,
+          (map->ds_type == DS_TYPE_COUNTER) ? value_counter : value_gauge));
+
+  DEBUG ("gmond plugin: Cannot find a translation for %s.", name);
+  return (-1);
+} /* }}} int mc_handle_value_msg */
+
+static int mc_handle_metadata_msg (Ganglia_metadata_msg *msg) /* {{{ */
+{
+  switch (msg->id)
+  {
+    case gmetadata_full:
+    {
+      Ganglia_metadatadef msg_meta;
+      staging_entry_t *se;
+      const data_set_t *ds;
+      metric_map_t *map;
+
+      msg_meta = msg->Ganglia_metadata_msg_u.gfull;
+
+      if (msg_meta.metric.tmax <= 0)
+        return (-1);
+
+      map = metric_lookup (msg_meta.metric_id.name);
+      if (map == NULL)
+      {
+        DEBUG ("gmond plugin: Not handling meta data %s.",
+            msg_meta.metric_id.name);
+        return (0);
+      }
+
+      ds = plugin_get_ds (map->type);
+      if (ds == NULL)
+      {
+        WARNING ("gmond plugin: Could not find data set %s.", map->type);
+        return (-1);
+      }
+
+      DEBUG ("gmond plugin: Received meta data for %s/%s.",
+          msg_meta.metric_id.host, msg_meta.metric_id.name);
+
+      pthread_mutex_lock (&staging_lock);
+      se = staging_entry_get (msg_meta.metric_id.host,
+          msg_meta.metric_id.name,
+          map->type, map->type_instance,
+          ds->ds_num);
+      if (se != NULL)
+        se->vl.interval = (int) msg_meta.metric.tmax;
+      pthread_mutex_unlock (&staging_lock);
+
+      if (se == NULL)
+      {
+        ERROR ("gmond plugin: staging_entry_get failed.");
+        return (-1);
+      }
+
+      break;
+    }
+
+    default:
+    {
+      return (-1);
+    }
+  }
+
+  return (0);
+} /* }}} int mc_handle_metadata_msg */
+
+static int mc_handle_metric (void *buffer, size_t buffer_size) /* {{{ */
+{
+  XDR xdr;
+  Ganglia_msg_formats format;
+
+  xdrmem_create (&xdr, buffer, buffer_size, XDR_DECODE);
+
+  xdr_Ganglia_msg_formats (&xdr, &format);
+  xdr_setpos (&xdr, 0);
+
+  switch (format)
+  {
+    case gmetric_ushort:
+    case gmetric_short:
+    case gmetric_int:
+    case gmetric_uint:
+    case gmetric_string:
+    case gmetric_float:
+    case gmetric_double:
+    {
+      Ganglia_value_msg msg;
+
+      memset (&msg, 0, sizeof (msg));
+      if (xdr_Ganglia_value_msg (&xdr, &msg))
+        mc_handle_value_msg (&msg);
+      break;
+    }
+
+    case gmetadata_full:
+    case gmetadata_request:
+    {
+      Ganglia_metadata_msg msg;
+      memset (&msg, 0, sizeof (msg));
+      if (xdr_Ganglia_metadata_msg (&xdr, &msg))
+        mc_handle_metadata_msg (&msg);
+      break;
+    }
+
+    default:
+      DEBUG ("gmond plugin: Unknown format: %i", format);
+      return (-1);
+  } /* switch (format) */
+
+
+  return (0);
+} /* }}} int mc_handle_metric */
+
+static int mc_handle_socket (struct pollfd *p) /* {{{ */
+{
+  char buffer[BUFF_SIZE];
+  ssize_t buffer_size;
+
+  if ((p->revents & (POLLIN | POLLPRI)) == 0)
+  {
+    p->revents = 0;
+    return (-1);
+  }
+
+  buffer_size = recv (p->fd, buffer, sizeof (buffer), /* flags = */ 0);
+  if (buffer_size <= 0)
+  {
+    char errbuf[1024];
+    ERROR ("gmond plugin: recv failed: %s",
+        sstrerror (errno, errbuf, sizeof (errbuf)));
+    p->revents = 0;
+    return (-1);
+  }
+
+  mc_handle_metric (buffer, (size_t) buffer_size);
+  return (0);
+} /* }}} int mc_handle_socket */
+
+static void *mc_receive_thread (void *arg) /* {{{ */
+{
+  socket_entry_t *mc_receive_socket_entries;
+  int status;
+  size_t i;
+
+  mc_receive_socket_entries = NULL;
+  status = create_sockets (&mc_receive_socket_entries, &mc_receive_sockets_num,
+      (mc_receive_group != NULL) ? mc_receive_group : MC_RECEIVE_GROUP_DEFAULT,
+      (mc_receive_port != NULL) ? mc_receive_port : MC_RECEIVE_PORT_DEFAULT,
+      /* listen = */ 1);
+  if (status != 0)
+  {
+    ERROR ("gmond plugin: create_sockets failed.");
+    return ((void *) -1);
+  }
+
+  mc_receive_sockets = (struct pollfd *) calloc (mc_receive_sockets_num,
+      sizeof (*mc_receive_sockets));
+  if (mc_receive_sockets == NULL)
+  {
+    ERROR ("gmond plugin: calloc failed.");
+    for (i = 0; i < mc_receive_sockets_num; i++)
+      close (mc_receive_socket_entries[i].fd);
+    free (mc_receive_socket_entries);
+    mc_receive_socket_entries = NULL;
+    mc_receive_sockets_num = 0;
+    return ((void *) -1);
+  }
+
+  for (i = 0; i < mc_receive_sockets_num; i++)
+  {
+    mc_receive_sockets[i].fd = mc_receive_socket_entries[i].fd;
+    mc_receive_sockets[i].events = POLLIN | POLLPRI;
+    mc_receive_sockets[i].revents = 0;
+  }
+
+  while (mc_receive_thread_loop != 0)
+  {
+    status = poll (mc_receive_sockets, mc_receive_sockets_num, -1);
+    if (status <= 0)
+    {
+      char errbuf[1024];
+      if (errno == EINTR)
+        continue;
+      ERROR ("gmond plugin: poll failed: %s",
+          sstrerror (errno, errbuf, sizeof (errbuf)));
+      break;
+    }
+
+    for (i = 0; i < mc_receive_sockets_num; i++)
+    {
+      if (mc_receive_sockets[i].revents != 0)
+        mc_handle_socket (mc_receive_sockets + i);
+    }
+  } /* while (mc_receive_thread_loop != 0) */
+
+  return ((void *) 0);
+} /* }}} void *mc_receive_thread */
+
+static int mc_receive_thread_start (void) /* {{{ */
+{
+  int status;
+
+  if (mc_receive_thread_running != 0)
+    return (-1);
+
+  mc_receive_thread_loop = 1;
+
+  status = pthread_create (&mc_receive_thread_id, /* attr = */ NULL,
+      mc_receive_thread, /* args = */ NULL);
+  if (status != 0)
+  {
+    ERROR ("gmond plugin: Starting receive thread failed.");
+    mc_receive_thread_loop = 0;
+    return (-1);
+  }
+
+  mc_receive_thread_running = 1;
+  return (0);
+} /* }}} int start_receive_thread */
+
+static int mc_receive_thread_stop (void) /* {{{ */
+{
+  if (mc_receive_thread_running == 0)
+    return (-1);
+
+  mc_receive_thread_loop = 0;
+
+  INFO ("gmond plugin: Stopping receive thread.");
+  pthread_kill (mc_receive_thread_id, SIGTERM);
+  pthread_join (mc_receive_thread_id, /* return value = */ NULL);
+  memset (&mc_receive_thread_id, 0, sizeof (mc_receive_thread_id));
+
+  mc_receive_thread_running = 0;
+
+  return (0);
+} /* }}} int mc_receive_thread_stop */
+
+/* 
+ * Config:
+ *
+ * <Plugin gmond>
+ *   MCReceiveFrom "239.2.11.71" "8649"
+ *   <Metric "load_one">
+ *     Type "load"
+ *     [TypeInstance "foo"]
+ *     [DataSource "bar"]
+ *   </Metric>
+ * </Plugin>
+ */
+static int gmond_config_set_string (oconfig_item_t *ci, char **str) /* {{{ */
+{
+  char *tmp;
+
+  if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("gmond plugin: The `%s' option needs "
+        "exactly one string argument.", ci->key);
+    return (-1);
+  }
+
+  tmp = strdup (ci->values[0].value.string);
+  if (tmp == NULL)
+  {
+    ERROR ("gmond plugin: strdup failed.");
+    return (-1);
+  }
+
+  sfree (*str);
+  *str = tmp;
+  return (0);
+} /* }}} int gmond_config_set_string */
+
+static int gmond_config_add_metric (oconfig_item_t *ci) /* {{{ */
+{
+  metric_map_t *map;
+  int i;
+
+  if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("gmond plugin: `Metric' blocks need "
+        "exactly one string argument.");
+    return (-1);
+  }
+
+  map = realloc (metric_map, (metric_map_len + 1) * sizeof (*metric_map));
+  if (map == NULL)
+  {
+    ERROR ("gmond plugin: realloc failed.");
+    return (-1);
+  }
+  metric_map = map;
+  map = metric_map + metric_map_len;
+
+  memset (map, 0, sizeof (*map));
+  map->type = NULL;
+  map->type_instance = NULL;
+  map->ds_name = NULL;
+  map->ds_type = -1;
+  map->ds_index = -1;
+
+  map->ganglia_name = strdup (ci->values[0].value.string);
+  if (map->ganglia_name == NULL)
+  {
+    ERROR ("gmond plugin: strdup failed.");
+    return (-1);
+  }
+
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+    if (strcasecmp ("Type", child->key) == 0)
+      gmond_config_set_string (child, &map->type);
+    else if (strcasecmp ("TypeInstance", child->key) == 0)
+      gmond_config_set_string (child, &map->type_instance);
+    else if (strcasecmp ("DataSource", child->key) == 0)
+      gmond_config_set_string (child, &map->ds_name);
+    else
+    {
+      WARNING ("gmond plugin: Unknown configuration option `%s' ignored.",
+          child->key);
+    }
+  }
+
+  if (map->type == NULL)
+  {
+    ERROR ("gmond plugin: No type is set for metric %s.",
+        map->ganglia_name);
+    sfree (map->ganglia_name);
+    sfree (map->type_instance);
+    return (-1);
+  }
+
+  metric_map_len++;
+  return (0);
+} /* }}} int gmond_config_add_metric */
+
+static int gmond_config_set_address (oconfig_item_t *ci, /* {{{ */
+    char **ret_addr, char **ret_port)
+{
+  char *addr;
+  char *port;
+
+  if ((ci->values_num != 1) && (ci->values_num != 2))
+  {
+    WARNING ("gmond plugin: The `%s' config option needs "
+        "one or two string arguments.",
+        ci->key);
+    return (-1);
+  }
+  if ((ci->values[0].type != OCONFIG_TYPE_STRING)
+      || ((ci->values_num == 2)
+        && (ci->values[1].type != OCONFIG_TYPE_STRING)))
+  {
+    WARNING ("gmond plugin: The `%s' config option needs "
+        "one or two string arguments.",
+        ci->key);
+    return (-1);
+  }
+
+  addr = strdup (ci->values[0].value.string);
+  if (ci->values_num == 2)
+    port = strdup (ci->values[1].value.string);
+  else
+    port = NULL;
+
+  if ((addr == NULL) || ((ci->values_num == 2) && (port == NULL)))
+  {
+    ERROR ("gmond plugin: strdup failed.");
+    sfree (addr);
+    sfree (port);
+    return (-1);
+  }
+
+  sfree (*ret_addr);
+  sfree (*ret_port);
+
+  *ret_addr = addr;
+  *ret_port = port;
+
+  return (0);
+} /* }}} int gmond_config_set_address */
+
+static int gmond_config (oconfig_item_t *ci) /* {{{ */
+{
+  int i;
+
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+    if (strcasecmp ("MCReceiveFrom", child->key) == 0)
+      gmond_config_set_address (child, &mc_receive_group, &mc_receive_port);
+    else if (strcasecmp ("Metric", child->key) == 0)
+      gmond_config_add_metric (child);
+    else
+    {
+      WARNING ("gmond plugin: Unknown configuration option `%s' ignored.",
+          child->key);
+    }
+  }
+
+  return (0);
+} /* }}} int gmond_config */
+
+static int gmond_init (void) /* {{{ */
+{
+  create_sockets (&mc_send_sockets, &mc_send_sockets_num,
+      (mc_receive_group != NULL) ? mc_receive_group : MC_RECEIVE_GROUP_DEFAULT,
+      (mc_receive_port != NULL) ? mc_receive_port : MC_RECEIVE_PORT_DEFAULT,
+      /* listen = */ 0);
+
+  staging_tree = c_avl_create ((void *) strcmp);
+  if (staging_tree == NULL)
+  {
+    ERROR ("gmond plugin: c_avl_create failed.");
+    return (-1);
+  }
+
+  mc_receive_thread_start ();
+
+  return (0);
+} /* }}} int gmond_init */
+
+static int gmond_shutdown (void) /* {{{ */
+{
+  size_t i;
+
+  mc_receive_thread_stop ();
+
+  pthread_mutex_lock (&mc_send_sockets_lock);
+  for (i = 0; i < mc_send_sockets_num; i++)
+  {
+    close (mc_send_sockets[i].fd);
+    mc_send_sockets[i].fd = -1;
+  }
+  sfree (mc_send_sockets);
+  mc_send_sockets_num = 0;
+  pthread_mutex_unlock (&mc_send_sockets_lock);
+
+
+  return (0);
+} /* }}} int gmond_shutdown */
+
+void module_register (void)
+{
+  plugin_register_complex_config ("gmond", gmond_config);
+  plugin_register_init ("gmond", gmond_init);
+  plugin_register_shutdown ("gmond", gmond_shutdown);
+}
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
diff --git a/src/java.c b/src/java.c
new file mode 100644 (file)
index 0000000..20523f9
--- /dev/null
@@ -0,0 +1,3012 @@
+/**
+ * collectd - src/java.c
+ * Copyright (C) 2009  Florian octo Forster
+ * Copyright (C) 2008  Justo Alonso Achaques
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ *   Justo Alonso Achaques <justo.alonso at gmail.com>
+ **/
+
+#include "collectd.h"
+#include "plugin.h"
+#include "common.h"
+#include "filter_chain.h"
+
+#include <pthread.h>
+#include <jni.h>
+
+#if !defined(JNI_VERSION_1_2)
+# error "Need JNI 1.2 compatible interface!"
+#endif
+
+/*
+ * Types
+ */
+struct cjni_jvm_env_s /* {{{ */
+{
+  JNIEnv *jvm_env;
+  int reference_counter;
+};
+typedef struct cjni_jvm_env_s cjni_jvm_env_t;
+/* }}} */
+
+struct java_plugin_class_s /* {{{ */
+{
+  char     *name;
+  jclass    class;
+  jobject   object;
+};
+typedef struct java_plugin_class_s java_plugin_class_t;
+/* }}} */
+
+#define CB_TYPE_CONFIG       1
+#define CB_TYPE_INIT         2
+#define CB_TYPE_READ         3
+#define CB_TYPE_WRITE        4
+#define CB_TYPE_FLUSH        5
+#define CB_TYPE_SHUTDOWN     6
+#define CB_TYPE_LOG          7
+#define CB_TYPE_NOTIFICATION 8
+#define CB_TYPE_MATCH        9
+#define CB_TYPE_TARGET      10
+struct cjni_callback_info_s /* {{{ */
+{
+  char     *name;
+  int       type;
+  jclass    class;
+  jobject   object;
+  jmethodID method;
+};
+typedef struct cjni_callback_info_s cjni_callback_info_t;
+/* }}} */
+
+/*
+ * Global variables
+ */
+static JavaVM *jvm = NULL;
+static pthread_key_t jvm_env_key;
+
+/* Configuration options for the JVM. */
+static char **jvm_argv = NULL;
+static size_t jvm_argc = 0;
+
+/* List of class names to load */
+static java_plugin_class_t  *java_classes_list = NULL;
+static size_t                java_classes_list_len;
+
+/* List of config, init, and shutdown callbacks. */
+static cjni_callback_info_t *java_callbacks      = NULL;
+static size_t                java_callbacks_num  = 0;
+static pthread_mutex_t       java_callbacks_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/*
+ * Prototypes
+ *
+ * Mostly functions that are needed by the Java interface (``native'')
+ * functions.
+ */
+static void cjni_callback_info_destroy (void *arg);
+static cjni_callback_info_t *cjni_callback_info_create (JNIEnv *jvm_env,
+    jobject o_name, jobject o_callback, int type);
+static int cjni_callback_register (JNIEnv *jvm_env, jobject o_name,
+    jobject o_callback, int type);
+static int cjni_read (user_data_t *user_data);
+static int cjni_write (const data_set_t *ds, const value_list_t *vl,
+    user_data_t *ud);
+static int cjni_flush (int timeout, const char *identifier, user_data_t *ud);
+static void cjni_log (int severity, const char *message, user_data_t *ud);
+static int cjni_notification (const notification_t *n, user_data_t *ud);
+
+/* Create, destroy, and match/invoke functions, used by both, matches AND
+ * targets. */
+static int cjni_match_target_create (const oconfig_item_t *ci, void **user_data);
+static int cjni_match_target_destroy (void **user_data);
+static int cjni_match_target_invoke (const data_set_t *ds, value_list_t *vl,
+    notification_meta_t **meta, void **user_data);
+
+/* 
+ * C to Java conversion functions
+ */
+static int ctoj_string (JNIEnv *jvm_env, /* {{{ */
+    const char *string,
+    jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+  jmethodID m_set;
+  jstring o_string;
+
+  /* Create a java.lang.String */
+  o_string = (*jvm_env)->NewStringUTF (jvm_env,
+      (string != NULL) ? string : "");
+  if (o_string == NULL)
+  {
+    ERROR ("java plugin: ctoj_string: NewStringUTF failed.");
+    return (-1);
+  }
+
+  /* Search for the `void setFoo (String s)' method. */
+  m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      method_name, "(Ljava/lang/String;)V");
+  if (m_set == NULL)
+  {
+    ERROR ("java plugin: ctoj_string: Cannot find method `void %s (String)'.",
+        method_name);
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_string);
+    return (-1);
+  }
+
+  /* Call the method. */
+  (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, o_string);
+
+  /* Decrease reference counter on the java.lang.String object. */
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_string);
+
+  return (0);
+} /* }}} int ctoj_string */
+
+static int ctoj_int (JNIEnv *jvm_env, /* {{{ */
+    jint value,
+    jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+  jmethodID m_set;
+
+  /* Search for the `void setFoo (int i)' method. */
+  m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      method_name, "(I)V");
+  if (m_set == NULL)
+  {
+    ERROR ("java plugin: ctoj_int: Cannot find method `void %s (int)'.",
+        method_name);
+    return (-1);
+  }
+
+  (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
+
+  return (0);
+} /* }}} int ctoj_int */
+
+static int ctoj_long (JNIEnv *jvm_env, /* {{{ */
+    jlong value,
+    jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+  jmethodID m_set;
+
+  /* Search for the `void setFoo (long l)' method. */
+  m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      method_name, "(J)V");
+  if (m_set == NULL)
+  {
+    ERROR ("java plugin: ctoj_long: Cannot find method `void %s (long)'.",
+        method_name);
+    return (-1);
+  }
+
+  (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
+
+  return (0);
+} /* }}} int ctoj_long */
+
+static int ctoj_double (JNIEnv *jvm_env, /* {{{ */
+    jdouble value,
+    jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+  jmethodID m_set;
+
+  /* Search for the `void setFoo (double d)' method. */
+  m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      method_name, "(D)V");
+  if (m_set == NULL)
+  {
+    ERROR ("java plugin: ctoj_double: Cannot find method `void %s (double)'.",
+        method_name);
+    return (-1);
+  }
+
+  (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
+
+  return (0);
+} /* }}} int ctoj_double */
+
+/* Convert a jlong to a java.lang.Number */
+static jobject ctoj_jlong_to_number (JNIEnv *jvm_env, jlong value) /* {{{ */
+{
+  jclass c_long;
+  jmethodID m_long_constructor;
+
+  /* Look up the java.lang.Long class */
+  c_long = (*jvm_env)->FindClass (jvm_env, "java.lang.Long");
+  if (c_long == NULL)
+  {
+    ERROR ("java plugin: ctoj_jlong_to_number: Looking up the "
+        "java.lang.Long class failed.");
+    return (NULL);
+  }
+
+  m_long_constructor = (*jvm_env)->GetMethodID (jvm_env,
+      c_long, "<init>", "(J)V");
+  if (m_long_constructor == NULL)
+  {
+    ERROR ("java plugin: ctoj_jlong_to_number: Looking up the "
+        "`Long (long)' constructor failed.");
+    return (NULL);
+  }
+
+  return ((*jvm_env)->NewObject (jvm_env,
+        c_long, m_long_constructor, value));
+} /* }}} jobject ctoj_jlong_to_number */
+
+/* Convert a jdouble to a java.lang.Number */
+static jobject ctoj_jdouble_to_number (JNIEnv *jvm_env, jdouble value) /* {{{ */
+{
+  jclass c_double;
+  jmethodID m_double_constructor;
+
+  /* Look up the java.lang.Long class */
+  c_double = (*jvm_env)->FindClass (jvm_env, "java.lang.Double");
+  if (c_double == NULL)
+  {
+    ERROR ("java plugin: ctoj_jdouble_to_number: Looking up the "
+        "java.lang.Double class failed.");
+    return (NULL);
+  }
+
+  m_double_constructor = (*jvm_env)->GetMethodID (jvm_env,
+      c_double, "<init>", "(D)V");
+  if (m_double_constructor == NULL)
+  {
+    ERROR ("java plugin: ctoj_jdouble_to_number: Looking up the "
+        "`Double (double)' constructor failed.");
+    return (NULL);
+  }
+
+  return ((*jvm_env)->NewObject (jvm_env,
+        c_double, m_double_constructor, value));
+} /* }}} jobject ctoj_jdouble_to_number */
+
+/* Convert a value_t to a java.lang.Number */
+static jobject ctoj_value_to_number (JNIEnv *jvm_env, /* {{{ */
+    value_t value, int ds_type)
+{
+  if (ds_type == DS_TYPE_COUNTER)
+    return (ctoj_jlong_to_number (jvm_env, (jlong) value.counter));
+  else if (ds_type == DS_TYPE_GAUGE)
+    return (ctoj_jdouble_to_number (jvm_env, (jdouble) value.gauge));
+  else
+    return (NULL);
+} /* }}} jobject ctoj_value_to_number */
+
+/* Convert a data_source_t to a org/collectd/api/DataSource */
+static jobject ctoj_data_source (JNIEnv *jvm_env, /* {{{ */
+    const data_source_t *dsrc)
+{
+  jclass c_datasource;
+  jmethodID m_datasource_constructor;
+  jobject o_datasource;
+  int status;
+
+  /* Look up the DataSource class */
+  c_datasource = (*jvm_env)->FindClass (jvm_env,
+      "org/collectd/api/DataSource");
+  if (c_datasource == NULL)
+  {
+    ERROR ("java plugin: ctoj_data_source: "
+        "FindClass (org/collectd/api/DataSource) failed.");
+    return (NULL);
+  }
+
+  /* Lookup the `ValueList ()' constructor. */
+  m_datasource_constructor = (*jvm_env)->GetMethodID (jvm_env, c_datasource,
+      "<init>", "()V");
+  if (m_datasource_constructor == NULL)
+  {
+    ERROR ("java plugin: ctoj_data_source: Cannot find the "
+        "`DataSource ()' constructor.");
+    return (NULL);
+  }
+
+  /* Create a new instance. */
+  o_datasource = (*jvm_env)->NewObject (jvm_env, c_datasource,
+      m_datasource_constructor);
+  if (o_datasource == NULL)
+  {
+    ERROR ("java plugin: ctoj_data_source: "
+        "Creating a new DataSource instance failed.");
+    return (NULL);
+  }
+
+  /* Set name via `void setName (String name)' */
+  status = ctoj_string (jvm_env, dsrc->name,
+      c_datasource, o_datasource, "setName");
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_data_source: "
+        "ctoj_string (setName) failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+    return (NULL);
+  }
+
+  /* Set type via `void setType (int type)' */
+  status = ctoj_int (jvm_env, dsrc->type,
+      c_datasource, o_datasource, "setType");
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_data_source: "
+        "ctoj_int (setType) failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+    return (NULL);
+  }
+
+  /* Set min via `void setMin (double min)' */
+  status = ctoj_double (jvm_env, dsrc->min,
+      c_datasource, o_datasource, "setMin");
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_data_source: "
+        "ctoj_double (setMin) failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+    return (NULL);
+  }
+
+  /* Set max via `void setMax (double max)' */
+  status = ctoj_double (jvm_env, dsrc->max,
+      c_datasource, o_datasource, "setMax");
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_data_source: "
+        "ctoj_double (setMax) failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+    return (NULL);
+  }
+
+  return (o_datasource);
+} /* }}} jobject ctoj_data_source */
+
+/* Convert a oconfig_value_t to a org/collectd/api/OConfigValue */
+static jobject ctoj_oconfig_value (JNIEnv *jvm_env, /* {{{ */
+    oconfig_value_t ocvalue)
+{
+  jclass c_ocvalue;
+  jmethodID m_ocvalue_constructor;
+  jobject o_argument;
+  jobject o_ocvalue;
+
+  m_ocvalue_constructor = NULL;
+  o_argument = NULL;
+
+  c_ocvalue = (*jvm_env)->FindClass (jvm_env,
+      "org/collectd/api/OConfigValue");
+  if (c_ocvalue == NULL)
+  {
+    ERROR ("java plugin: ctoj_oconfig_value: "
+        "FindClass (org/collectd/api/OConfigValue) failed.");
+    return (NULL);
+  }
+
+  if (ocvalue.type == OCONFIG_TYPE_BOOLEAN)
+  {
+    jboolean tmp_boolean;
+
+    tmp_boolean = (ocvalue.value.boolean == 0) ? JNI_FALSE : JNI_TRUE;
+
+    m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
+        "<init>", "(Z)V");
+    if (m_ocvalue_constructor == NULL)
+    {
+      ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
+          "`OConfigValue (boolean)' constructor.");
+      return (NULL);
+    }
+
+    return ((*jvm_env)->NewObject (jvm_env,
+          c_ocvalue, m_ocvalue_constructor, tmp_boolean));
+  } /* if (ocvalue.type == OCONFIG_TYPE_BOOLEAN) */
+  else if (ocvalue.type == OCONFIG_TYPE_STRING)
+  {
+    m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
+        "<init>", "(Ljava/lang/String;)V");
+    if (m_ocvalue_constructor == NULL)
+    {
+      ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
+          "`OConfigValue (String)' constructor.");
+      return (NULL);
+    }
+
+    o_argument = (*jvm_env)->NewStringUTF (jvm_env, ocvalue.value.string);
+    if (o_argument == NULL)
+    {
+      ERROR ("java plugin: ctoj_oconfig_value: "
+          "Creating a String object failed.");
+      return (NULL);
+    }
+  }
+  else if (ocvalue.type == OCONFIG_TYPE_NUMBER)
+  {
+    m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
+        "<init>", "(Ljava/lang/Number;)V");
+    if (m_ocvalue_constructor == NULL)
+    {
+      ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
+          "`OConfigValue (Number)' constructor.");
+      return (NULL);
+    }
+
+    o_argument = ctoj_jdouble_to_number (jvm_env,
+        (jdouble) ocvalue.value.number);
+    if (o_argument == NULL)
+    {
+      ERROR ("java plugin: ctoj_oconfig_value: "
+          "Creating a Number object failed.");
+      return (NULL);
+    }
+  }
+  else
+  {
+    return (NULL);
+  }
+
+  assert (m_ocvalue_constructor != NULL);
+  assert (o_argument != NULL);
+
+  o_ocvalue = (*jvm_env)->NewObject (jvm_env,
+      c_ocvalue, m_ocvalue_constructor, o_argument);
+  if (o_ocvalue == NULL)
+  {
+    ERROR ("java plugin: ctoj_oconfig_value: "
+        "Creating an OConfigValue object failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_argument);
+    return (NULL);
+  }
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_argument);
+  return (o_ocvalue);
+} /* }}} jobject ctoj_oconfig_value */
+
+/* Convert a oconfig_item_t to a org/collectd/api/OConfigItem */
+static jobject ctoj_oconfig_item (JNIEnv *jvm_env, /* {{{ */
+    const oconfig_item_t *ci)
+{
+  jclass c_ocitem;
+  jmethodID m_ocitem_constructor;
+  jmethodID m_addvalue;
+  jmethodID m_addchild;
+  jobject o_key;
+  jobject o_ocitem;
+  int i;
+
+  c_ocitem = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/OConfigItem");
+  if (c_ocitem == NULL)
+  {
+    ERROR ("java plugin: ctoj_oconfig_item: "
+        "FindClass (org/collectd/api/OConfigItem) failed.");
+    return (NULL);
+  }
+
+  /* Get the required methods: m_ocitem_constructor, m_addvalue, and m_addchild
+   * {{{ */
+  m_ocitem_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
+      "<init>", "(Ljava/lang/String;)V");
+  if (m_ocitem_constructor == NULL)
+  {
+    ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
+        "`OConfigItem (String)' constructor.");
+    return (NULL);
+  }
+
+  m_addvalue = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
+      "addValue", "(Lorg/collectd/api/OConfigValue;)V");
+  if (m_addvalue == NULL)
+  {
+    ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
+        "`addValue (OConfigValue)' method.");
+    return (NULL);
+  }
+
+  m_addchild = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
+      "addChild", "(Lorg/collectd/api/OConfigItem;)V");
+  if (m_addchild == NULL)
+  {
+    ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
+        "`addChild (OConfigItem)' method.");
+    return (NULL);
+  }
+  /* }}} */
+
+  /* Create a String object with the key.
+   * Needed for calling the constructor. */
+  o_key = (*jvm_env)->NewStringUTF (jvm_env, ci->key);
+  if (o_key == NULL)
+  {
+    ERROR ("java plugin: ctoj_oconfig_item: "
+        "Creating String object failed.");
+    return (NULL);
+  }
+
+  /* Create an OConfigItem object */
+  o_ocitem = (*jvm_env)->NewObject (jvm_env,
+      c_ocitem, m_ocitem_constructor, o_key);
+  if (o_ocitem == NULL)
+  {
+    ERROR ("java plugin: ctoj_oconfig_item: "
+        "Creating an OConfigItem object failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_key);
+    return (NULL);
+  }
+
+  /* We don't need the String object any longer.. */
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_key);
+
+  /* Call OConfigItem.addValue for each value */
+  for (i = 0; i < ci->values_num; i++) /* {{{ */
+  {
+    jobject o_value;
+
+    o_value = ctoj_oconfig_value (jvm_env, ci->values[i]);
+    if (o_value == NULL)
+    {
+      ERROR ("java plugin: ctoj_oconfig_item: "
+          "Creating an OConfigValue object failed.");
+      (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
+      return (NULL);
+    }
+
+    (*jvm_env)->CallVoidMethod (jvm_env, o_ocitem, m_addvalue, o_value);
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_value);
+  } /* }}} for (i = 0; i < ci->values_num; i++) */
+
+  /* Call OConfigItem.addChild for each child */
+  for (i = 0; i < ci->children_num; i++) /* {{{ */
+  {
+    jobject o_child;
+
+    o_child = ctoj_oconfig_item (jvm_env, ci->children + i);
+    if (o_child == NULL)
+    {
+      ERROR ("java plugin: ctoj_oconfig_item: "
+          "Creating an OConfigItem object failed.");
+      (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
+      return (NULL);
+    }
+
+    (*jvm_env)->CallVoidMethod (jvm_env, o_ocitem, m_addchild, o_child);
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_child);
+  } /* }}} for (i = 0; i < ci->children_num; i++) */
+
+  return (o_ocitem);
+} /* }}} jobject ctoj_oconfig_item */
+
+/* Convert a data_set_t to a org/collectd/api/DataSet */
+static jobject ctoj_data_set (JNIEnv *jvm_env, const data_set_t *ds) /* {{{ */
+{
+  jclass c_dataset;
+  jmethodID m_constructor;
+  jmethodID m_add;
+  jobject o_type;
+  jobject o_dataset;
+  int i;
+
+  /* Look up the org/collectd/api/DataSet class */
+  c_dataset = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/DataSet");
+  if (c_dataset == NULL)
+  {
+    ERROR ("java plugin: ctoj_data_set: Looking up the "
+        "org/collectd/api/DataSet class failed.");
+    return (NULL);
+  }
+
+  /* Search for the `DataSet (String type)' constructor. */
+  m_constructor = (*jvm_env)->GetMethodID (jvm_env,
+      c_dataset, "<init>", "(Ljava.lang.String;)V");
+  if (m_constructor == NULL)
+  {
+    ERROR ("java plugin: ctoj_data_set: Looking up the "
+        "`DataSet (String)' constructor failed.");
+    return (NULL);
+  }
+
+  /* Search for the `void addDataSource (DataSource)' method. */
+  m_add = (*jvm_env)->GetMethodID (jvm_env,
+      c_dataset, "addDataSource", "(Lorg/collectd/api/DataSource;)V");
+  if (m_add == NULL)
+  {
+    ERROR ("java plugin: ctoj_data_set: Looking up the "
+        "`addDataSource (DataSource)' method failed.");
+    return (NULL);
+  }
+
+  o_type = (*jvm_env)->NewStringUTF (jvm_env, ds->type);
+  if (o_type == NULL)
+  {
+    ERROR ("java plugin: ctoj_data_set: Creating a String object failed.");
+    return (NULL);
+  }
+
+  o_dataset = (*jvm_env)->NewObject (jvm_env,
+      c_dataset, m_constructor, o_type);
+  if (o_dataset == NULL)
+  {
+    ERROR ("java plugin: ctoj_data_set: Creating a DataSet object failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_type);
+    return (NULL);
+  }
+
+  /* Decrease reference counter on the java.lang.String object. */
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_type);
+
+  for (i = 0; i < ds->ds_num; i++)
+  {
+    jobject o_datasource;
+
+    o_datasource = ctoj_data_source (jvm_env, ds->ds + i);
+    if (o_datasource == NULL)
+    {
+      ERROR ("java plugin: ctoj_data_set: ctoj_data_source (%s.%s) failed",
+          ds->type, ds->ds[i].name);
+      (*jvm_env)->DeleteLocalRef (jvm_env, o_dataset);
+      return (NULL);
+    }
+
+    (*jvm_env)->CallVoidMethod (jvm_env, o_dataset, m_add, o_datasource);
+
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+  } /* for (i = 0; i < ds->ds_num; i++) */
+
+  return (o_dataset);
+} /* }}} jobject ctoj_data_set */
+
+static int ctoj_value_list_add_value (JNIEnv *jvm_env, /* {{{ */
+    value_t value, int ds_type,
+    jclass class_ptr, jobject object_ptr)
+{
+  jmethodID m_addvalue;
+  jobject o_number;
+
+  m_addvalue = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      "addValue", "(Ljava/lang/Number;)V");
+  if (m_addvalue == NULL)
+  {
+    ERROR ("java plugin: ctoj_value_list_add_value: "
+        "Cannot find method `void addValue (Number)'.");
+    return (-1);
+  }
+
+  o_number = ctoj_value_to_number (jvm_env, value, ds_type);
+  if (o_number == NULL)
+  {
+    ERROR ("java plugin: ctoj_value_list_add_value: "
+        "ctoj_value_to_number failed.");
+    return (-1);
+  }
+
+  (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_addvalue, o_number);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_number);
+
+  return (0);
+} /* }}} int ctoj_value_list_add_value */
+
+static int ctoj_value_list_add_data_set (JNIEnv *jvm_env, /* {{{ */
+    jclass c_valuelist, jobject o_valuelist, const data_set_t *ds)
+{
+  jmethodID m_setdataset;
+  jobject o_dataset;
+
+  /* Look for the `void setDataSource (List<DataSource> ds)' method. */
+  m_setdataset = (*jvm_env)->GetMethodID (jvm_env, c_valuelist,
+      "setDataSet", "(Lorg/collectd/api/DataSet;)V");
+  if (m_setdataset == NULL)
+  {
+    ERROR ("java plugin: ctoj_value_list_add_data_set: "
+        "Cannot find the `void setDataSet (DataSet)' method.");
+    return (-1);
+  }
+
+  /* Create a DataSet object. */
+  o_dataset = ctoj_data_set (jvm_env, ds);
+  if (o_dataset == NULL)
+  {
+    ERROR ("java plugin: ctoj_value_list_add_data_set: "
+        "ctoj_data_set (%s) failed.", ds->type);
+    return (-1);
+  }
+
+  /* Actually call the method. */
+  (*jvm_env)->CallVoidMethod (jvm_env,
+      o_valuelist, m_setdataset, o_dataset);
+
+  /* Decrease reference counter on the List<DataSource> object. */
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_dataset);
+
+  return (0);
+} /* }}} int ctoj_value_list_add_data_set */
+
+/* Convert a value_list_t (and data_set_t) to a org/collectd/api/ValueList */
+static jobject ctoj_value_list (JNIEnv *jvm_env, /* {{{ */
+    const data_set_t *ds, const value_list_t *vl)
+{
+  jclass c_valuelist;
+  jmethodID m_valuelist_constructor;
+  jobject o_valuelist;
+  int status;
+  int i;
+
+  /* First, create a new ValueList instance..
+   * Look up the class.. */
+  c_valuelist = (*jvm_env)->FindClass (jvm_env,
+      "org/collectd/api/ValueList");
+  if (c_valuelist == NULL)
+  {
+    ERROR ("java plugin: ctoj_value_list: "
+        "FindClass (org/collectd/api/ValueList) failed.");
+    return (NULL);
+  }
+
+  /* Lookup the `ValueList ()' constructor. */
+  m_valuelist_constructor = (*jvm_env)->GetMethodID (jvm_env, c_valuelist,
+      "<init>", "()V");
+  if (m_valuelist_constructor == NULL)
+  {
+    ERROR ("java plugin: ctoj_value_list: Cannot find the "
+        "`ValueList ()' constructor.");
+    return (NULL);
+  }
+
+  /* Create a new instance. */
+  o_valuelist = (*jvm_env)->NewObject (jvm_env, c_valuelist,
+      m_valuelist_constructor);
+  if (o_valuelist == NULL)
+  {
+    ERROR ("java plugin: ctoj_value_list: Creating a new ValueList instance "
+        "failed.");
+    return (NULL);
+  }
+
+  status = ctoj_value_list_add_data_set (jvm_env,
+      c_valuelist, o_valuelist, ds);
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_value_list: "
+        "ctoj_value_list_add_data_set failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
+    return (NULL);
+  }
+
+  /* Set the strings.. */
+#define SET_STRING(str,method_name) do { \
+  status = ctoj_string (jvm_env, str, \
+      c_valuelist, o_valuelist, method_name); \
+  if (status != 0) { \
+    ERROR ("java plugin: ctoj_value_list: ctoj_string (%s) failed.", \
+        method_name); \
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist); \
+    return (NULL); \
+  } } while (0)
+
+  SET_STRING (vl->host,            "setHost");
+  SET_STRING (vl->plugin,          "setPlugin");
+  SET_STRING (vl->plugin_instance, "setPluginInstance");
+  SET_STRING (vl->type,            "setType");
+  SET_STRING (vl->type_instance,   "setTypeInstance");
+
+#undef SET_STRING
+
+  /* Set the `time' member. Java stores time in milliseconds. */
+  status = ctoj_long (jvm_env, ((jlong) vl->time) * ((jlong) 1000),
+      c_valuelist, o_valuelist, "setTime");
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_value_list: ctoj_long (setTime) failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
+    return (NULL);
+  }
+
+  /* Set the `interval' member.. */
+  status = ctoj_long (jvm_env, (jlong) vl->interval,
+      c_valuelist, o_valuelist, "setInterval");
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_value_list: ctoj_long (setInterval) failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
+    return (NULL);
+  }
+
+  for (i = 0; i < vl->values_len; i++)
+  {
+    status = ctoj_value_list_add_value (jvm_env, vl->values[i], ds->ds[i].type,
+        c_valuelist, o_valuelist);
+    if (status != 0)
+    {
+      ERROR ("java plugin: ctoj_value_list: "
+          "ctoj_value_list_add_value failed.");
+      (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
+      return (NULL);
+    }
+  }
+
+  return (o_valuelist);
+} /* }}} jobject ctoj_value_list */
+
+/* Convert a notification_t to a org/collectd/api/Notification */
+static jobject ctoj_notification (JNIEnv *jvm_env, /* {{{ */
+    const notification_t *n)
+{
+  jclass c_notification;
+  jmethodID m_constructor;
+  jobject o_notification;
+  int status;
+
+  /* First, create a new Notification instance..
+   * Look up the class.. */
+  c_notification = (*jvm_env)->FindClass (jvm_env,
+      "org/collectd/api/Notification");
+  if (c_notification == NULL)
+  {
+    ERROR ("java plugin: ctoj_notification: "
+        "FindClass (org/collectd/api/Notification) failed.");
+    return (NULL);
+  }
+
+  /* Lookup the `Notification ()' constructor. */
+  m_constructor = (*jvm_env)->GetMethodID (jvm_env, c_notification,
+      "<init>", "()V");
+  if (m_constructor == NULL)
+  {
+    ERROR ("java plugin: ctoj_notification: Cannot find the "
+        "`Notification ()' constructor.");
+    return (NULL);
+  }
+
+  /* Create a new instance. */
+  o_notification = (*jvm_env)->NewObject (jvm_env, c_notification,
+      m_constructor);
+  if (o_notification == NULL)
+  {
+    ERROR ("java plugin: ctoj_notification: Creating a new Notification "
+        "instance failed.");
+    return (NULL);
+  }
+
+  /* Set the strings.. */
+#define SET_STRING(str,method_name) do { \
+  status = ctoj_string (jvm_env, str, \
+      c_notification, o_notification, method_name); \
+  if (status != 0) { \
+    ERROR ("java plugin: ctoj_notification: ctoj_string (%s) failed.", \
+        method_name); \
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_notification); \
+    return (NULL); \
+  } } while (0)
+
+  SET_STRING (n->host,            "setHost");
+  SET_STRING (n->plugin,          "setPlugin");
+  SET_STRING (n->plugin_instance, "setPluginInstance");
+  SET_STRING (n->type,            "setType");
+  SET_STRING (n->type_instance,   "setTypeInstance");
+  SET_STRING (n->message,         "setMessage");
+
+#undef SET_STRING
+
+  /* Set the `time' member. Java stores time in milliseconds. */
+  status = ctoj_long (jvm_env, ((jlong) n->time) * ((jlong) 1000),
+      c_notification, o_notification, "setTime");
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_notification: ctoj_long (setTime) failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
+    return (NULL);
+  }
+
+  /* Set the `interval' member.. */
+  status = ctoj_int (jvm_env, (jint) n->severity,
+      c_notification, o_notification, "setSeverity");
+  if (status != 0)
+  {
+    ERROR ("java plugin: ctoj_notification: ctoj_int (setSeverity) failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
+    return (NULL);
+  }
+
+  return (o_notification);
+} /* }}} jobject ctoj_notification */
+
+/*
+ * Java to C conversion functions
+ */
+/* Call a `String <method> ()' method. */
+static int jtoc_string (JNIEnv *jvm_env, /* {{{ */
+    char *buffer, size_t buffer_size, int empty_okay,
+    jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+  jmethodID method_id;
+  jobject string_obj;
+  const char *c_str;
+
+  method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      method_name, "()Ljava/lang/String;");
+  if (method_id == NULL)
+  {
+    ERROR ("java plugin: jtoc_string: Cannot find method `String %s ()'.",
+        method_name);
+    return (-1);
+  }
+
+  string_obj = (*jvm_env)->CallObjectMethod (jvm_env, object_ptr, method_id);
+  if ((string_obj == NULL) && (empty_okay == 0))
+  {
+    ERROR ("java plugin: jtoc_string: CallObjectMethod (%s) failed.",
+        method_name);
+    return (-1);
+  }
+  else if ((string_obj == NULL) && (empty_okay != 0))
+  {
+    memset (buffer, 0, buffer_size);
+    return (0);
+  }
+
+  c_str = (*jvm_env)->GetStringUTFChars (jvm_env, string_obj, 0);
+  if (c_str == NULL)
+  {
+    ERROR ("java plugin: jtoc_string: GetStringUTFChars failed.");
+    (*jvm_env)->DeleteLocalRef (jvm_env, string_obj);
+    return (-1);
+  }
+
+  sstrncpy (buffer, c_str, buffer_size);
+
+  (*jvm_env)->ReleaseStringUTFChars (jvm_env, string_obj, c_str);
+  (*jvm_env)->DeleteLocalRef (jvm_env, string_obj);
+
+  return (0);
+} /* }}} int jtoc_string */
+
+/* Call an `int <method> ()' method. */
+static int jtoc_int (JNIEnv *jvm_env, /* {{{ */
+    jint *ret_value,
+    jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+  jmethodID method_id;
+
+  method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      method_name, "()I");
+  if (method_id == NULL)
+  {
+    ERROR ("java plugin: jtoc_int: Cannot find method `int %s ()'.",
+        method_name);
+    return (-1);
+  }
+
+  *ret_value = (*jvm_env)->CallIntMethod (jvm_env, object_ptr, method_id);
+
+  return (0);
+} /* }}} int jtoc_int */
+
+/* Call a `long <method> ()' method. */
+static int jtoc_long (JNIEnv *jvm_env, /* {{{ */
+    jlong *ret_value,
+    jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+  jmethodID method_id;
+
+  method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      method_name, "()J");
+  if (method_id == NULL)
+  {
+    ERROR ("java plugin: jtoc_long: Cannot find method `long %s ()'.",
+        method_name);
+    return (-1);
+  }
+
+  *ret_value = (*jvm_env)->CallLongMethod (jvm_env, object_ptr, method_id);
+
+  return (0);
+} /* }}} int jtoc_long */
+
+/* Call a `double <method> ()' method. */
+static int jtoc_double (JNIEnv *jvm_env, /* {{{ */
+    jdouble *ret_value,
+    jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+  jmethodID method_id;
+
+  method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      method_name, "()D");
+  if (method_id == NULL)
+  {
+    ERROR ("java plugin: jtoc_double: Cannot find method `double %s ()'.",
+        method_name);
+    return (-1);
+  }
+
+  *ret_value = (*jvm_env)->CallDoubleMethod (jvm_env, object_ptr, method_id);
+
+  return (0);
+} /* }}} int jtoc_double */
+
+static int jtoc_value (JNIEnv *jvm_env, /* {{{ */
+    value_t *ret_value, int ds_type, jobject object_ptr)
+{
+  jclass class_ptr;
+  int status;
+
+  class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
+
+  if (ds_type == DS_TYPE_COUNTER)
+  {
+    jlong tmp_long;
+
+    status = jtoc_long (jvm_env, &tmp_long,
+        class_ptr, object_ptr, "longValue");
+    if (status != 0)
+    {
+      ERROR ("java plugin: jtoc_value: "
+          "jtoc_long failed.");
+      return (-1);
+    }
+    (*ret_value).counter = (counter_t) tmp_long;
+  }
+  else
+  {
+    jdouble tmp_double;
+
+    status = jtoc_double (jvm_env, &tmp_double,
+        class_ptr, object_ptr, "doubleValue");
+    if (status != 0)
+    {
+      ERROR ("java plugin: jtoc_value: "
+          "jtoc_double failed.");
+      return (-1);
+    }
+    (*ret_value).gauge = (gauge_t) tmp_double;
+  }
+
+  return (0);
+} /* }}} int jtoc_value */
+
+/* Read a List<Number>, convert it to `value_t' and add it to the given
+ * `value_list_t'. */
+static int jtoc_values_array (JNIEnv *jvm_env, /* {{{ */
+    const data_set_t *ds, value_list_t *vl,
+    jclass class_ptr, jobject object_ptr)
+{
+  jmethodID m_getvalues;
+  jmethodID m_toarray;
+  jobject o_list;
+  jobjectArray o_number_array;
+
+  value_t *values;
+  int values_num;
+  int i;
+
+  values_num = ds->ds_num;
+
+  values = NULL;
+  o_number_array = NULL;
+  o_list = NULL;
+
+#define BAIL_OUT(status) \
+  free (values); \
+  if (o_number_array != NULL) \
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_number_array); \
+  if (o_list != NULL) \
+    (*jvm_env)->DeleteLocalRef (jvm_env, o_list); \
+  return (status);
+
+  /* Call: List<Number> ValueList.getValues () */
+  m_getvalues = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+      "getValues", "()Ljava/util/List;");
+  if (m_getvalues == NULL)
+  {
+    ERROR ("java plugin: jtoc_values_array: "
+        "Cannot find method `List getValues ()'.");
+    BAIL_OUT (-1);
+  }
+
+  o_list = (*jvm_env)->CallObjectMethod (jvm_env, object_ptr, m_getvalues);
+  if (o_list == NULL)
+  {
+    ERROR ("java plugin: jtoc_values_array: "
+        "CallObjectMethod (getValues) failed.");
+    BAIL_OUT (-1);
+  }
+
+  /* Call: Number[] List.toArray () */
+  m_toarray = (*jvm_env)->GetMethodID (jvm_env,
+      (*jvm_env)->GetObjectClass (jvm_env, o_list),
+      "toArray", "()[Ljava/lang/Object;");
+  if (m_toarray == NULL)
+  {
+    ERROR ("java plugin: jtoc_values_array: "
+        "Cannot find method `Object[] toArray ()'.");
+    BAIL_OUT (-1);
+  }
+
+  o_number_array = (*jvm_env)->CallObjectMethod (jvm_env, o_list, m_toarray);
+  if (o_number_array == NULL)
+  {
+    ERROR ("java plugin: jtoc_values_array: "
+        "CallObjectMethod (toArray) failed.");
+    BAIL_OUT (-1);
+  }
+
+  values = (value_t *) calloc (values_num, sizeof (value_t));
+  if (values == NULL)
+  {
+    ERROR ("java plugin: jtoc_values_array: calloc failed.");
+    BAIL_OUT (-1);
+  }
+
+  for (i = 0; i < values_num; i++)
+  {
+    jobject o_number;
+    int status;
+
+    o_number = (*jvm_env)->GetObjectArrayElement (jvm_env,
+        o_number_array, (jsize) i);
+    if (o_number == NULL)
+    {
+      ERROR ("java plugin: jtoc_values_array: "
+          "GetObjectArrayElement (%i) failed.", i);
+      BAIL_OUT (-1);
+    }
+
+    status = jtoc_value (jvm_env, values + i, ds->ds[i].type, o_number);
+    if (status != 0)
+    {
+      ERROR ("java plugin: jtoc_values_array: "
+          "jtoc_value (%i) failed.", i);
+      BAIL_OUT (-1);
+    }
+  } /* for (i = 0; i < values_num; i++) */
+
+  vl->values = values;
+  vl->values_len = values_num;
+
+#undef BAIL_OUT
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_number_array);
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_list);
+  return (0);
+} /* }}} int jtoc_values_array */
+
+/* Convert a org/collectd/api/ValueList to a value_list_t. */
+static int jtoc_value_list (JNIEnv *jvm_env, value_list_t *vl, /* {{{ */
+    jobject object_ptr)
+{
+  jclass class_ptr;
+  int status;
+  jlong tmp_long;
+  const data_set_t *ds;
+
+  class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
+  if (class_ptr == NULL)
+  {
+    ERROR ("java plugin: jtoc_value_list: GetObjectClass failed.");
+    return (-1);
+  }
+
+  /* eo == empty okay */
+#define SET_STRING(buffer,method, eo) do { \
+  status = jtoc_string (jvm_env, buffer, sizeof (buffer), eo, \
+      class_ptr, object_ptr, method); \
+  if (status != 0) { \
+    ERROR ("java plugin: jtoc_value_list: jtoc_string (%s) failed.", \
+        method); \
+    return (-1); \
+  } } while (0)
+
+  SET_STRING(vl->type, "getType", /* empty = */ 0);
+
+  ds = plugin_get_ds (vl->type);
+  if (ds == NULL)
+  {
+    ERROR ("java plugin: jtoc_value_list: Data-set `%s' is not defined. "
+        "Please consult the types.db(5) manpage for mor information.",
+        vl->type);
+    return (-1);
+  }
+
+  SET_STRING(vl->host,            "getHost",           /* empty = */ 0);
+  SET_STRING(vl->plugin,          "getPlugin",         /* empty = */ 0);
+  SET_STRING(vl->plugin_instance, "getPluginInstance", /* empty = */ 1);
+  SET_STRING(vl->type_instance,   "getTypeInstance",   /* empty = */ 1);
+
+#undef SET_STRING
+
+  status = jtoc_long (jvm_env, &tmp_long, class_ptr, object_ptr, "getTime");
+  if (status != 0)
+  {
+    ERROR ("java plugin: jtoc_value_list: jtoc_long (getTime) failed.");
+    return (-1);
+  }
+  /* Java measures time in milliseconds. */
+  vl->time = (time_t) (tmp_long / ((jlong) 1000));
+
+  status = jtoc_long (jvm_env, &tmp_long,
+      class_ptr, object_ptr, "getInterval");
+  if (status != 0)
+  {
+    ERROR ("java plugin: jtoc_value_list: jtoc_long (getInterval) failed.");
+    return (-1);
+  }
+  vl->interval = (int) tmp_long;
+
+  status = jtoc_values_array (jvm_env, ds, vl, class_ptr, object_ptr);
+  if (status != 0)
+  {
+    ERROR ("java plugin: jtoc_value_list: jtoc_values_array failed.");
+    return (-1);
+  }
+
+  return (0);
+} /* }}} int jtoc_value_list */
+
+/* Convert a org/collectd/api/Notification to a notification_t. */
+static int jtoc_notification (JNIEnv *jvm_env, notification_t *n, /* {{{ */
+    jobject object_ptr)
+{
+  jclass class_ptr;
+  int status;
+  jlong tmp_long;
+  jint tmp_int;
+
+  class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
+  if (class_ptr == NULL)
+  {
+    ERROR ("java plugin: jtoc_notification: GetObjectClass failed.");
+    return (-1);
+  }
+
+  /* eo == empty okay */
+#define SET_STRING(buffer,method, eo) do { \
+  status = jtoc_string (jvm_env, buffer, sizeof (buffer), eo, \
+      class_ptr, object_ptr, method); \
+  if (status != 0) { \
+    ERROR ("java plugin: jtoc_notification: jtoc_string (%s) failed.", \
+        method); \
+    return (-1); \
+  } } while (0)
+
+  SET_STRING (n->host,            "getHost",           /* empty = */ 1);
+  SET_STRING (n->plugin,          "getPlugin",         /* empty = */ 1);
+  SET_STRING (n->plugin_instance, "getPluginInstance", /* empty = */ 1);
+  SET_STRING (n->type,            "getType",           /* empty = */ 1);
+  SET_STRING (n->type_instance,   "getTypeInstance",   /* empty = */ 1);
+  SET_STRING (n->message,         "getMessage",        /* empty = */ 0);
+
+#undef SET_STRING
+
+  status = jtoc_long (jvm_env, &tmp_long, class_ptr, object_ptr, "getTime");
+  if (status != 0)
+  {
+    ERROR ("java plugin: jtoc_notification: jtoc_long (getTime) failed.");
+    return (-1);
+  }
+  /* Java measures time in milliseconds. */
+  n->time = (time_t) (tmp_long / ((jlong) 1000));
+
+  status = jtoc_int (jvm_env, &tmp_int,
+      class_ptr, object_ptr, "getSeverity");
+  if (status != 0)
+  {
+    ERROR ("java plugin: jtoc_notification: jtoc_int (getSeverity) failed.");
+    return (-1);
+  }
+  n->severity = (int) tmp_int;
+
+  return (0);
+} /* }}} int jtoc_notification */
+/* 
+ * Functions accessible from Java
+ */
+static jint JNICALL cjni_api_dispatch_values (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject java_vl)
+{
+  value_list_t vl = VALUE_LIST_INIT;
+  int status;
+
+  DEBUG ("cjni_api_dispatch_values: java_vl = %p;", (void *) java_vl);
+
+  status = jtoc_value_list (jvm_env, &vl, java_vl);
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_api_dispatch_values: jtoc_value_list failed.");
+    return (-1);
+  }
+
+  status = plugin_dispatch_values (&vl);
+
+  sfree (vl.values);
+
+  return (status);
+} /* }}} jint cjni_api_dispatch_values */
+
+static jint JNICALL cjni_api_dispatch_notification (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_notification)
+{
+  notification_t n;
+  int status;
+
+  memset (&n, 0, sizeof (n));
+  n.meta = NULL;
+
+  status = jtoc_notification (jvm_env, &n, o_notification);
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_api_dispatch_notification: jtoc_notification failed.");
+    return (-1);
+  }
+
+  status = plugin_dispatch_notification (&n);
+
+  return (status);
+} /* }}} jint cjni_api_dispatch_notification */
+
+static jobject JNICALL cjni_api_get_ds (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_string_type)
+{
+  const char *ds_name;
+  const data_set_t *ds;
+  jobject o_dataset;
+
+  ds_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_string_type, 0);
+  if (ds_name == NULL)
+  {
+    ERROR ("java plugin: cjni_api_get_ds: GetStringUTFChars failed.");
+    return (NULL);
+  }
+
+  ds = plugin_get_ds (ds_name);
+  DEBUG ("java plugin: cjni_api_get_ds: "
+      "plugin_get_ds (%s) = %p;", ds_name, (void *) ds);
+
+  (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_string_type, ds_name);
+
+  if (ds == NULL)
+    return (NULL);
+
+  o_dataset = ctoj_data_set (jvm_env, ds);
+  return (o_dataset);
+} /* }}} jint cjni_api_get_ds */
+
+static jint JNICALL cjni_api_register_config (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_config)
+{
+  return (cjni_callback_register (jvm_env, o_name, o_config, CB_TYPE_CONFIG));
+} /* }}} jint cjni_api_register_config */
+
+static jint JNICALL cjni_api_register_init (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_config)
+{
+  return (cjni_callback_register (jvm_env, o_name, o_config, CB_TYPE_INIT));
+} /* }}} jint cjni_api_register_init */
+
+static jint JNICALL cjni_api_register_read (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_read)
+{
+  user_data_t ud;
+  cjni_callback_info_t *cbi;
+
+  cbi = cjni_callback_info_create (jvm_env, o_name, o_read, CB_TYPE_READ);
+  if (cbi == NULL)
+    return (-1);
+
+  DEBUG ("java plugin: Registering new read callback: %s", cbi->name);
+
+  memset (&ud, 0, sizeof (ud));
+  ud.data = (void *) cbi;
+  ud.free_func = cjni_callback_info_destroy;
+
+  plugin_register_complex_read (cbi->name, cjni_read,
+      /* interval = */ NULL, &ud);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_read);
+
+  return (0);
+} /* }}} jint cjni_api_register_read */
+
+static jint JNICALL cjni_api_register_write (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_write)
+{
+  user_data_t ud;
+  cjni_callback_info_t *cbi;
+
+  cbi = cjni_callback_info_create (jvm_env, o_name, o_write, CB_TYPE_WRITE);
+  if (cbi == NULL)
+    return (-1);
+
+  DEBUG ("java plugin: Registering new write callback: %s", cbi->name);
+
+  memset (&ud, 0, sizeof (ud));
+  ud.data = (void *) cbi;
+  ud.free_func = cjni_callback_info_destroy;
+
+  plugin_register_write (cbi->name, cjni_write, &ud);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_write);
+
+  return (0);
+} /* }}} jint cjni_api_register_write */
+
+static jint JNICALL cjni_api_register_flush (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_flush)
+{
+  user_data_t ud;
+  cjni_callback_info_t *cbi;
+
+  cbi = cjni_callback_info_create (jvm_env, o_name, o_flush, CB_TYPE_FLUSH);
+  if (cbi == NULL)
+    return (-1);
+
+  DEBUG ("java plugin: Registering new flush callback: %s", cbi->name);
+
+  memset (&ud, 0, sizeof (ud));
+  ud.data = (void *) cbi;
+  ud.free_func = cjni_callback_info_destroy;
+
+  plugin_register_flush (cbi->name, cjni_flush, &ud);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_flush);
+
+  return (0);
+} /* }}} jint cjni_api_register_flush */
+
+static jint JNICALL cjni_api_register_shutdown (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_shutdown)
+{
+  return (cjni_callback_register (jvm_env, o_name, o_shutdown,
+        CB_TYPE_SHUTDOWN));
+} /* }}} jint cjni_api_register_shutdown */
+
+static jint JNICALL cjni_api_register_log (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_log)
+{
+  user_data_t ud;
+  cjni_callback_info_t *cbi;
+
+  cbi = cjni_callback_info_create (jvm_env, o_name, o_log, CB_TYPE_LOG);
+  if (cbi == NULL)
+    return (-1);
+
+  DEBUG ("java plugin: Registering new log callback: %s", cbi->name);
+
+  memset (&ud, 0, sizeof (ud));
+  ud.data = (void *) cbi;
+  ud.free_func = cjni_callback_info_destroy;
+
+  plugin_register_log (cbi->name, cjni_log, &ud);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_log);
+
+  return (0);
+} /* }}} jint cjni_api_register_log */
+
+static jint JNICALL cjni_api_register_notification (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_notification)
+{
+  user_data_t ud;
+  cjni_callback_info_t *cbi;
+
+  cbi = cjni_callback_info_create (jvm_env, o_name, o_notification,
+      CB_TYPE_NOTIFICATION);
+  if (cbi == NULL)
+    return (-1);
+
+  DEBUG ("java plugin: Registering new notification callback: %s", cbi->name);
+
+  memset (&ud, 0, sizeof (ud));
+  ud.data = (void *) cbi;
+  ud.free_func = cjni_callback_info_destroy;
+
+  plugin_register_notification (cbi->name, cjni_notification, &ud);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
+
+  return (0);
+} /* }}} jint cjni_api_register_notification */
+
+static jint JNICALL cjni_api_register_match_target (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_match, int type)
+{
+  int status;
+  const char *c_name;
+
+  c_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_name, 0);
+  if (c_name == NULL)
+  {
+    ERROR ("java plugin: cjni_api_register_match_target: "
+        "GetStringUTFChars failed.");
+    return (-1);
+  }
+
+  status = cjni_callback_register (jvm_env, o_name, o_match, type);
+  if (status != 0)
+  {
+    (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+    return (-1);
+  }
+
+  if (type == CB_TYPE_MATCH)
+  {
+    match_proc_t m_proc;
+
+    memset (&m_proc, 0, sizeof (m_proc));
+    m_proc.create  = cjni_match_target_create;
+    m_proc.destroy = cjni_match_target_destroy;
+    m_proc.match   = (void *) cjni_match_target_invoke;
+
+    status = fc_register_match (c_name, m_proc);
+  }
+  else if (type == CB_TYPE_TARGET)
+  {
+    target_proc_t t_proc;
+
+    memset (&t_proc, 0, sizeof (t_proc));
+    t_proc.create  = cjni_match_target_create;
+    t_proc.destroy = cjni_match_target_destroy;
+    t_proc.invoke  = cjni_match_target_invoke;
+
+    status = fc_register_target (c_name, t_proc);
+  }
+  else
+  {
+    ERROR ("java plugin: cjni_api_register_match_target: "
+        "Don't know whether to create a match or a target.");
+    (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+    return (-1);
+  }
+
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_api_register_match_target: "
+        "%s failed.",
+        (type == CB_TYPE_MATCH) ? "fc_register_match" : "fc_register_target");
+    (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+    return (-1);
+  }
+
+  (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+
+  return (0);
+} /* }}} jint cjni_api_register_match_target */
+
+static jint JNICALL cjni_api_register_match (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_match)
+{
+  return (cjni_api_register_match_target (jvm_env, this, o_name, o_match,
+        CB_TYPE_MATCH));
+} /* }}} jint cjni_api_register_match */
+
+static jint JNICALL cjni_api_register_target (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jobject o_name, jobject o_target)
+{
+  return (cjni_api_register_match_target (jvm_env, this, o_name, o_target,
+        CB_TYPE_TARGET));
+} /* }}} jint cjni_api_register_target */
+
+static void JNICALL cjni_api_log (JNIEnv *jvm_env, /* {{{ */
+    jobject this, jint severity, jobject o_message)
+{
+  const char *c_str;
+
+  c_str = (*jvm_env)->GetStringUTFChars (jvm_env, o_message, 0);
+  if (c_str == NULL)
+  {
+    ERROR ("java plugin: cjni_api_log: GetStringUTFChars failed.");
+    return;
+  }
+
+  if (severity < LOG_ERR)
+    severity = LOG_ERR;
+  if (severity > LOG_DEBUG)
+    severity = LOG_DEBUG;
+
+  plugin_log (severity, "%s", c_str);
+
+  (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_message, c_str);
+} /* }}} void cjni_api_log */
+
+/* List of ``native'' functions, i. e. C-functions that can be called from
+ * Java. */
+static JNINativeMethod jni_api_functions[] = /* {{{ */
+{
+  { "dispatchValues",
+    "(Lorg/collectd/api/ValueList;)I",
+    cjni_api_dispatch_values },
+
+  { "dispatchNotification",
+    "(Lorg/collectd/api/Notification;)I",
+    cjni_api_dispatch_notification },
+
+  { "getDS",
+    "(Ljava/lang/String;)Lorg/collectd/api/DataSet;",
+    cjni_api_get_ds },
+
+  { "registerConfig",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdConfigInterface;)I",
+    cjni_api_register_config },
+
+  { "registerInit",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdInitInterface;)I",
+    cjni_api_register_init },
+
+  { "registerRead",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdReadInterface;)I",
+    cjni_api_register_read },
+
+  { "registerWrite",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdWriteInterface;)I",
+    cjni_api_register_write },
+
+  { "registerFlush",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdFlushInterface;)I",
+    cjni_api_register_flush },
+
+  { "registerShutdown",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdShutdownInterface;)I",
+    cjni_api_register_shutdown },
+
+  { "registerLog",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdLogInterface;)I",
+    cjni_api_register_log },
+
+  { "registerNotification",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdNotificationInterface;)I",
+    cjni_api_register_notification },
+
+  { "registerMatch",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdMatchFactoryInterface;)I",
+    cjni_api_register_match },
+
+  { "registerTarget",
+    "(Ljava/lang/String;Lorg/collectd/api/CollectdTargetFactoryInterface;)I",
+    cjni_api_register_target },
+
+  { "log",
+    "(ILjava/lang/String;)V",
+    cjni_api_log },
+};
+static size_t jni_api_functions_num = sizeof (jni_api_functions)
+  / sizeof (jni_api_functions[0]);
+/* }}} */
+
+/*
+ * Functions
+ */
+/* Allocate a `cjni_callback_info_t' given the type and objects necessary for
+ * all registration functions. */
+static cjni_callback_info_t *cjni_callback_info_create (JNIEnv *jvm_env, /* {{{ */
+    jobject o_name, jobject o_callback, int type)
+{
+  const char *c_name;
+  cjni_callback_info_t *cbi;
+  const char *method_name;
+  const char *method_signature;
+
+  switch (type)
+  {
+    case CB_TYPE_CONFIG:
+      method_name = "config";
+      method_signature = "(Lorg/collectd/api/OConfigItem;)I";
+      break;
+
+    case CB_TYPE_INIT:
+      method_name = "init";
+      method_signature = "()I";
+      break;
+
+    case CB_TYPE_READ:
+      method_name = "read";
+      method_signature = "()I";
+      break;
+
+    case CB_TYPE_WRITE:
+      method_name = "write";
+      method_signature = "(Lorg/collectd/api/ValueList;)I";
+      break;
+
+    case CB_TYPE_FLUSH:
+      method_name = "flush";
+      method_signature = "(ILjava/lang/String;)I";
+      break;
+
+    case CB_TYPE_SHUTDOWN:
+      method_name = "shutdown";
+      method_signature = "()I";
+      break;
+
+    case CB_TYPE_LOG:
+      method_name = "log";
+      method_signature = "(ILjava/lang/String;)V";
+      break;
+
+    case CB_TYPE_NOTIFICATION:
+      method_name = "notification";
+      method_signature = "(Lorg/collectd/api/Notification;)I";
+      break;
+
+    case CB_TYPE_MATCH:
+      method_name = "createMatch";
+      method_signature = "(Lorg/collectd/api/OConfigItem;)"
+        "Lorg/collectd/api/CollectdMatchInterface;";
+      break;
+
+    case CB_TYPE_TARGET:
+      method_name = "createTarget";
+      method_signature = "(Lorg/collectd/api/OConfigItem;)"
+        "Lorg/collectd/api/CollectdTargetInterface;";
+      break;
+
+    default:
+      ERROR ("java plugin: cjni_callback_info_create: Unknown type: %#x",
+          type);
+      return (NULL);
+  }
+
+  c_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_name, 0);
+  if (c_name == NULL)
+  {
+    ERROR ("java plugin: cjni_callback_info_create: "
+        "GetStringUTFChars failed.");
+    return (NULL);
+  }
+
+  cbi = (cjni_callback_info_t *) malloc (sizeof (*cbi));
+  if (cbi == NULL)
+  {
+    ERROR ("java plugin: cjni_callback_info_create: malloc failed.");
+    (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+    return (NULL);
+  }
+  memset (cbi, 0, sizeof (*cbi));
+  cbi->type = type;
+
+  cbi->name = strdup (c_name);
+  if (cbi->name == NULL)
+  {
+    pthread_mutex_unlock (&java_callbacks_lock);
+    ERROR ("java plugin: cjni_callback_info_create: strdup failed.");
+    (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+    return (NULL);
+  }
+
+  (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+
+  cbi->object = (*jvm_env)->NewGlobalRef (jvm_env, o_callback);
+  if (cbi->object == NULL)
+  {
+    ERROR ("java plugin: cjni_callback_info_create: NewGlobalRef failed.");
+    free (cbi);
+    return (NULL);
+  }
+
+  cbi->class  = (*jvm_env)->GetObjectClass (jvm_env, cbi->object);
+  if (cbi->class == NULL)
+  {
+    ERROR ("java plugin: cjni_callback_info_create: GetObjectClass failed.");
+    free (cbi);
+    return (NULL);
+  }
+
+  cbi->method = (*jvm_env)->GetMethodID (jvm_env, cbi->class,
+      method_name, method_signature);
+  if (cbi->method == NULL)
+  {
+    ERROR ("java plugin: cjni_callback_info_create: "
+        "Cannot find the `%s' method with signature `%s'.",
+        method_name, method_signature);
+    free (cbi);
+    return (NULL);
+  }
+
+  return (cbi);
+} /* }}} cjni_callback_info_t cjni_callback_info_create */
+
+/* Allocate a `cjni_callback_info_t' via `cjni_callback_info_create' and add it
+ * to the global `java_callbacks' variable. This is used for `config', `init',
+ * and `shutdown' callbacks. */
+static int cjni_callback_register (JNIEnv *jvm_env, /* {{{ */
+    jobject o_name, jobject o_callback, int type)
+{
+  cjni_callback_info_t *cbi;
+  cjni_callback_info_t *tmp;
+#if COLLECT_DEBUG
+  const char *type_str;
+#endif
+
+  cbi = cjni_callback_info_create (jvm_env, o_name, o_callback, type);
+  if (cbi == NULL)
+    return (-1);
+
+#if COLLECT_DEBUG
+  switch (type)
+  {
+    case CB_TYPE_CONFIG:
+      type_str = "config";
+      break;
+
+    case CB_TYPE_INIT:
+      type_str = "init";
+      break;
+
+    case CB_TYPE_SHUTDOWN:
+      type_str = "shutdown";
+      break;
+
+    case CB_TYPE_MATCH:
+      type_str = "match";
+      break;
+
+    case CB_TYPE_TARGET:
+      type_str = "target";
+      break;
+
+    default:
+      type_str = "<unknown>";
+  }
+  DEBUG ("java plugin: Registering new %s callback: %s",
+      type_str, cbi->name);
+#endif
+
+  pthread_mutex_lock (&java_callbacks_lock);
+
+  tmp = (cjni_callback_info_t *) realloc (java_callbacks,
+      (java_callbacks_num + 1) * sizeof (*java_callbacks));
+  if (tmp == NULL)
+  {
+    pthread_mutex_unlock (&java_callbacks_lock);
+    ERROR ("java plugin: cjni_callback_register: realloc failed.");
+
+    (*jvm_env)->DeleteGlobalRef (jvm_env, cbi->object);
+    free (cbi);
+
+    return (-1);
+  }
+  java_callbacks = tmp;
+  java_callbacks[java_callbacks_num] = *cbi;
+  java_callbacks_num++;
+
+  pthread_mutex_unlock (&java_callbacks_lock);
+
+  free (cbi);
+  return (0);
+} /* }}} int cjni_callback_register */
+
+/* Callback for `pthread_key_create'. It frees the data contained in
+ * `jvm_env_key' and prints a warning if the reference counter is not zero. */
+static void cjni_jvm_env_destroy (void *args) /* {{{ */
+{
+  cjni_jvm_env_t *cjni_env;
+
+  if (args == NULL)
+    return;
+
+  cjni_env = (cjni_jvm_env_t *) args;
+
+  if (cjni_env->reference_counter > 0)
+  {
+    ERROR ("java plugin: cjni_jvm_env_destroy: "
+        "cjni_env->reference_counter = %i;", cjni_env->reference_counter);
+  }
+
+  if (cjni_env->jvm_env != NULL)
+  {
+    ERROR ("java plugin: cjni_jvm_env_destroy: cjni_env->jvm_env = %p;",
+        (void *) cjni_env->jvm_env);
+  }
+
+  /* The pointer is allocated in `cjni_thread_attach' */
+  free (cjni_env);
+} /* }}} void cjni_jvm_env_destroy */
+
+/* Register ``native'' functions with the JVM. Native functions are C-functions
+ * that can be called by Java code. */
+static int cjni_init_native (JNIEnv *jvm_env) /* {{{ */
+{
+  jclass api_class_ptr;
+  int status;
+
+  api_class_ptr = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/Collectd");
+  if (api_class_ptr == NULL)
+  {
+    ERROR ("cjni_init_native: Cannot find API class `org/collectd/api/Collectd'.");
+    return (-1);
+  }
+
+  status = (*jvm_env)->RegisterNatives (jvm_env, api_class_ptr,
+      jni_api_functions, (jint) jni_api_functions_num);
+  if (status != 0)
+  {
+    ERROR ("cjni_init_native: RegisterNatives failed with status %i.", status);
+    return (-1);
+  }
+
+  return (0);
+} /* }}} int cjni_init_native */
+
+/* Create the JVM. This is called when the first thread tries to access the JVM
+ * via cjni_thread_attach. */
+static int cjni_create_jvm (void) /* {{{ */
+{
+  JNIEnv *jvm_env;
+  JavaVMInitArgs vm_args;
+  JavaVMOption vm_options[jvm_argc];
+
+  int status;
+  size_t i;
+
+  if (jvm != NULL)
+    return (0);
+
+  status = pthread_key_create (&jvm_env_key, cjni_jvm_env_destroy);
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_create_jvm: pthread_key_create failed "
+        "with status %i.", status);
+    return (-1);
+  }
+
+  jvm_env = NULL;
+
+  memset (&vm_args, 0, sizeof (vm_args));
+  vm_args.version = JNI_VERSION_1_2;
+  vm_args.options = vm_options;
+  vm_args.nOptions = (jint) jvm_argc;
+
+  for (i = 0; i < jvm_argc; i++)
+  {
+    DEBUG ("java plugin: cjni_create_jvm: jvm_argv[%zu] = %s",
+        i, jvm_argv[i]);
+    vm_args.options[i].optionString = jvm_argv[i];
+  }
+
+  status = JNI_CreateJavaVM (&jvm, (void *) &jvm_env, (void *) &vm_args);
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_create_jvm: "
+        "JNI_CreateJavaVM failed with status %i.",
+       status);
+    return (-1);
+  }
+  assert (jvm != NULL);
+  assert (jvm_env != NULL);
+
+  /* Call RegisterNatives */
+  status = cjni_init_native (jvm_env);
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_create_jvm: cjni_init_native failed.");
+    return (-1);
+  }
+
+  DEBUG ("java plugin: The JVM has been created.");
+  return (0);
+} /* }}} int cjni_create_jvm */
+
+/* Increase the reference counter to the JVM for this thread. If it was zero,
+ * attach the JVM first. */
+static JNIEnv *cjni_thread_attach (void) /* {{{ */
+{
+  cjni_jvm_env_t *cjni_env;
+  JNIEnv *jvm_env;
+
+  /* If we're the first thread to access the JVM, we'll have to create it
+   * first.. */
+  if (jvm == NULL)
+  {
+    int status;
+
+    status = cjni_create_jvm ();
+    if (status != 0)
+    {
+      ERROR ("java plugin: cjni_thread_attach: cjni_create_jvm failed.");
+      return (NULL);
+    }
+  }
+  assert (jvm != NULL);
+
+  cjni_env = pthread_getspecific (jvm_env_key);
+  if (cjni_env == NULL)
+  {
+    /* This pointer is free'd in `cjni_jvm_env_destroy'. */
+    cjni_env = (cjni_jvm_env_t *) malloc (sizeof (*cjni_env));
+    if (cjni_env == NULL)
+    {
+      ERROR ("java plugin: cjni_thread_attach: malloc failed.");
+      return (NULL);
+    }
+    memset (cjni_env, 0, sizeof (*cjni_env));
+    cjni_env->reference_counter = 0;
+    cjni_env->jvm_env = NULL;
+
+    pthread_setspecific (jvm_env_key, cjni_env);
+  }
+
+  if (cjni_env->reference_counter > 0)
+  {
+    cjni_env->reference_counter++;
+    jvm_env = cjni_env->jvm_env;
+  }
+  else
+  {
+    int status;
+    JavaVMAttachArgs args;
+
+    assert (cjni_env->jvm_env == NULL);
+
+    memset (&args, 0, sizeof (args));
+    args.version = JNI_VERSION_1_2;
+
+    status = (*jvm)->AttachCurrentThread (jvm, (void *) &jvm_env, (void *) &args);
+    if (status != 0)
+    {
+      ERROR ("java plugin: cjni_thread_attach: AttachCurrentThread failed "
+          "with status %i.", status);
+      return (NULL);
+    }
+
+    cjni_env->reference_counter = 1;
+    cjni_env->jvm_env = jvm_env;
+  }
+
+  DEBUG ("java plugin: cjni_thread_attach: cjni_env->reference_counter = %i",
+      cjni_env->reference_counter);
+  assert (jvm_env != NULL);
+  return (jvm_env);
+} /* }}} JNIEnv *cjni_thread_attach */
+
+/* Decrease the reference counter of this thread. If it reaches zero, detach
+ * from the JVM. */
+static int cjni_thread_detach (void) /* {{{ */
+{
+  cjni_jvm_env_t *cjni_env;
+  int status;
+
+  cjni_env = pthread_getspecific (jvm_env_key);
+  if (cjni_env == NULL)
+  {
+    ERROR ("java plugin: cjni_thread_detach: pthread_getspecific failed.");
+    return (-1);
+  }
+
+  assert (cjni_env->reference_counter > 0);
+  assert (cjni_env->jvm_env != NULL);
+
+  cjni_env->reference_counter--;
+  DEBUG ("java plugin: cjni_thread_detach: cjni_env->reference_counter = %i",
+      cjni_env->reference_counter);
+
+  if (cjni_env->reference_counter > 0)
+    return (0);
+
+  status = (*jvm)->DetachCurrentThread (jvm);
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_thread_detach: DetachCurrentThread failed "
+        "with status %i.", status);
+  }
+
+  cjni_env->reference_counter = 0;
+  cjni_env->jvm_env = NULL;
+
+  return (0);
+} /* }}} JNIEnv *cjni_thread_attach */
+
+static int cjni_config_add_jvm_arg (oconfig_item_t *ci) /* {{{ */
+{
+  char **tmp;
+
+  if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("java plugin: `JVMArg' needs exactly one string argument.");
+    return (-1);
+  }
+
+  if (jvm != NULL)
+  {
+    ERROR ("java plugin: All `JVMArg' options MUST appear before all "
+        "`LoadPlugin' options! The JVM is already started and I have to "
+        "ignore this argument: %s",
+        ci->values[0].value.string);
+    return (-1);
+  }
+
+  tmp = (char **) realloc (jvm_argv, sizeof (char *) * (jvm_argc + 1));
+  if (tmp == NULL)
+  {
+    ERROR ("java plugin: realloc failed.");
+    return (-1);
+  }
+  jvm_argv = tmp;
+
+  jvm_argv[jvm_argc] = strdup (ci->values[0].value.string);
+  if (jvm_argv[jvm_argc] == NULL)
+  {
+    ERROR ("java plugin: strdup failed.");
+    return (-1);
+  }
+  jvm_argc++;
+
+  return (0);
+} /* }}} int cjni_config_add_jvm_arg */
+
+static int cjni_config_load_plugin (oconfig_item_t *ci) /* {{{ */
+{
+  JNIEnv *jvm_env;
+  java_plugin_class_t *class;
+  jmethodID constructor_id;
+  jobject tmp_object;
+
+  if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("java plugin: `LoadPlugin' needs exactly one string argument.");
+    return (-1);
+  }
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return (-1);
+
+  class = (java_plugin_class_t *) realloc (java_classes_list,
+      (java_classes_list_len + 1) * sizeof (*java_classes_list));
+  if (class == NULL)
+  {
+    ERROR ("java plugin: realloc failed.");
+    cjni_thread_detach ();
+    return (-1);
+  }
+  java_classes_list = class;
+  class = java_classes_list + java_classes_list_len;
+
+  memset (class, 0, sizeof (*class));
+  class->name = strdup (ci->values[0].value.string);
+  if (class->name == NULL)
+  {
+    ERROR ("java plugin: strdup failed.");
+    cjni_thread_detach ();
+    return (-1);
+  }
+  class->class = NULL;
+  class->object = NULL;
+
+  DEBUG ("java plugin: Loading class %s", class->name);
+
+  class->class = (*jvm_env)->FindClass (jvm_env, class->name);
+  if (class->class == NULL)
+  {
+    ERROR ("java plugin: cjni_config_load_plugin: FindClass (%s) failed.",
+        class->name);
+    cjni_thread_detach ();
+    free (class->name);
+    return (-1);
+  }
+
+  constructor_id = (*jvm_env)->GetMethodID (jvm_env, class->class,
+      "<init>", "()V");
+  if (constructor_id == NULL)
+  {
+    ERROR ("java plugin: cjni_config_load_plugin: "
+        "Could not find the constructor for `%s'.",
+        class->name);
+    cjni_thread_detach ();
+    free (class->name);
+    return (-1);
+  }
+
+  tmp_object = (*jvm_env)->NewObject (jvm_env, class->class,
+      constructor_id);
+  if (tmp_object != NULL)
+    class->object = (*jvm_env)->NewGlobalRef (jvm_env, tmp_object);
+  else
+    class->object = NULL;
+  if (class->object == NULL)
+  {
+    ERROR ("java plugin: cjni_config_load_plugin: "
+        "Could create a new `%s' object.",
+        class->name);
+    cjni_thread_detach ();
+    free (class->name);
+    return (-1);
+  }
+
+  cjni_thread_detach ();
+
+  java_classes_list_len++;
+
+  return (0);
+} /* }}} int cjni_config_load_plugin */
+
+static int cjni_config_plugin_block (oconfig_item_t *ci) /* {{{ */
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi;
+  jobject o_ocitem;
+  const char *name;
+  int status;
+  size_t i;
+
+  jclass class;
+  jmethodID method;
+
+  if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("java plugin: `Plugin' blocks "
+        "need exactly one string argument.");
+    return (-1);
+  }
+
+  name = ci->values[0].value.string;
+
+  cbi = NULL;
+  for (i = 0; i < java_callbacks_num; i++)
+  {
+    if (java_callbacks[i].type != CB_TYPE_CONFIG)
+      continue;
+
+    if (strcmp (name, java_callbacks[i].name) != 0)
+      continue;
+
+    cbi = java_callbacks + i;
+    break;
+  }
+
+  if (cbi == NULL)
+  {
+    NOTICE ("java plugin: Configuration block for `%s' found, but no such "
+        "configuration callback has been registered. Please make sure, the "
+        "`LoadPlugin' lines precede the `Plugin' blocks.",
+        name);
+    return (0);
+  }
+
+  DEBUG ("java plugin: Configuring %s", name);
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return (-1);
+
+  o_ocitem = ctoj_oconfig_item (jvm_env, ci);
+  if (o_ocitem == NULL)
+  {
+    ERROR ("java plugin: cjni_config_plugin_block: ctoj_oconfig_item failed.");
+    cjni_thread_detach ();
+    return (-1);
+  }
+
+  class = (*jvm_env)->GetObjectClass (jvm_env, cbi->object);
+  method = (*jvm_env)->GetMethodID (jvm_env, class,
+      "config", "(Lorg/collectd/api/OConfigItem;)I");
+
+  status = (*jvm_env)->CallIntMethod (jvm_env,
+      cbi->object, method, o_ocitem);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
+  cjni_thread_detach ();
+  return (0);
+} /* }}} int cjni_config_plugin_block */
+
+static int cjni_config (oconfig_item_t *ci) /* {{{ */
+{
+  int success;
+  int errors;
+  int status;
+  int i;
+
+  success = 0;
+  errors = 0;
+
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+
+    if (strcasecmp ("JVMArg", child->key) == 0)
+    {
+      status = cjni_config_add_jvm_arg (child);
+      if (status == 0)
+        success++;
+      else
+        errors++;
+    }
+    else if (strcasecmp ("LoadPlugin", child->key) == 0)
+    {
+      status = cjni_config_load_plugin (child);
+      if (status == 0)
+        success++;
+      else
+        errors++;
+    }
+    else if (strcasecmp ("Plugin", child->key) == 0)
+    {
+      status = cjni_config_plugin_block (child);
+      if (status == 0)
+        success++;
+      else
+        errors++;
+    }
+    else
+    {
+      WARNING ("java plugin: Option `%s' not allowed here.", child->key);
+      errors++;
+    }
+  }
+
+  DEBUG ("java plugin: jvm_argc = %zu;", jvm_argc);
+  DEBUG ("java plugin: java_classes_list_len = %zu;", java_classes_list_len);
+
+  if ((success == 0) && (errors > 0))
+  {
+    ERROR ("java plugin: All statements failed.");
+    return (-1);
+  }
+
+  return (0);
+} /* }}} int cjni_config */
+
+/* Free the data contained in the `user_data_t' pointer passed to `cjni_read'
+ * and `cjni_write'. In particular, delete the global reference to the Java
+ * object. */
+static void cjni_callback_info_destroy (void *arg) /* {{{ */
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi;
+
+  DEBUG ("java plugin: cjni_callback_info_destroy (arg = %p);", arg);
+
+  cbi = (cjni_callback_info_t *) arg;
+
+  /* This condition can occurr when shutting down. */
+  if (jvm == NULL)
+  {
+    sfree (cbi);
+    return;
+  }
+
+  if (arg == NULL)
+    return;
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+  {
+    ERROR ("java plugin: cjni_callback_info_destroy: cjni_thread_attach failed.");
+    return;
+  }
+
+  (*jvm_env)->DeleteGlobalRef (jvm_env, cbi->object);
+
+  cbi->method = NULL;
+  cbi->object = NULL;
+  cbi->class  = NULL;
+  free (cbi);
+
+  cjni_thread_detach ();
+} /* }}} void cjni_callback_info_destroy */
+
+/* Call the CB_TYPE_READ callback pointed to by the `user_data_t' pointer. */
+static int cjni_read (user_data_t *ud) /* {{{ */
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi;
+  int status;
+  int ret_status;
+
+  if (jvm == NULL)
+  {
+    ERROR ("java plugin: cjni_read: jvm == NULL");
+    return (-1);
+  }
+
+  if ((ud == NULL) || (ud->data == NULL))
+  {
+    ERROR ("java plugin: cjni_read: Invalid user data.");
+    return (-1);
+  }
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return (-1);
+
+  cbi = (cjni_callback_info_t *) ud->data;
+
+  ret_status = (*jvm_env)->CallIntMethod (jvm_env, cbi->object,
+      cbi->method);
+
+  status = cjni_thread_detach ();
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
+    return (-1);
+  }
+
+  return (ret_status);
+} /* }}} int cjni_read */
+
+/* Call the CB_TYPE_WRITE callback pointed to by the `user_data_t' pointer. */
+static int cjni_write (const data_set_t *ds, const value_list_t *vl, /* {{{ */
+    user_data_t *ud)
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi;
+  jobject vl_java;
+  int status;
+  int ret_status;
+
+  if (jvm == NULL)
+  {
+    ERROR ("java plugin: cjni_write: jvm == NULL");
+    return (-1);
+  }
+
+  if ((ud == NULL) || (ud->data == NULL))
+  {
+    ERROR ("java plugin: cjni_write: Invalid user data.");
+    return (-1);
+  }
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return (-1);
+
+  cbi = (cjni_callback_info_t *) ud->data;
+
+  vl_java = ctoj_value_list (jvm_env, ds, vl);
+  if (vl_java == NULL)
+  {
+    ERROR ("java plugin: cjni_write: ctoj_value_list failed.");
+    return (-1);
+  }
+
+  ret_status = (*jvm_env)->CallIntMethod (jvm_env,
+      cbi->object, cbi->method, vl_java);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, vl_java);
+
+  status = cjni_thread_detach ();
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_write: cjni_thread_detach failed.");
+    return (-1);
+  }
+
+  return (ret_status);
+} /* }}} int cjni_write */
+
+/* Call the CB_TYPE_FLUSH callback pointed to by the `user_data_t' pointer. */
+static int cjni_flush (int timeout, const char *identifier, /* {{{ */
+    user_data_t *ud)
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi;
+  jobject o_identifier;
+  int status;
+  int ret_status;
+
+  if (jvm == NULL)
+  {
+    ERROR ("java plugin: cjni_flush: jvm == NULL");
+    return (-1);
+  }
+
+  if ((ud == NULL) || (ud->data == NULL))
+  {
+    ERROR ("java plugin: cjni_flush: Invalid user data.");
+    return (-1);
+  }
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return (-1);
+
+  cbi = (cjni_callback_info_t *) ud->data;
+
+  o_identifier = NULL;
+  if (identifier != NULL)
+  {
+    o_identifier = (*jvm_env)->NewStringUTF (jvm_env, identifier);
+    if (o_identifier == NULL)
+    {
+      ERROR ("java plugin: cjni_flush: NewStringUTF failed.");
+      return (-1);
+    }
+  }
+
+  ret_status = (*jvm_env)->CallIntMethod (jvm_env,
+      cbi->object, cbi->method, (jint) timeout, o_identifier);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_identifier);
+
+  status = cjni_thread_detach ();
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_flush: cjni_thread_detach failed.");
+    return (-1);
+  }
+
+  return (ret_status);
+} /* }}} int cjni_flush */
+
+/* Call the CB_TYPE_LOG callback pointed to by the `user_data_t' pointer. */
+static void cjni_log (int severity, const char *message, /* {{{ */
+    user_data_t *ud)
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi;
+  jobject o_message;
+
+  if (jvm == NULL)
+    return;
+
+  if ((ud == NULL) || (ud->data == NULL))
+    return;
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return;
+
+  cbi = (cjni_callback_info_t *) ud->data;
+
+  o_message = (*jvm_env)->NewStringUTF (jvm_env, message);
+  if (o_message == NULL)
+    return;
+
+  (*jvm_env)->CallVoidMethod (jvm_env,
+      cbi->object, cbi->method, (jint) severity, o_message);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_message);
+
+  cjni_thread_detach ();
+} /* }}} void cjni_log */
+
+/* Call the CB_TYPE_NOTIFICATION callback pointed to by the `user_data_t'
+ * pointer. */
+static int cjni_notification (const notification_t *n, /* {{{ */
+    user_data_t *ud)
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi;
+  jobject o_notification;
+  int status;
+  int ret_status;
+
+  if (jvm == NULL)
+  {
+    ERROR ("java plugin: cjni_read: jvm == NULL");
+    return (-1);
+  }
+
+  if ((ud == NULL) || (ud->data == NULL))
+  {
+    ERROR ("java plugin: cjni_read: Invalid user data.");
+    return (-1);
+  }
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return (-1);
+
+  cbi = (cjni_callback_info_t *) ud->data;
+
+  o_notification = ctoj_notification (jvm_env, n);
+  if (o_notification == NULL)
+  {
+    ERROR ("java plugin: cjni_notification: ctoj_notification failed.");
+    return (-1);
+  }
+
+  ret_status = (*jvm_env)->CallIntMethod (jvm_env,
+      cbi->object, cbi->method, o_notification);
+
+  (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
+
+  status = cjni_thread_detach ();
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
+    return (-1);
+  }
+
+  return (ret_status);
+} /* }}} int cjni_notification */
+
+/* Callbacks for matches implemented in Java */
+static int cjni_match_target_create (const oconfig_item_t *ci, /* {{{ */
+    void **user_data)
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi_ret;
+  cjni_callback_info_t *cbi_factory;
+  const char *name;
+  jobject o_ci;
+  jobject o_tmp;
+  int type;
+  size_t i;
+
+  cbi_ret = NULL;
+  o_ci = NULL;
+  jvm_env = NULL;
+
+#define BAIL_OUT(status) \
+  if (cbi_ret != NULL) { \
+    free (cbi_ret->name); \
+    if ((jvm_env != NULL) && (cbi_ret->object != NULL)) \
+      (*jvm_env)->DeleteLocalRef (jvm_env, cbi_ret->object); \
+  } \
+  free (cbi_ret); \
+  if (jvm_env != NULL) { \
+    if (o_ci != NULL) \
+      (*jvm_env)->DeleteLocalRef (jvm_env, o_ci); \
+    cjni_thread_detach (); \
+  } \
+  return (status)
+
+  if (jvm == NULL)
+  {
+    ERROR ("java plugin: cjni_read: jvm == NULL");
+    BAIL_OUT (-1);
+  }
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+  {
+    BAIL_OUT (-1);
+  }
+
+  /* Find out whether to create a match or a target. */
+  if (strcasecmp ("Match", ci->key) == 0)
+    type = CB_TYPE_MATCH;
+  else if (strcasecmp ("Target", ci->key) == 0)
+    type = CB_TYPE_TARGET;
+  else
+  {
+    ERROR ("java plugin: cjni_match_target_create: Can't figure out whether "
+        "to create a match or a target.");
+    BAIL_OUT (-1);
+  }
+
+  /* This is the name of the match we should create. */
+  name = ci->values[0].value.string;
+
+  /* Lets see if we have a matching factory here.. */
+  cbi_factory = NULL;
+  for (i = 0; i < java_callbacks_num; i++)
+  {
+    if (java_callbacks[i].type != type)
+      continue;
+
+    if (strcmp (name, java_callbacks[i].name) != 0)
+      continue;
+
+    cbi_factory = java_callbacks + i;
+    break;
+  }
+
+  /* Nope, no factory for that name.. */
+  if (cbi_factory == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_create: "
+        "No such match factory registered: %s",
+        name);
+    BAIL_OUT (-1);
+  }
+
+  /* We convert `ci' to its Java equivalent.. */
+  o_ci = ctoj_oconfig_item (jvm_env, ci);
+  if (o_ci == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_create: "
+        "ctoj_oconfig_item failed.");
+    BAIL_OUT (-1);
+  }
+
+  /* Allocate a new callback info structure. This is going to be our user_data
+   * pointer. */
+  cbi_ret = (cjni_callback_info_t *) malloc (sizeof (*cbi_ret));
+  if (cbi_ret == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_create: malloc failed.");
+    BAIL_OUT (-1);
+  }
+  memset (cbi_ret, 0, sizeof (*cbi_ret));
+  cbi_ret->object = NULL;
+  cbi_ret->type = type;
+
+  /* Lets fill the callback info structure.. First, the name: */
+  cbi_ret->name = strdup (name);
+  if (cbi_ret->name == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_create: strdup failed.");
+    BAIL_OUT (-1);
+  }
+
+  /* Then call the factory method so it creates a new object for us. */
+  o_tmp = (*jvm_env)->CallObjectMethod (jvm_env,
+      cbi_factory->object, cbi_factory->method, o_ci);
+  if (o_tmp == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_create: CallObjectMethod failed.");
+    BAIL_OUT (-1);
+  }
+
+  cbi_ret->object = (*jvm_env)->NewGlobalRef (jvm_env, o_tmp);
+  if (o_tmp == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_create: NewGlobalRef failed.");
+    BAIL_OUT (-1);
+  }
+
+  /* This is the class of the match. It is possibly different from the class of
+   * the match-factory! */
+  cbi_ret->class = (*jvm_env)->GetObjectClass (jvm_env, cbi_ret->object);
+  if (cbi_ret->class == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_create: GetObjectClass failed.");
+    BAIL_OUT (-1);
+  }
+
+  /* Lookup the `int match (DataSet, ValueList)' method. */
+  cbi_ret->method = (*jvm_env)->GetMethodID (jvm_env, cbi_ret->class,
+      /* method name = */ (type == CB_TYPE_MATCH) ? "match" : "invoke",
+      "(Lorg/collectd/api/DataSet;Lorg/collectd/api/ValueList;)I");
+  if (cbi_ret->method == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_create: GetMethodID failed.");
+    BAIL_OUT (-1);
+  }
+
+  /* Return the newly created match via the user_data pointer. */
+  *user_data = (void *) cbi_ret;
+
+  cjni_thread_detach ();
+
+  DEBUG ("java plugin: cjni_match_target_create: "
+      "Successfully created a `%s' %s.",
+      cbi_ret->name, (type == CB_TYPE_MATCH) ? "match" : "target");
+
+  /* Success! */
+  return (0);
+#undef BAIL_OUT
+} /* }}} int cjni_match_target_create */
+
+static int cjni_match_target_destroy (void **user_data) /* {{{ */
+{
+  cjni_callback_info_destroy (*user_data);
+  *user_data = NULL;
+
+  return (0);
+} /* }}} int cjni_match_target_destroy */
+
+static int cjni_match_target_invoke (const data_set_t *ds, /* {{{ */
+    value_list_t *vl, notification_meta_t **meta, void **user_data)
+{
+  JNIEnv *jvm_env;
+  cjni_callback_info_t *cbi;
+  jobject o_vl;
+  jobject o_ds;
+  int ret_status;
+  int status;
+
+  if (jvm == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_invoke: jvm == NULL");
+    return (-1);
+  }
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return (-1);
+
+  cbi = (cjni_callback_info_t *) *user_data;
+
+  o_vl = ctoj_value_list (jvm_env, ds, vl);
+  if (o_vl == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_invoke: ctoj_value_list failed.");
+    cjni_thread_detach ();
+    return (-1);
+  }
+
+  o_ds = ctoj_data_set (jvm_env, ds);
+  if (o_ds == NULL)
+  {
+    ERROR ("java plugin: cjni_match_target_invoke: ctoj_value_list failed.");
+    cjni_thread_detach ();
+    return (-1);
+  }
+
+  ret_status = (*jvm_env)->CallIntMethod (jvm_env, cbi->object, cbi->method,
+      o_ds, o_vl);
+
+  DEBUG ("java plugin: cjni_match_target_invoke: Method returned %i.", ret_status);
+
+  /* If we're executing a target, copy the `ValueList' back to our
+   * `value_list_t'. */
+  if (cbi->type == CB_TYPE_TARGET)
+  {
+    value_list_t new_vl;
+
+    memset (&new_vl, 0, sizeof (new_vl));
+    status = jtoc_value_list (jvm_env, &new_vl, o_vl);
+    if (status != 0)
+    {
+      ERROR ("java plugin: cjni_match_target_invoke: "
+          "jtoc_value_list failed.");
+    }
+    else /* if (status == 0) */
+    {
+      /* plugin_dispatch_values assures that this is dynamically allocated
+       * memory. */
+      sfree (vl->values);
+
+      /* This will replace the vl->values pointer to a new, dynamically
+       * allocated piece of memory. */
+      memcpy (vl, &new_vl, sizeof (*vl));
+    }
+  } /* if (cbi->type == CB_TYPE_TARGET) */
+
+  status = cjni_thread_detach ();
+  if (status != 0)
+    ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
+
+  return (ret_status);
+} /* }}} int cjni_match_target_invoke */
+
+/* Iterate over `java_callbacks' and call all CB_TYPE_INIT callbacks. */
+static int cjni_init_plugins (JNIEnv *jvm_env) /* {{{ */
+{
+  int status;
+  size_t i;
+
+  for (i = 0; i < java_callbacks_num; i++)
+  {
+    if (java_callbacks[i].type != CB_TYPE_INIT)
+      continue;
+
+    DEBUG ("java plugin: Initializing %s", java_callbacks[i].name);
+
+    status = (*jvm_env)->CallIntMethod (jvm_env,
+        java_callbacks[i].object, java_callbacks[i].method);
+    if (status != 0)
+    {
+      ERROR ("java plugin: Initializing `%s' failed with status %i. "
+          "Removing read function.",
+          java_callbacks[i].name, status);
+      plugin_unregister_read (java_callbacks[i].name);
+    }
+  }
+
+  return (0);
+} /* }}} int cjni_init_plugins */
+
+/* Iterate over `java_callbacks' and call all CB_TYPE_SHUTDOWN callbacks. */
+static int cjni_shutdown_plugins (JNIEnv *jvm_env) /* {{{ */
+{
+  int status;
+  size_t i;
+
+  for (i = 0; i < java_callbacks_num; i++)
+  {
+    if (java_callbacks[i].type != CB_TYPE_SHUTDOWN)
+      continue;
+
+    DEBUG ("java plugin: Shutting down %s", java_callbacks[i].name);
+
+    status = (*jvm_env)->CallIntMethod (jvm_env,
+        java_callbacks[i].object, java_callbacks[i].method);
+    if (status != 0)
+    {
+      ERROR ("java plugin: Shutting down `%s' failed with status %i. ",
+          java_callbacks[i].name, status);
+    }
+  }
+
+  return (0);
+} /* }}} int cjni_shutdown_plugins */
+
+
+static int cjni_shutdown (void) /* {{{ */
+{
+  JNIEnv *jvm_env;
+  JavaVMAttachArgs args;
+  int status;
+  size_t i;
+
+  if (jvm == NULL)
+    return (0);
+
+  jvm_env = NULL;
+  memset (&args, 0, sizeof (args));
+  args.version = JNI_VERSION_1_2;
+
+  status = (*jvm)->AttachCurrentThread (jvm, (void *) &jvm_env, &args);
+  if (status != 0)
+  {
+    ERROR ("java plugin: cjni_shutdown: AttachCurrentThread failed with status %i.",
+        status);
+    return (-1);
+  }
+
+  /* Execute all the shutdown functions registered by plugins. */
+  cjni_shutdown_plugins (jvm_env);
+
+  /* Release all the global references to callback functions */
+  for (i = 0; i < java_callbacks_num; i++)
+  {
+    if (java_callbacks[i].object != NULL)
+    {
+      (*jvm_env)->DeleteGlobalRef (jvm_env, java_callbacks[i].object);
+      java_callbacks[i].object = NULL;
+    }
+    sfree (java_callbacks[i].name);
+  }
+  java_callbacks_num = 0;
+  sfree (java_callbacks);
+
+  /* Release all the global references to directly loaded classes. */
+  for (i = 0; i < java_classes_list_len; i++)
+  {
+    if (java_classes_list[i].object != NULL)
+    {
+      (*jvm_env)->DeleteGlobalRef (jvm_env, java_classes_list[i].object);
+      java_classes_list[i].object = NULL;
+    }
+    sfree (java_classes_list[i].name);
+  }
+  java_classes_list_len = 0;
+  sfree (java_classes_list);
+
+  /* Destroy the JVM */
+  DEBUG ("java plugin: Destroying the JVM.");
+  (*jvm)->DestroyJavaVM (jvm);
+  jvm = NULL;
+  jvm_env = NULL;
+
+  pthread_key_delete (jvm_env_key);
+
+  /* Free the JVM argument list */
+  for (i = 0; i < jvm_argc; i++)
+    sfree (jvm_argv[i]);
+  jvm_argc = 0;
+  sfree (jvm_argv);
+
+  return (0);
+} /* }}} int cjni_shutdown */
+
+/* Initialization: Create a JVM, load all configured classes and call their
+ * `config' and `init' callback methods. */
+static int cjni_init (void) /* {{{ */
+{
+  JNIEnv *jvm_env;
+
+  if (jvm == NULL)
+  {
+    ERROR ("java plugin: cjni_init: jvm == NULL");
+    return (-1);
+  }
+
+  jvm_env = cjni_thread_attach ();
+  if (jvm_env == NULL)
+    return (-1);
+
+  cjni_init_plugins (jvm_env);
+
+  cjni_thread_detach ();
+  return (0);
+} /* }}} int cjni_init */
+
+void module_register (void)
+{
+  plugin_register_complex_config ("java", cjni_config);
+  plugin_register_init ("java", cjni_init);
+  plugin_register_shutdown ("java", cjni_shutdown);
+} /* void module_register (void) */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
index 79b53ae..629775a 100644 (file)
@@ -95,6 +95,98 @@ oconfig_item_t *oconfig_parse_file (const char *file)
   return (ret);
 } /* oconfig_item_t *oconfig_parse_file */
 
+oconfig_item_t *oconfig_clone (const oconfig_item_t *ci_orig)
+{
+  oconfig_item_t *ci_copy;
+
+  ci_copy = (oconfig_item_t *) malloc (sizeof (*ci_copy));
+  if (ci_copy == NULL)
+  {
+    fprintf (stderr, "malloc failed.\n");
+    return (NULL);
+  }
+  memset (ci_copy, 0, sizeof (*ci_copy));
+  ci_copy->values = NULL;
+  ci_copy->parent = NULL;
+  ci_copy->children = NULL;
+
+  ci_copy->key = strdup (ci_orig->key);
+  if (ci_copy->key == NULL)
+  {
+    fprintf (stderr, "strdup failed.\n");
+    free (ci_copy);
+    return (NULL);
+  }
+
+  if (ci_orig->values_num > 0) /* {{{ */
+  {
+    int i;
+
+    ci_copy->values = (oconfig_value_t *) calloc (ci_orig->values_num,
+       sizeof (*ci_copy->values));
+    if (ci_copy->values == NULL)
+    {
+      fprintf (stderr, "calloc failed.\n");
+      free (ci_copy->key);
+      free (ci_copy);
+      return (NULL);
+    }
+    ci_copy->values_num = ci_orig->values_num;
+
+    for (i = 0; i < ci_copy->values_num; i++)
+    {
+       ci_copy->values[i].type = ci_orig->values[i].type;
+       if (ci_copy->values[i].type == OCONFIG_TYPE_STRING)
+       {
+        ci_copy->values[i].value.string
+          = strdup (ci_orig->values[i].value.string);
+        if (ci_copy->values[i].value.string == NULL)
+        {
+          fprintf (stderr, "strdup failed.\n");
+          oconfig_free (ci_copy);
+          return (NULL);
+        }
+       }
+       else /* ci_copy->values[i].type != OCONFIG_TYPE_STRING) */
+       {
+        ci_copy->values[i].value = ci_orig->values[i].value;
+       }
+    }
+  } /* }}} if (ci_orig->values_num > 0) */
+
+  if (ci_orig->children_num > 0) /* {{{ */
+  {
+    int i;
+
+    ci_copy->children = (oconfig_item_t *) calloc (ci_orig->children_num,
+       sizeof (*ci_copy->children));
+    if (ci_copy->children == NULL)
+    {
+      fprintf (stderr, "calloc failed.\n");
+      oconfig_free (ci_copy);
+      return (NULL);
+    }
+    ci_copy->children_num = ci_orig->children_num;
+
+    for (i = 0; i < ci_copy->children_num; i++)
+    {
+      oconfig_item_t *child;
+      
+      child = oconfig_clone (ci_orig->children + i);
+      if (child == NULL)
+      {
+       oconfig_free (ci_copy);
+       return (NULL);
+      }
+      child->parent = ci_copy;
+      ci_copy->children[i] = *child;
+      free (child);
+    } /* for (i = 0; i < ci_copy->children_num; i++) */
+  } /* }}} if (ci_orig->children_num > 0) */
+
+  return (ci_copy);
+} /* oconfig_item_t *oconfig_clone */
+
 void oconfig_free (oconfig_item_t *ci)
 {
   int i;
@@ -121,5 +213,5 @@ void oconfig_free (oconfig_item_t *ci)
 }
 
 /*
- * vim:shiftwidth=2:tabstop=8:softtabstop=2
+ * vim:shiftwidth=2:tabstop=8:softtabstop=2:fdm=marker
  */
index e6e53e2..70fc623 100644 (file)
@@ -5,7 +5,7 @@
 
 /**
  * oconfig - src/oconfig.h
- * Copyright (C) 2006,2007  Florian octo Forster <octo at verplant.org>
+ * Copyright (C) 2006-2009  Florian octo Forster <octo at verplant.org>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -59,6 +59,8 @@ struct oconfig_item_s
 oconfig_item_t *oconfig_parse_fh (FILE *fh);
 oconfig_item_t *oconfig_parse_file (const char *file);
 
+oconfig_item_t *oconfig_clone (const oconfig_item_t *ci);
+
 void oconfig_free (oconfig_item_t *ci);
 
 /*
diff --git a/src/liboping/AUTHORS b/src/liboping/AUTHORS
deleted file mode 100644 (file)
index e69de29..0000000
diff --git a/src/liboping/COPYING b/src/liboping/COPYING
deleted file mode 100644 (file)
index 623b625..0000000
+++ /dev/null
@@ -1,340 +0,0 @@
-                   GNU GENERAL PUBLIC LICENSE
-                      Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                           Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-\f
-                   GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-\f
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-\f
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-\f
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-                           NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-                    END OF TERMS AND CONDITIONS
-\f
-           How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    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 General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year  name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
-Public License instead of this License.
diff --git a/src/liboping/ChangeLog b/src/liboping/ChangeLog
deleted file mode 100644 (file)
index c4bd92d..0000000
+++ /dev/null
@@ -1,31 +0,0 @@
-2006-06-05, Version 0.2.2
-       * The `oping' application didn't exit if no hosts could be resolved.
-         This release fixes it's behavior.
-
-2006-06-01, Version 0.2.1
-       * Fix the behavior for non GNU-Linux systems. liboping tried to
-         `bind(2)' to the raw-socket it uses to send ICMP packets. Apparently
-         (decided by majority vote ;) this is not the right thing to do.
-         GNU/Linux never complained about it, but works find without the bind.
-         Other operating systems don't work at all with the bind.
-       * Build fixes for non-GNU/Linux platforms: Mac OS X doesn't define
-         `size_t' as `unsigned int' and therefore needs casting and FreeBSD
-         needs to have `sys/types.h' included before `netinet/*.h'
-
-2006-05-29, Version 0.2.0
-       * It's now possible to set the data to be send to the remote host and
-         to get the data received from the host.
-       * The `oping' binary now calculates the standard deviation. Also, it
-         displays the number of byes that were received and other output
-         changes.
-       * Hosts are now returned in the same order as they were added by
-         `ping_host_add'. This is not guaranteed, but makes `oping' prettier.
-
-2006-05-12, Version 0.1.1
-       * A bug in the library has been fixed: When the sequence got higher
-         than 2^16 the counter in the packets wrapped around, but the
-         internal counter didn't, causing the library to ignore all further
-         ICMP packets. This affected both, ICMPv4 and ICMPv6.
-
-2006-05-08, Version 0.1.0
-       * Initial release.
diff --git a/src/liboping/Makefile.am b/src/liboping/Makefile.am
deleted file mode 100644 (file)
index 1b00410..0000000
+++ /dev/null
@@ -1,16 +0,0 @@
-AUTOMAKE_OPTIONS = foreign no-dependencies
-
-if COMPILER_IS_GCC
-AM_CFLAGS = -Wall -Werror
-endif
-
-EXTRA_DIST = AUTHORS COPYING ChangeLog README
-
-noinst_LTLIBRARIES = liboping.la
-
-#liboping_la_CFLAGS = 
-liboping_la_LDFLAGS = -version-info 0:3:0
-if BUILD_WITH_LIBSOCKET
-liboping_la_LDFLAGS += -lsocket
-endif
-liboping_la_SOURCES = liboping.c oping.h
diff --git a/src/liboping/README b/src/liboping/README
deleted file mode 100644 (file)
index 7d2e8d4..0000000
+++ /dev/null
@@ -1,28 +0,0 @@
- liboping - Library to ping IPv4 and IPv6 hosts in parallel
-============================================================
-http://verplant.org/liboping/
-
-About
------
-
-  liboping was inspired by ping, libping and fping: It differs from these
-  existing solutions in that it can `ping' multiple hosts in parallel using
-  IPv4 or IPv6 transparently. Other design principles were an object oriented
-  interface, simplicity and extensibility.
-
-
-Features
---------
-
-  * Support for multiple hosts.
-
-  * Support for IPv4 and IPv6.
-
-  * Object oriented interface.
-
-
-Author
-------
-
-  Florian octo Forster <octo at verplant.org>
-
diff --git a/src/liboping/liboping.c b/src/liboping/liboping.c
deleted file mode 100644 (file)
index fb3f843..0000000
+++ /dev/null
@@ -1,1220 +0,0 @@
-/**
- * Object oriented C module to send ICMP and ICMPv6 `echo's.
- * Copyright (C) 2006  Florian octo Forster <octo at verplant.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
- */
-
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#if STDC_HEADERS
-# include <stdlib.h>
-# include <stdio.h>
-# include <string.h>
-# include <errno.h>
-# include <assert.h>
-#else
-# error "You don't have the standard C99 header files installed"
-#endif /* STDC_HEADERS */
-
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-
-#if HAVE_FCNTL_H
-# include <fcntl.h>
-#endif
-#if HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-#if HAVE_SYS_STAT_H
-# include <sys/stat.h>
-#endif
-
-#if TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# if HAVE_SYS_TIME_H
-#  include <sys/time.h>
-# else
-#  include <time.h>
-# endif
-#endif
-
-#if HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#if HAVE_NETDB_H
-# include <netdb.h>
-#endif
-
-#if HAVE_NETINET_IN_SYSTM_H
-# include <netinet/in_systm.h>
-#endif
-#if HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#if HAVE_NETINET_IP_H
-# include <netinet/ip.h>
-#endif
-#if HAVE_NETINET_IP_ICMP_H
-# include <netinet/ip_icmp.h>
-#endif
-#ifdef HAVE_NETINET_IP_VAR_H
-# include <netinet/ip_var.h>
-#endif
-#if HAVE_NETINET_IP6_H
-# include <netinet/ip6.h>
-#endif
-#if HAVE_NETINET_ICMP6_H
-# include <netinet/icmp6.h>
-#endif
-
-#include "oping.h"
-
-#if WITH_DEBUG
-# define dprintf(...) printf ("%s[%4i]: %-20s: ", __FILE__, __LINE__, __FUNCTION__); printf (__VA_ARGS__)
-#else
-# define dprintf(...) /**/
-#endif
-
-#define PING_ERRMSG_LEN 256
-
-struct pinghost
-{
-       char                    *hostname;
-       struct sockaddr_storage *addr;
-       socklen_t                addrlen;
-       int                      addrfamily;
-       int                      fd;
-       int                      ident;
-       int                      sequence;
-       struct timeval          *timer;
-       double                   latency;
-       char                    *data;
-
-       void                    *context;
-
-       struct pinghost         *next;
-};
-
-struct pingobj
-{
-       double      timeout;
-       int         ttl;
-       int         addrfamily;
-       char       *data;
-
-       char        errmsg[PING_ERRMSG_LEN];
-
-       pinghost_t *head;
-};
-
-/*
- * private (static) functions
- */
-static void ping_set_error (pingobj_t *obj, const char *function,
-               const char *message)
-{
-       snprintf (obj->errmsg, PING_ERRMSG_LEN, "%s: %s", function, message);
-       obj->errmsg[PING_ERRMSG_LEN - 1] = '\0';
-}
-
-static int ping_timeval_add (struct timeval *tv1, struct timeval *tv2,
-               struct timeval *res)
-{
-       res->tv_sec  = tv1->tv_sec  + tv2->tv_sec;
-       res->tv_usec = tv1->tv_usec + tv2->tv_usec;
-
-       while (res->tv_usec > 1000000)
-       {
-               res->tv_usec -= 1000000;
-               res->tv_sec++;
-       }
-
-       return (0);
-}
-
-static int ping_timeval_sub (struct timeval *tv1, struct timeval *tv2,
-               struct timeval *res)
-{
-
-       if ((tv1->tv_sec < tv2->tv_sec)
-                       || ((tv1->tv_sec == tv2->tv_sec)
-                               && (tv1->tv_usec < tv2->tv_usec)))
-               return (-1);
-
-       res->tv_sec  = tv1->tv_sec  - tv2->tv_sec;
-       res->tv_usec = tv1->tv_usec - tv2->tv_usec;
-
-       assert ((res->tv_sec > 0) || ((res->tv_sec == 0) && (res->tv_usec > 0)));
-
-       while (res->tv_usec < 0)
-       {
-               res->tv_usec += 1000000;
-               res->tv_sec--;
-       }
-
-       return (0);
-}
-
-static uint16_t ping_icmp4_checksum (char *buf, size_t len)
-{
-       uint32_t sum = 0;
-       uint16_t ret = 0;
-
-       uint16_t *ptr;
-
-       for (ptr = (uint16_t *) buf; len > 1; ptr++, len -= 2)
-               sum += *ptr;
-
-       if (len == 1)
-       {
-               *(char *) &ret = *(char *) ptr;
-               sum += ret;
-       }
-
-       /* Do this twice to get all possible carries.. */
-       sum = (sum >> 16) + (sum & 0xFFFF);
-       sum = (sum >> 16) + (sum & 0xFFFF);
-
-       ret = ~sum;
-
-       return (ret);
-}
-
-static pinghost_t *ping_receive_ipv4 (pinghost_t *ph, char *buffer, size_t buffer_len)
-{
-       struct ip *ip_hdr;
-       struct icmp *icmp_hdr;
-
-       size_t ip_hdr_len;
-
-       uint16_t recv_checksum;
-       uint16_t calc_checksum;
-
-       uint16_t ident;
-       uint16_t seq;
-
-       pinghost_t *ptr;
-
-       if (buffer_len < sizeof (struct ip))
-               return (NULL);
-
-       ip_hdr     = (struct ip *) buffer;
-       ip_hdr_len = ip_hdr->ip_hl << 2;
-
-       if (buffer_len < ip_hdr_len)
-               return (NULL);
-
-       buffer     += ip_hdr_len;
-       buffer_len -= ip_hdr_len;
-
-       if (buffer_len < sizeof (struct icmp))
-               return (NULL);
-
-       icmp_hdr = (struct icmp *) buffer;
-       buffer     += sizeof (struct icmp);
-       buffer_len -= sizeof (struct icmp);
-
-       if (icmp_hdr->icmp_type != ICMP_ECHOREPLY)
-       {
-               dprintf ("Unexpected ICMP type: %i\n", icmp_hdr->icmp_type);
-               return (NULL);
-       }
-
-       recv_checksum = icmp_hdr->icmp_cksum;
-       icmp_hdr->icmp_cksum = 0;
-       calc_checksum = ping_icmp4_checksum ((char *) icmp_hdr,
-                       sizeof (struct icmp) + buffer_len);
-
-       if (recv_checksum != calc_checksum)
-       {
-               dprintf ("Checksum missmatch: Got 0x%04x, calculated 0x%04x\n",
-                               recv_checksum, calc_checksum);
-               return (NULL);
-       }
-
-       ident = ntohs (icmp_hdr->icmp_id);
-       seq   = ntohs (icmp_hdr->icmp_seq);
-
-       for (ptr = ph; ptr != NULL; ptr = ptr->next)
-       {
-               dprintf ("hostname = %s, ident = 0x%04x, seq = %i\n",
-                               ptr->hostname, ptr->ident, ((ptr->sequence - 1) & 0xFFFF));
-
-               if (ptr->addrfamily != AF_INET)
-                       continue;
-
-               if (!timerisset (ptr->timer))
-                       continue;
-
-               if (ptr->ident != ident)
-                       continue;
-
-               if (((ptr->sequence - 1) & 0xFFFF) != seq)
-                       continue;
-
-               dprintf ("Match found: hostname = %s, ident = 0x%04x, seq = %i\n",
-                               ptr->hostname, ident, seq);
-
-               break;
-       }
-
-       if (ptr == NULL)
-       {
-               dprintf ("No match found for ident = 0x%04x, seq = %i\n",
-                               ident, seq);
-       }
-
-       return (ptr);
-}
-
-static pinghost_t *ping_receive_ipv6 (pinghost_t *ph, char *buffer, size_t buffer_len)
-{
-       struct icmp6_hdr *icmp_hdr;
-
-       uint16_t ident;
-       uint16_t seq;
-
-       pinghost_t *ptr;
-
-       if (buffer_len < sizeof (struct icmp6_hdr))
-               return (NULL);
-
-       icmp_hdr = (struct icmp6_hdr *) buffer;
-       buffer     += sizeof (struct icmp);
-       buffer_len -= sizeof (struct icmp);
-
-       if (icmp_hdr->icmp6_type != ICMP6_ECHO_REPLY)
-       {
-               dprintf ("Unexpected ICMP type: %02x\n", icmp_hdr->icmp6_type);
-               return (NULL);
-       }
-
-       if (icmp_hdr->icmp6_code != 0)
-       {
-               dprintf ("Unexpected ICMP code: %02x\n", icmp_hdr->icmp6_code);
-               return (NULL);
-       }
-
-       ident = ntohs (icmp_hdr->icmp6_id);
-       seq   = ntohs (icmp_hdr->icmp6_seq);
-
-       for (ptr = ph; ptr != NULL; ptr = ptr->next)
-       {
-               dprintf ("hostname = %s, ident = 0x%04x, seq = %i\n",
-                               ptr->hostname, ptr->ident, ((ptr->sequence - 1) & 0xFFFF));
-
-               if (ptr->addrfamily != AF_INET6)
-                       continue;
-
-               if (!timerisset (ptr->timer))
-                       continue;
-
-               if (ptr->ident != ident)
-                       continue;
-
-               if (((ptr->sequence - 1) & 0xFFFF) != seq)
-                       continue;
-
-               dprintf ("Match found: hostname = %s, ident = 0x%04x, seq = %i\n",
-                               ptr->hostname, ident, seq);
-
-               break;
-       }
-
-       if (ptr == NULL)
-       {
-               dprintf ("No match found for ident = 0x%04x, seq = %i\n",
-                               ident, seq);
-       }
-
-       return (ptr);
-}
-
-static int ping_receive_one (int fd, pinghost_t *ph, struct timeval *now)
-{
-       char   buffer[4096];
-       size_t buffer_len;
-
-       struct timeval diff;
-
-       pinghost_t *host = NULL;
-
-       struct sockaddr_storage sa;
-       socklen_t               sa_len;
-
-       sa_len = sizeof (sa);
-
-       buffer_len = recvfrom (fd, buffer, sizeof (buffer), 0,
-                       (struct sockaddr *) &sa, &sa_len);
-       if (buffer_len == -1)
-       {
-               dprintf ("recvfrom: %s\n", strerror (errno));
-               return (-1);
-       }
-
-       dprintf ("Read %u bytes from fd = %i\n", (unsigned int) buffer_len, fd);
-
-       if (sa.ss_family == AF_INET)
-       {
-               if ((host = ping_receive_ipv4 (ph, buffer, buffer_len)) == NULL)
-                       return (-1);
-       }
-       else if (sa.ss_family == AF_INET6)
-       {
-               if ((host = ping_receive_ipv6 (ph, buffer, buffer_len)) == NULL)
-                       return (-1);
-       }
-
-       dprintf ("rcvd: %12i.%06i\n",
-                       (int) now->tv_sec,
-                       (int) now->tv_usec);
-       dprintf ("sent: %12i.%06i\n",
-                       (int) host->timer->tv_sec,
-                       (int) host->timer->tv_usec);
-
-       if (ping_timeval_sub (now, host->timer, &diff) < 0)
-       {
-               timerclear (host->timer);
-               return (-1);
-       }
-
-       dprintf ("diff: %12i.%06i\n",
-                       (int) diff.tv_sec,
-                       (int) diff.tv_usec);
-
-       host->latency  = ((double) diff.tv_usec) / 1000.0;
-       host->latency += ((double) diff.tv_sec)  * 1000.0;
-
-       timerclear (host->timer);
-
-       return (0);
-}
-
-static int ping_receive_all (pingobj_t *obj)
-{
-       fd_set readfds;
-       int num_readfds;
-       int max_readfds;
-
-       pinghost_t *ph;
-       pinghost_t *ptr;
-
-       struct timeval endtime;
-       struct timeval nowtime;
-       struct timeval timeout;
-       int status;
-
-       int ret;
-
-       ph = obj->head;
-       ret = 0;
-
-       for (ptr = ph; ptr != NULL; ptr = ptr->next)
-               ptr->latency = -1.0;
-
-       if (gettimeofday (&nowtime, NULL) == -1)
-       {
-               ping_set_error (obj, "gettimeofday", strerror (errno));
-               return (-1);
-       }
-
-       /* Set up timeout */
-       timeout.tv_sec = (time_t) obj->timeout;
-       timeout.tv_usec = (suseconds_t) (1000000 * (obj->timeout - ((double) timeout.tv_sec)));
-
-       dprintf ("Set timeout to %i.%06i seconds\n",
-                       (int) timeout.tv_sec,
-                       (int) timeout.tv_usec);
-
-       ping_timeval_add (&nowtime, &timeout, &endtime);
-
-       while (1)
-       {
-               FD_ZERO (&readfds);
-               num_readfds =  0;
-               max_readfds = -1;
-
-               for (ptr = ph; ptr != NULL; ptr = ptr->next)
-               {
-                       if (!timerisset (ptr->timer))
-                               continue;
-
-                       FD_SET (ptr->fd, &readfds);
-                       num_readfds++;
-
-                       if (max_readfds < ptr->fd)
-                               max_readfds = ptr->fd;
-               }
-
-               if (num_readfds == 0)
-                       break;
-
-               if (gettimeofday (&nowtime, NULL) == -1)
-               {
-                       ping_set_error (obj, "gettimeofday", strerror (errno));
-                       return (-1);
-               }
-
-               if (ping_timeval_sub (&endtime, &nowtime, &timeout) == -1)
-                       break;
-
-               dprintf ("Waiting on %i sockets for %i.%06i seconds\n", num_readfds,
-                               (int) timeout.tv_sec,
-                               (int) timeout.tv_usec);
-
-               status = select (max_readfds + 1, &readfds, NULL, NULL, &timeout);
-
-               if (gettimeofday (&nowtime, NULL) == -1)
-               {
-                       ping_set_error (obj, "gettimeofday", strerror (errno));
-                       return (-1);
-               }
-               
-               if ((status == -1) && (errno == EINTR))
-               {
-                       dprintf ("select was interrupted by signal..\n");
-                       continue;
-               }
-               else if (status < 0)
-               {
-                       dprintf ("select: %s\n", strerror (errno));
-                       break;
-               }
-               else if (status == 0)
-               {
-                       dprintf ("select timed out\n");
-                       break;
-               }
-
-               for (ptr = ph; ptr != NULL; ptr = ptr->next)
-               {
-                       if (FD_ISSET (ptr->fd, &readfds))
-                               if (ping_receive_one (ptr->fd, ph, &nowtime) == 0)
-                                       ret++;
-               }
-       } /* while (1) */
-       
-       return (ret);
-}
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Sending functions:                                                        *
- *                                                                           *
- * ping_send_all                                                             *
- * +-> ping_send_one_ipv4                                                    *
- * `-> ping_send_one_ipv6                                                    *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-static ssize_t ping_sendto (pingobj_t *obj, pinghost_t *ph,
-               const void *buf, size_t buflen)
-{
-       ssize_t ret;
-
-       if (gettimeofday (ph->timer, NULL) == -1)
-       {
-               timerclear (ph->timer);
-               return (-1);
-       }
-
-       ret = sendto (ph->fd, buf, buflen, 0,
-                       (struct sockaddr *) ph->addr, ph->addrlen);
-
-       if (ret < 0)
-       {
-#if defined(EHOSTUNREACH)
-               if (errno == EHOSTUNREACH)
-                       return (0);
-#endif
-#if defined(ENETUNREACH)
-               if (errno == ENETUNREACH)
-                       return (0);
-#endif
-               ping_set_error (obj, "sendto", strerror (errno));
-       }
-
-       return (ret);
-}
-
-static int ping_send_one_ipv4 (pingobj_t *obj, pinghost_t *ph)
-{
-       struct icmp *icmp4;
-       int status;
-
-       char buf[4096];
-       int  buflen;
-
-       char *data;
-       int   datalen;
-
-       dprintf ("ph->hostname = %s\n", ph->hostname);
-
-       memset (buf, '\0', sizeof (buf));
-       icmp4 = (struct icmp *) buf;
-       data  = (char *) (icmp4 + 1);
-
-       icmp4->icmp_type  = ICMP_ECHO;
-       icmp4->icmp_code  = 0;
-       icmp4->icmp_cksum = 0;
-       icmp4->icmp_id    = htons (ph->ident);
-       icmp4->icmp_seq   = htons (ph->sequence);
-
-       buflen = 4096 - sizeof (struct icmp);
-       strncpy (data, ph->data, buflen);
-       datalen = strlen (data);
-
-       buflen = datalen + sizeof (struct icmp);
-
-       icmp4->icmp_cksum = ping_icmp4_checksum (buf, buflen);
-
-       dprintf ("Sending ICMPv4 package with ID 0x%04x\n", ph->ident);
-
-       status = ping_sendto (obj, ph, buf, buflen);
-       if (status < 0)
-       {
-               perror ("ping_sendto");
-               return (-1);
-       }
-
-       dprintf ("sendto: status = %i\n", status);
-
-       return (0);
-}
-
-static int ping_send_one_ipv6 (pingobj_t *obj, pinghost_t *ph)
-{
-       struct icmp6_hdr *icmp6;
-       int status;
-
-       char buf[4096];
-       int  buflen;
-
-       char *data;
-       int   datalen;
-
-       dprintf ("ph->hostname = %s\n", ph->hostname);
-
-       memset (buf, '\0', sizeof (buf));
-       icmp6 = (struct icmp6_hdr *) buf;
-       data  = (char *) (icmp6 + 1);
-
-       icmp6->icmp6_type  = ICMP6_ECHO_REQUEST;
-       icmp6->icmp6_code  = 0;
-       /* The checksum will be calculated by the TCP/IP stack.  */
-       /* FIXME */
-       icmp6->icmp6_cksum = 0;
-       icmp6->icmp6_id    = htons (ph->ident);
-       icmp6->icmp6_seq   = htons (ph->sequence);
-
-       buflen = 4096 - sizeof (struct icmp6_hdr);
-       strncpy (data, ph->data, buflen);
-       datalen = strlen (data);
-
-       buflen = datalen + sizeof (struct icmp6_hdr);
-
-       dprintf ("Sending ICMPv6 package with ID 0x%04x\n", ph->ident);
-
-       status = ping_sendto (obj, ph, buf, buflen);
-       if (status < 0)
-       {
-               perror ("ping_sendto");
-               return (-1);
-       }
-
-       dprintf ("sendto: status = %i\n", status);
-
-       return (0);
-}
-
-static int ping_send_all (pingobj_t *obj)
-{
-       pinghost_t *ph;
-       pinghost_t *ptr;
-
-       int ret;
-
-       ret = 0;
-       ph = obj->head;
-
-       for (ptr = ph; ptr != NULL; ptr = ptr->next)
-       {
-               /* start timer.. The GNU `ping6' starts the timer before
-                * sending the packet, so I will do that too */
-               if (gettimeofday (ptr->timer, NULL) == -1)
-               {
-                       dprintf ("gettimeofday: %s\n", strerror (errno));
-                       timerclear (ptr->timer);
-                       ret--;
-                       continue;
-               }
-               else
-               {
-                       dprintf ("timer set for hostname = %s\n", ptr->hostname);
-               }
-
-               if (ptr->addrfamily == AF_INET6)
-               {       
-                       dprintf ("Sending ICMPv6 echo request to `%s'\n", ptr->hostname);
-                       if (ping_send_one_ipv6 (obj, ptr) != 0)
-                       {
-                               timerclear (ptr->timer);
-                               ret--;
-                               continue;
-                       }
-               }
-               else if (ptr->addrfamily == AF_INET)
-               {
-                       dprintf ("Sending ICMPv4 echo request to `%s'\n", ptr->hostname);
-                       if (ping_send_one_ipv4 (obj, ptr) != 0)
-                       {
-                               timerclear (ptr->timer);
-                               ret--;
-                               continue;
-                       }
-               }
-               else /* this should not happen */
-               {
-                       dprintf ("Unknown address family: %i\n", ptr->addrfamily);
-                       timerclear (ptr->timer);
-                       ret--;
-                       continue;
-               }
-
-               ptr->sequence++;
-       }
-
-       return (ret);
-}
-
-/*
- * Set the TTL of a socket protocol independently.
- */
-static int ping_set_ttl (pinghost_t *ph, int ttl)
-{
-       int ret = -2;
-
-       if (ph->addrfamily == AF_INET)
-       {
-               ret = setsockopt (ph->fd, IPPROTO_IP, IP_TTL, &ttl, sizeof (ttl));
-       }
-       else if (ph->addrfamily == AF_INET6)
-       {
-               ret = setsockopt (ph->fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof (ttl));
-       }
-
-       return (ret);
-}
-
-static int ping_get_ident (void)
-{
-       int fd;
-       static int did_seed = 0;
-
-       int retval;
-
-       if (did_seed == 0)
-       {
-               if ((fd = open ("/dev/urandom", O_RDONLY)) != -1)
-               {
-                       unsigned int seed;
-
-                       if (read (fd, &seed, sizeof (seed)) != -1)
-                       {
-                               did_seed = 1;
-                               dprintf ("Random seed: %i\n", seed);
-                               srandom (seed);
-                       }
-
-                       close (fd);
-               }
-               else
-               {
-                       dprintf ("open (/dev/urandom): %s\n", strerror (errno));
-               }
-       }
-
-       retval = (int) random ();
-
-       dprintf ("Random number: %i\n", retval);
-       
-       return (retval);
-}
-
-static pinghost_t *ping_alloc (void)
-{
-       pinghost_t *ph;
-       size_t      ph_size;
-
-       ph_size = sizeof (pinghost_t)
-               + sizeof (struct sockaddr_storage)
-               + sizeof (struct timeval);
-
-       ph = (pinghost_t *) malloc (ph_size);
-       if (ph == NULL)
-               return (NULL);
-
-       memset (ph, '\0', ph_size);
-
-       ph->timer   = (struct timeval *) (ph + 1);
-       ph->addr    = (struct sockaddr_storage *) (ph->timer + 1);
-
-       ph->addrlen = sizeof (struct sockaddr_storage);
-       ph->latency = -1.0;
-       ph->ident   = ping_get_ident () & 0xFFFF;
-
-       return (ph);
-}
-
-static void ping_free (pinghost_t *ph)
-{
-       if (ph->hostname != NULL)
-               free (ph->hostname);
-
-       if (ph->data != NULL)
-               free (ph->data);
-
-       free (ph);
-}
-
-/*
- * public methods
- */
-const char *ping_get_error (pingobj_t *obj)
-{
-       return (obj->errmsg);
-}
-
-pingobj_t *ping_construct (void)
-{
-       pingobj_t *obj;
-
-       if ((obj = (pingobj_t *) malloc (sizeof (pingobj_t))) == NULL)
-               return (NULL);
-       memset (obj, '\0', sizeof (pingobj_t));
-
-       obj->timeout    = PING_DEF_TIMEOUT;
-       obj->ttl        = PING_DEF_TTL;
-       obj->addrfamily = PING_DEF_AF;
-       obj->data       = strdup (PING_DEF_DATA);
-
-       return (obj);
-}
-
-void ping_destroy (pingobj_t *obj)
-{
-       pinghost_t *current;
-       pinghost_t *next;
-
-       current = obj->head;
-       next = NULL;
-
-       while (current != NULL)
-       {
-               next = current->next;
-               ping_free (current);
-               current = next;
-       }
-
-       if (obj->data != NULL)
-               free (obj->data);
-
-       free (obj);
-
-       return;
-}
-
-int ping_setopt (pingobj_t *obj, int option, void *value)
-{
-       int ret = 0;
-
-       switch (option)
-       {
-               case PING_OPT_TIMEOUT:
-                       obj->timeout = *((double *) value);
-                       if (obj->timeout < 0.0)
-                       {
-                               obj->timeout = PING_DEF_TIMEOUT;
-                               ret = -1;
-                       }
-                       break;
-
-               case PING_OPT_TTL:
-                       obj->ttl = *((int *) value);
-                       if ((obj->ttl < 1) || (obj->ttl > 255))
-                       {
-                               obj->ttl = PING_DEF_TTL;
-                               ret = -1;
-                       }
-                       break;
-
-               case PING_OPT_AF:
-                       obj->addrfamily = *((int *) value);
-                       if ((obj->addrfamily != AF_UNSPEC)
-                                       && (obj->addrfamily != AF_INET)
-                                       && (obj->addrfamily != AF_INET6))
-                       {
-                               obj->addrfamily = PING_DEF_AF;
-                               ret = -1;
-                       }
-                       break;
-
-               case PING_OPT_DATA:
-                       if (obj->data != NULL)
-                       {
-                               free (obj->data);
-                               obj->data = NULL;
-                       }
-                       obj->data = strdup ((const char *) value);
-                       break;
-
-               default:
-                       ret = -2;
-       } /* switch (option) */
-
-       return (ret);
-} /* int ping_setopt */
-
-
-int ping_send (pingobj_t *obj)
-{
-       int ret;
-
-       if (ping_send_all (obj) < 0)
-               return (-1);
-
-       if ((ret = ping_receive_all (obj)) < 0)
-               return (-2);
-
-       return (ret);
-}
-
-static pinghost_t *ping_host_search (pinghost_t *ph, const char *host)
-{
-       while (ph != NULL)
-       {
-               if (strcasecmp (ph->hostname, host) == 0)
-                       break;
-
-               ph = ph->next;
-       }
-
-       return (ph);
-}
-
-int ping_host_add (pingobj_t *obj, const char *host)
-{
-       pinghost_t *ph;
-
-       struct addrinfo  ai_hints;
-       struct addrinfo *ai_list, *ai_ptr;
-       int              ai_return;
-
-       dprintf ("host = %s\n", host);
-
-       if (ping_host_search (obj->head, host) != NULL)
-               return (0);
-
-       memset (&ai_hints, '\0', sizeof (ai_hints));
-       ai_hints.ai_flags     = 0;
-#ifdef AI_ADDRCONFIG
-       ai_hints.ai_flags    |= AI_ADDRCONFIG;
-#endif
-       ai_hints.ai_family    = obj->addrfamily;
-       ai_hints.ai_socktype  = SOCK_RAW;
-
-       if ((ph = ping_alloc ()) == NULL)
-       {
-               dprintf ("Out of memory!\n");
-               return (-1);
-       }
-
-       if ((ph->hostname = strdup (host)) == NULL)
-       {
-               dprintf ("Out of memory!\n");
-               ping_set_error (obj, "strdup", strerror (errno));
-               ping_free (ph);
-               return (-1);
-       }
-
-       /* obj->data is not garuanteed to be != NULL */
-       if ((ph->data = strdup (obj->data == NULL ? PING_DEF_DATA : obj->data)) == NULL)
-       {
-               dprintf ("Out of memory!\n");
-               ping_set_error (obj, "strdup", strerror (errno));
-               ping_free (ph);
-               return (-1);
-       }
-
-       if ((ai_return = getaddrinfo (host, NULL, &ai_hints, &ai_list)) != 0)
-       {
-               dprintf ("getaddrinfo failed\n");
-               ping_set_error (obj, "getaddrinfo",
-                               (ai_return == EAI_SYSTEM)
-                               ? strerror (errno)
-                               : gai_strerror (ai_return));
-               ping_free (ph);
-               return (-1);
-       }
-
-       if (ai_list == NULL)
-               ping_set_error (obj, "getaddrinfo", "No hosts returned");
-
-       for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
-       {
-               ph->fd = -1;
-
-               if (ai_ptr->ai_family == AF_INET)
-               {
-                       ai_ptr->ai_socktype = SOCK_RAW;
-                       ai_ptr->ai_protocol = IPPROTO_ICMP;
-               }
-               else if (ai_ptr->ai_family == AF_INET6)
-               {
-                       ai_ptr->ai_socktype = SOCK_RAW;
-                       ai_ptr->ai_protocol = IPPROTO_ICMPV6;
-               }
-               else
-               {
-                       char errmsg[PING_ERRMSG_LEN];
-
-                       snprintf (errmsg, PING_ERRMSG_LEN, "Unknown `ai_family': %i", ai_ptr->ai_family);
-                       errmsg[PING_ERRMSG_LEN - 1] = '\0';
-
-                       dprintf (errmsg);
-                       ping_set_error (obj, "getaddrinfo", errmsg);
-                       continue;
-               }
-
-               /* TODO: Move this to a static function `ping_open_socket' and
-                * call it whenever the socket dies. */
-               ph->fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
-               if (ph->fd == -1)
-               {
-                       dprintf ("socket: %s\n", strerror (errno));
-                       ping_set_error (obj, "socket", strerror (errno));
-                       continue;
-               }
-
-/*
- * The majority vote of operating systems has decided that you don't need to
- * bind here. This code should be reactivated to bind to a specific address,
- * though. See the `-I' option of `ping(1)' (GNU).  -octo
- */
-#if 0
-               if (bind (ph->fd, (struct sockaddr *) &sockaddr, sockaddr_len) == -1)
-               {
-                       dprintf ("bind: %s\n", strerror (errno));
-                       ping_set_error (obj, "bind", strerror (errno));
-                       close (ph->fd);
-                       ph->fd = -1;
-                       continue;
-               }
-#endif
-
-               assert (sizeof (struct sockaddr_storage) >= ai_ptr->ai_addrlen);
-               memset (ph->addr, '\0', sizeof (struct sockaddr_storage));
-               memcpy (ph->addr, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
-               ph->addrlen = ai_ptr->ai_addrlen;
-               ph->addrfamily = ai_ptr->ai_family;
-
-               break;
-       }
-
-       freeaddrinfo (ai_list);
-
-       if (ph->fd < 0)
-       {
-               free (ph->hostname);
-               free (ph);
-               return (-1);
-       }
-
-       /*
-        * Adding in the front is much easier, but then the iterator will
-        * return the host that was added last as first host. That's just not
-        * nice. -octo
-        */
-       if (obj->head == NULL)
-       {
-               obj->head = ph;
-       }
-       else
-       {
-               pinghost_t *hptr;
-
-               hptr = obj->head;
-               while (hptr->next != NULL)
-                       hptr = hptr->next;
-
-               assert ((hptr != NULL) && (hptr->next == NULL));
-               hptr->next = ph;
-       }
-
-       ping_set_ttl (ph, obj->ttl);
-
-       return (0);
-}
-
-int ping_host_remove (pingobj_t *obj, const char *host)
-{
-       pinghost_t *pre, *cur;
-
-       pre = NULL;
-       cur = obj->head;
-
-       while (cur != NULL)
-       {
-               if (strcasecmp (host, cur->hostname))
-                       break;
-
-               pre = cur;
-               cur = cur->next;
-       }
-
-       if (cur == NULL)
-       {
-               ping_set_error (obj, "ping_host_remove", "Host not found");
-               return (-1);
-       }
-
-       if (pre == NULL)
-               obj->head = cur->next;
-       else
-               pre->next = cur->next;
-       
-       if (cur->fd >= 0)
-               close (cur->fd);
-
-       ping_free (cur);
-
-       return (0);
-}
-
-pingobj_iter_t *ping_iterator_get (pingobj_t *obj)
-{
-       return ((pingobj_iter_t *) obj->head);
-}
-
-pingobj_iter_t *ping_iterator_next (pingobj_iter_t *iter)
-{
-       return ((pingobj_iter_t *) iter->next);
-}
-
-int ping_iterator_get_info (pingobj_iter_t *iter, int info,
-               void *buffer, size_t *buffer_len)
-{
-       int ret = EINVAL;
-
-       size_t orig_buffer_len = *buffer_len;
-
-       switch (info)
-       {
-               case PING_INFO_HOSTNAME:
-                       ret = ENOMEM;
-                       *buffer_len = strlen (iter->hostname);
-                       if (orig_buffer_len <= *buffer_len)
-                               break;
-                       /* Since (orig_buffer_len > *buffer_len) `strncpy'
-                        * will copy `*buffer_len' and pad the rest of
-                        * `buffer' with null-bytes */
-                       strncpy (buffer, iter->hostname, orig_buffer_len);
-                       ret = 0;
-                       break;
-
-               case PING_INFO_ADDRESS:
-                       ret = getnameinfo ((struct sockaddr *) iter->addr,
-                                       iter->addrlen,
-                                       (char *) buffer,
-                                       *buffer_len,
-                                       NULL, 0,
-                                       NI_NUMERICHOST);
-                       if (ret != 0)
-                       {
-                               if ((ret == EAI_MEMORY)
-#ifdef EAI_OVERFLOW
-                                               || (ret == EAI_OVERFLOW)
-#endif
-                                  )
-                                       ret = ENOMEM;
-                               else if (ret == EAI_SYSTEM)
-                                       /* XXX: Not thread-safe! */
-                                       ret = errno;
-                               else
-                                       ret = EINVAL;
-                       }
-                       break;
-
-               case PING_INFO_FAMILY:
-                       ret = ENOMEM;
-                       *buffer_len = sizeof (int);
-                       if (orig_buffer_len < sizeof (int))
-                               break;
-                       *((int *) buffer) = iter->addrfamily;
-                       ret = 0;
-                       break;
-
-               case PING_INFO_LATENCY:
-                       ret = ENOMEM;
-                       *buffer_len = sizeof (double);
-                       if (orig_buffer_len < sizeof (double))
-                               break;
-                       *((double *) buffer) = iter->latency;
-                       ret = 0;
-                       break;
-
-               case PING_INFO_SEQUENCE:
-                       ret = ENOMEM;
-                       *buffer_len = sizeof (unsigned int);
-                       if (orig_buffer_len < sizeof (unsigned int))
-                               break;
-                       *((unsigned int *) buffer) = (unsigned int) iter->sequence;
-                       ret = 0;
-                       break;
-
-               case PING_INFO_IDENT:
-                       ret = ENOMEM;
-                       *buffer_len = sizeof (uint16_t);
-                       if (orig_buffer_len < sizeof (uint16_t))
-                               break;
-                       *((uint16_t *) buffer) = (uint16_t) iter->ident;
-                       ret = 0;
-                       break;
-
-               case PING_INFO_DATA:
-                       ret = ENOMEM;
-                       *buffer_len = strlen (iter->data);
-                       if (orig_buffer_len < *buffer_len)
-                               break;
-                       strncpy ((char *) buffer, iter->data, orig_buffer_len);
-                       ret = 0;
-                       break;
-       }
-
-       return (ret);
-}
-
-void *ping_iterator_get_context (pingobj_iter_t *iter)
-{
-       return (iter->context);
-}
-
-void ping_iterator_set_context (pingobj_iter_t *iter, void *context)
-{
-       iter->context = context;
-}
diff --git a/src/liboping/oping.h b/src/liboping/oping.h
deleted file mode 100644 (file)
index 54d0310..0000000
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * Object oriented C module to send ICMP and ICMPv6 `echo's.
- * Copyright (C) 2006  Florian octo Forster <octo at verplant.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
- */
-
-#ifndef OCTO_PING_H
-#define OCTO_PING_H 1
-
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#if HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-#if HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-
-/*
- * Type definitions
- */
-struct pinghost;
-typedef struct pinghost pinghost_t;
-
-typedef pinghost_t pingobj_iter_t;
-
-struct pingobj;
-typedef struct pingobj pingobj_t;
-
-#define PING_OPT_TIMEOUT 0x01
-#define PING_OPT_TTL     0x02
-#define PING_OPT_AF      0x04
-#define PING_OPT_DATA    0x08
-
-#define PING_DEF_TIMEOUT 1.0
-#define PING_DEF_TTL     255
-#define PING_DEF_AF      AF_UNSPEC
-#define PING_DEF_DATA    "Florian Forster <octo@verplant.org> http://verplant.org/"
-
-/*
- * Method definitions
- */
-pingobj_t *ping_construct (void);
-void ping_destroy (pingobj_t *obj);
-
-int ping_setopt (pingobj_t *obj, int option, void *value);
-
-int ping_send (pingobj_t *obj);
-
-int ping_host_add (pingobj_t *obj, const char *host);
-int ping_host_remove (pingobj_t *obj, const char *host);
-
-pingobj_iter_t *ping_iterator_get (pingobj_t *obj);
-pingobj_iter_t *ping_iterator_next (pingobj_iter_t *iter);
-
-#define PING_INFO_HOSTNAME 1
-#define PING_INFO_ADDRESS  2
-#define PING_INFO_FAMILY   3
-#define PING_INFO_LATENCY  4
-#define PING_INFO_SEQUENCE 5
-#define PING_INFO_IDENT    6
-#define PING_INFO_DATA     7
-int ping_iterator_get_info (pingobj_iter_t *iter, int info,
-               void *buffer, size_t *buffer_len);
-
-const char *ping_get_error (pingobj_t *obj);
-
-void *ping_iterator_get_context (pingobj_iter_t *iter);
-void  ping_iterator_set_context (pingobj_iter_t *iter, void *context);
-
-#endif /* OCTO_PING_H */
index 382386b..03af7a3 100644 (file)
@@ -143,7 +143,8 @@ static void logfile_print (const char *msg, time_t timestamp_time)
        return;
 } /* void logfile_print */
 
-static void logfile_log (int severity, const char *msg)
+static void logfile_log (int severity, const char *msg,
+               user_data_t __attribute__((unused)) *user_data)
 {
        if (severity > log_level)
                return;
@@ -151,7 +152,8 @@ static void logfile_log (int severity, const char *msg)
        logfile_print (msg, time (NULL));
 } /* void logfile_log (int, const char *) */
 
-static int logfile_notification (const notification_t *n)
+static int logfile_notification (const notification_t *n,
+               user_data_t __attribute__((unused)) *user_data)
 {
        char  buf[1024] = "";
        char *buf_ptr = buf;
@@ -185,7 +187,8 @@ static int logfile_notification (const notification_t *n)
 
        buf[sizeof (buf) - 1] = '\0';
 
-       logfile_print (buf, n->time);
+       logfile_print (buf,
+                       (n->time > 0) ? n->time : time (NULL));
 
        return (0);
 } /* int logfile_notification */
@@ -194,8 +197,9 @@ void module_register (void)
 {
        plugin_register_config ("logfile", logfile_config,
                        config_keys, config_keys_num);
-       plugin_register_log ("logfile", logfile_log);
-       plugin_register_notification ("logfile", logfile_notification);
+       plugin_register_log ("logfile", logfile_log, /* user_data = */ NULL);
+       plugin_register_notification ("logfile", logfile_notification,
+                       /* user_data = */ NULL);
 } /* void module_register (void) */
 
 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */
diff --git a/src/memcachec.c b/src/memcachec.c
new file mode 100644 (file)
index 0000000..0868a9c
--- /dev/null
@@ -0,0 +1,533 @@
+/**
+ * collectd - src/memcachec.c
+ * Copyright (C) 2009       Doug MacEachern
+ * Copyright (C) 2006-2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Doug MacEachern <Doug.MacEachern at hyperic.com>
+ *   Florian octo Forster <octo at verplant.org>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "configfile.h"
+#include "utils_match.h"
+
+#include <libmemcached/memcached.h>
+
+/*
+ * Data types
+ */
+struct web_match_s;
+typedef struct web_match_s web_match_t;
+struct web_match_s /* {{{ */
+{
+  char *regex;
+  int dstype;
+  char *type;
+  char *instance;
+
+  cu_match_t *match;
+
+  web_match_t *next;
+}; /* }}} */
+
+struct web_page_s;
+typedef struct web_page_s web_page_t;
+struct web_page_s /* {{{ */
+{
+  char *instance;
+
+  char *server;
+  char *key;
+
+  memcached_st *memc;
+  char *buffer;
+
+  web_match_t *matches;
+
+  web_page_t *next;
+}; /* }}} */
+
+/*
+ * Global variables;
+ */
+static web_page_t *pages_g = NULL;
+
+/*
+ * Private functions
+ */
+static void cmc_web_match_free (web_match_t *wm) /* {{{ */
+{
+  if (wm == NULL)
+    return;
+
+  sfree (wm->regex);
+  sfree (wm->type);
+  sfree (wm->instance);
+  match_destroy (wm->match);
+  cmc_web_match_free (wm->next);
+  sfree (wm);
+} /* }}} void cmc_web_match_free */
+
+static void cmc_web_page_free (web_page_t *wp) /* {{{ */
+{
+  if (wp == NULL)
+    return;
+
+  if (wp->memc != NULL)
+    memcached_free(wp->memc);
+  wp->memc = NULL;
+
+  sfree (wp->instance);
+  sfree (wp->server);
+  sfree (wp->key);
+  sfree (wp->buffer);
+
+  cmc_web_match_free (wp->matches);
+  cmc_web_page_free (wp->next);
+  sfree (wp);
+} /* }}} void cmc_web_page_free */
+
+static int cmc_page_init_memc (web_page_t *wp) /* {{{ */
+{
+  memcached_server_st *server;
+
+  wp->memc = memcached_create(NULL);
+  if (wp->memc == NULL)
+  {
+    ERROR ("memcachec plugin: memcached_create failed.");
+    return (-1);
+  }
+
+  server = memcached_servers_parse (wp->server);
+  memcached_server_push (wp->memc, server);
+  memcached_server_list_free (server);
+
+  return (0);
+} /* }}} int cmc_page_init_memc */
+
+static int cmc_config_add_string (const char *name, char **dest, /* {{{ */
+    oconfig_item_t *ci)
+{
+  if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("memcachec plugin: `%s' needs exactly one string argument.", name);
+    return (-1);
+  }
+
+  sfree (*dest);
+  *dest = strdup (ci->values[0].value.string);
+  if (*dest == NULL)
+    return (-1);
+
+  return (0);
+} /* }}} int cmc_config_add_string */
+
+static int cmc_config_add_match_dstype (int *dstype_ret, /* {{{ */
+    oconfig_item_t *ci)
+{
+  int dstype;
+
+  if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("memcachec plugin: `DSType' needs exactly one string argument.");
+    return (-1);
+  }
+
+  if (strncasecmp ("Gauge", ci->values[0].value.string,
+        strlen ("Gauge")) == 0)
+  {
+    dstype = UTILS_MATCH_DS_TYPE_GAUGE;
+    if (strcasecmp ("GaugeAverage", ci->values[0].value.string) == 0)
+      dstype |= UTILS_MATCH_CF_GAUGE_AVERAGE;
+    else if (strcasecmp ("GaugeMin", ci->values[0].value.string) == 0)
+      dstype |= UTILS_MATCH_CF_GAUGE_MIN;
+    else if (strcasecmp ("GaugeMax", ci->values[0].value.string) == 0)
+      dstype |= UTILS_MATCH_CF_GAUGE_MAX;
+    else if (strcasecmp ("GaugeLast", ci->values[0].value.string) == 0)
+      dstype |= UTILS_MATCH_CF_GAUGE_LAST;
+    else
+      dstype = 0;
+  }
+  else if (strncasecmp ("Counter", ci->values[0].value.string,
+        strlen ("Counter")) == 0)
+  {
+    dstype = UTILS_MATCH_DS_TYPE_COUNTER;
+    if (strcasecmp ("CounterSet", ci->values[0].value.string) == 0)
+      dstype |= UTILS_MATCH_CF_COUNTER_SET;
+    else if (strcasecmp ("CounterAdd", ci->values[0].value.string) == 0)
+      dstype |= UTILS_MATCH_CF_COUNTER_ADD;
+    else if (strcasecmp ("CounterInc", ci->values[0].value.string) == 0)
+      dstype |= UTILS_MATCH_CF_COUNTER_INC;
+    else
+      dstype = 0;
+  }
+  else
+  {
+    dstype = 0;
+  }
+
+  if (dstype == 0)
+  {
+    WARNING ("memcachec plugin: `%s' is not a valid argument to `DSType'.",
+       ci->values[0].value.string);
+    return (-1);
+  }
+
+  *dstype_ret = dstype;
+  return (0);
+} /* }}} int cmc_config_add_match_dstype */
+
+static int cmc_config_add_match (web_page_t *page, /* {{{ */
+    oconfig_item_t *ci)
+{
+  web_match_t *match;
+  int status;
+  int i;
+
+  if (ci->values_num != 0)
+  {
+    WARNING ("memcachec plugin: Ignoring arguments for the `Match' block.");
+  }
+
+  match = (web_match_t *) malloc (sizeof (*match));
+  if (match == NULL)
+  {
+    ERROR ("memcachec plugin: malloc failed.");
+    return (-1);
+  }
+  memset (match, 0, sizeof (*match));
+
+  status = 0;
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+
+    if (strcasecmp ("Regex", child->key) == 0)
+      status = cmc_config_add_string ("Regex", &match->regex, child);
+    else if (strcasecmp ("DSType", child->key) == 0)
+      status = cmc_config_add_match_dstype (&match->dstype, child);
+    else if (strcasecmp ("Type", child->key) == 0)
+      status = cmc_config_add_string ("Type", &match->type, child);
+    else if (strcasecmp ("Instance", child->key) == 0)
+      status = cmc_config_add_string ("Instance", &match->instance, child);
+    else
+    {
+      WARNING ("memcachec plugin: Option `%s' not allowed here.", child->key);
+      status = -1;
+    }
+
+    if (status != 0)
+      break;
+  } /* for (i = 0; i < ci->children_num; i++) */
+
+  while (status == 0)
+  {
+    if (match->regex == NULL)
+    {
+      WARNING ("memcachec plugin: `Regex' missing in `Match' block.");
+      status = -1;
+    }
+
+    if (match->type == NULL)
+    {
+      WARNING ("memcachec plugin: `Type' missing in `Match' block.");
+      status = -1;
+    }
+
+    if (match->dstype == 0)
+    {
+      WARNING ("memcachec plugin: `DSType' missing in `Match' block.");
+      status = -1;
+    }
+
+    break;
+  } /* while (status == 0) */
+
+  if (status != 0)
+    return (status);
+
+  match->match = match_create_simple (match->regex, match->dstype);
+  if (match->match == NULL)
+  {
+    ERROR ("memcachec plugin: tail_match_add_match_simple failed.");
+    cmc_web_match_free (match);
+    return (-1);
+  }
+  else
+  {
+    web_match_t *prev;
+
+    prev = page->matches;
+    while ((prev != NULL) && (prev->next != NULL))
+      prev = prev->next;
+
+    if (prev == NULL)
+      page->matches = match;
+    else
+      prev->next = match;
+  }
+
+  return (0);
+} /* }}} int cmc_config_add_match */
+
+static int cmc_config_add_page (oconfig_item_t *ci) /* {{{ */
+{
+  web_page_t *page;
+  int status;
+  int i;
+
+  if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("memcachec plugin: `Page' blocks need exactly one string argument.");
+    return (-1);
+  }
+
+  page = (web_page_t *) malloc (sizeof (*page));
+  if (page == NULL)
+  {
+    ERROR ("memcachec plugin: malloc failed.");
+    return (-1);
+  }
+  memset (page, 0, sizeof (*page));
+  page->server = NULL;
+  page->key = NULL;
+
+  page->instance = strdup (ci->values[0].value.string);
+  if (page->instance == NULL)
+  {
+    ERROR ("memcachec plugin: strdup failed.");
+    sfree (page);
+    return (-1);
+  }
+
+  /* Process all children */
+  status = 0;
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+
+    if (strcasecmp ("Server", child->key) == 0)
+      status = cmc_config_add_string ("Server", &page->server, child);
+    if (strcasecmp ("Key", child->key) == 0)
+      status = cmc_config_add_string ("Key", &page->key, child);
+    else if (strcasecmp ("Match", child->key) == 0)
+      /* Be liberal with failing matches => don't set `status'. */
+      cmc_config_add_match (page, child);
+    else
+    {
+      WARNING ("memcachec plugin: Option `%s' not allowed here.", child->key);
+      status = -1;
+    }
+
+    if (status != 0)
+      break;
+  } /* for (i = 0; i < ci->children_num; i++) */
+
+  /* Additionial sanity checks and libCURL initialization. */
+  while (status == 0)
+  {
+    if (page->server == NULL)
+    {
+      WARNING ("memcachec plugin: `Server' missing in `Page' block.");
+      status = -1;
+    }
+
+    if (page->key == NULL)
+    {
+      WARNING ("memcachec plugin: `Key' missing in `Page' block.");
+      status = -1;
+    }
+
+    if (page->matches == NULL)
+    {
+      assert (page->instance != NULL);
+      WARNING ("memcachec plugin: No (valid) `Match' block "
+          "within `Page' block `%s'.", page->instance);
+      status = -1;
+    }
+
+    if (status == 0)
+      status = cmc_page_init_memc (page);
+
+    break;
+  } /* while (status == 0) */
+
+  if (status != 0)
+  {
+    cmc_web_page_free (page);
+    return (status);
+  }
+
+  /* Add the new page to the linked list */
+  if (pages_g == NULL)
+    pages_g = page;
+  else
+  {
+    web_page_t *prev;
+
+    prev = pages_g;
+    while ((prev != NULL) && (prev->next != NULL))
+      prev = prev->next;
+    prev->next = page;
+  }
+
+  return (0);
+} /* }}} int cmc_config_add_page */
+
+static int cmc_config (oconfig_item_t *ci) /* {{{ */
+{
+  int success;
+  int errors;
+  int status;
+  int i;
+
+  success = 0;
+  errors = 0;
+
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+
+    if (strcasecmp ("Page", child->key) == 0)
+    {
+      status = cmc_config_add_page (child);
+      if (status == 0)
+        success++;
+      else
+        errors++;
+    }
+    else
+    {
+      WARNING ("memcachec plugin: Option `%s' not allowed here.", child->key);
+      errors++;
+    }
+  }
+
+  if ((success == 0) && (errors > 0))
+  {
+    ERROR ("memcachec plugin: All statements failed.");
+    return (-1);
+  }
+
+  return (0);
+} /* }}} int cmc_config */
+
+static int cmc_init (void) /* {{{ */
+{
+  if (pages_g == NULL)
+  {
+    INFO ("memcachec plugin: No pages have been defined.");
+    return (-1);
+  }
+  return (0);
+} /* }}} int cmc_init */
+
+static void cmc_submit (const web_page_t *wp, const web_match_t *wm, /* {{{ */
+    const cu_match_value_t *mv)
+{
+  value_t values[1];
+  value_list_t vl = VALUE_LIST_INIT;
+
+  values[0] = mv->value;
+
+  vl.values = values;
+  vl.values_len = 1;
+  vl.time = time (NULL);
+  sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+  sstrncpy (vl.plugin, "memcachec", sizeof (vl.plugin));
+  sstrncpy (vl.plugin_instance, wp->instance, sizeof (vl.plugin_instance));
+  sstrncpy (vl.type, wm->type, sizeof (vl.type));
+  sstrncpy (vl.type_instance, wm->instance, sizeof (vl.type_instance));
+
+  plugin_dispatch_values (&vl);
+} /* }}} void cmc_submit */
+
+static int cmc_read_page (web_page_t *wp) /* {{{ */
+{
+  web_match_t *wm;
+  memcached_return rc;
+  size_t string_length;
+  uint32_t flags;
+  int status;
+
+  if (wp->memc == NULL)
+    return (-1);
+
+  wp->buffer = memcached_get (wp->memc, wp->key, strlen (wp->key),
+                              &string_length, &flags, &rc);
+  if (rc != MEMCACHED_SUCCESS)
+  {
+    ERROR ("memcachec plugin: memcached_get failed: %s",
+        memcached_strerror (wp->memc, rc));
+    return (-1);
+  }
+
+  for (wm = wp->matches; wm != NULL; wm = wm->next)
+  {
+    cu_match_value_t *mv;
+
+    status = match_apply (wm->match, wp->buffer);
+    if (status != 0)
+    {
+      WARNING ("memcachec plugin: match_apply failed.");
+      continue;
+    }
+
+    mv = match_get_user_data (wm->match);
+    if (mv == NULL)
+    {
+      WARNING ("memcachec plugin: match_get_user_data returned NULL.");
+      continue;
+    }
+
+    cmc_submit (wp, wm, mv);
+  } /* for (wm = wp->matches; wm != NULL; wm = wm->next) */
+
+  sfree (wp->buffer);
+
+  return (0);
+} /* }}} int cmc_read_page */
+
+static int cmc_read (void) /* {{{ */
+{
+  web_page_t *wp;
+
+  for (wp = pages_g; wp != NULL; wp = wp->next)
+    cmc_read_page (wp);
+
+  return (0);
+} /* }}} int cmc_read */
+
+static int cmc_shutdown (void) /* {{{ */
+{
+  cmc_web_page_free (pages_g);
+  pages_g = NULL;
+
+  return (0);
+} /* }}} int cmc_shutdown */
+
+void module_register (void)
+{
+  plugin_register_complex_config ("memcachec", cmc_config);
+  plugin_register_init ("memcachec", cmc_init);
+  plugin_register_read ("memcachec", cmc_read);
+  plugin_register_shutdown ("memcachec", cmc_shutdown);
+} /* void module_register */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
index 1c009a0..a129f40 100644 (file)
@@ -1,6 +1,8 @@
 /**
  * collectd - src/mysql.c
- * Copyright (C) 2006,2007  Florian octo Forster
+ * Copyright (C) 2006-2009  Florian octo Forster
+ * Copyright (C) 2009  Doug MacEachern
+ * Copyright (C) 2009  Sebastian tokkee Harl
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -17,6 +19,9 @@
  *
  * Authors:
  *   Florian octo Forster <octo at verplant.org>
+ *   Mirko Buffoni <briareos at eswat.org>
+ *   Doug MacEachern <dougm at hyperic.com>
+ *   Sebastian tokkee Harl <sh at tokkee.org>
  **/
 
 #include "collectd.h"
 
 /* TODO: Understand `Select_*' and possibly do that stuff as well.. */
 
-static const char *config_keys[] =
+struct mysql_database_s /* {{{ */
 {
-       "Host",
-       "User",
-       "Password",
-       "Database",
-       "Port",
-       "Socket",
-       NULL
+       /* instance == NULL  =>  legacy mode */
+       char *instance;
+       char *host;
+       char *user;
+       char *pass;
+       char *database;
+       char *socket;
+       int   port;
+
+       int   master_stats;
+       int   slave_stats;
+
+       int   slave_notif;
+       int   slave_io_running;
+       int   slave_sql_running;
+
+       MYSQL *con;
+       int    state;
 };
-static int config_keys_num = 6;
+typedef struct mysql_database_s mysql_database_t; /* }}} */
 
-static char *host = "localhost";
-static char *user;
-static char *pass;
-static char *db = NULL;
-static char *socket = NULL;
-static int   port = 0;
+static int mysql_read (user_data_t *ud);
 
-static MYSQL *getconnection (void)
+static void mysql_database_free (void *arg) /* {{{ */
 {
-       static MYSQL *con;
-       static int    state;
+       mysql_database_t *db;
 
-       static int wait_for = 0;
-       static int wait_increase = 60;
+       DEBUG ("mysql plugin: mysql_database_free (arg = %p);", arg);
 
-       if (state != 0)
+       db = (mysql_database_t *) arg;
+
+       if (db == NULL)
+               return;
+
+       if (db->con != NULL)
+               mysql_close (db->con);
+
+       sfree (db->host);
+       sfree (db->user);
+       sfree (db->pass);
+       sfree (db->socket);
+       sfree (db->instance);
+       sfree (db->database);
+       sfree (db);
+} /* }}} void mysql_database_free */
+
+/* Configuration handling functions {{{
+ *
+ * <Plugin mysql>
+ *   <Database "plugin_instance1">
+ *     Host "localhost"
+ *     Port 22000
+ *     ...
+ *   </Database>
+ * </Plugin>
+ */
+
+static int mysql_config_set_string (char **ret_string, /* {{{ */
+                                   oconfig_item_t *ci)
+{
+       char *string;
+
+       if ((ci->values_num != 1)
+           || (ci->values[0].type != OCONFIG_TYPE_STRING))
        {
-               int err;
-               if ((err = mysql_ping (con)) != 0)
+               WARNING ("mysql plugin: The `%s' config option "
+                        "needs exactly one string argument.", ci->key);
+               return (-1);
+       }
+
+       string = strdup (ci->values[0].value.string);
+       if (string == NULL)
+       {
+               ERROR ("mysql plugin: strdup failed.");
+               return (-1);
+       }
+
+       if (*ret_string != NULL)
+               free (*ret_string);
+       *ret_string = string;
+
+       return (0);
+} /* }}} int mysql_config_set_string */
+
+static int mysql_config_set_int (int *ret_int, /* {{{ */
+                                oconfig_item_t *ci)
+{
+       if ((ci->values_num != 1)
+           || (ci->values[0].type != OCONFIG_TYPE_NUMBER))
+       {
+               WARNING ("mysql plugin: The `%s' config option "
+                        "needs exactly one string argument.", ci->key);
+               return (-1);
+       }
+
+       *ret_int = ci->values[0].value.number;
+
+       return (0);
+} /* }}} int mysql_config_set_int */
+
+static int mysql_config_set_boolean (int *ret_boolean, /* {{{ */
+                               oconfig_item_t *ci)
+{
+       int status = 0;
+
+       if (ci->values_num != 1)
+               status = -1;
+
+       if (status == 0)
+       {
+               if (ci->values[0].type == OCONFIG_TYPE_BOOLEAN)
+                       *ret_boolean = ci->values[0].value.boolean;
+               else if (ci->values[0].type == OCONFIG_TYPE_STRING)
                {
-                       WARNING ("mysql_ping failed: %s", mysql_error (con));
-                       state = 0;
+                       if (IS_TRUE (ci->values[0].value.string))
+                               *ret_boolean = 1;
+                       else if (IS_FALSE (ci->values[0].value.string))
+                               *ret_boolean = 0;
+                       else
+                               status = -1;
                }
                else
+                       status = -1;
+       }
+
+       if (status != 0)
+       {
+               WARNING ("mysql plugin: The `%s' config option "
+                       "needs exactly one boolean argument.", ci->key);
+               return (-1);
+       }
+       return (0);
+} /* }}} mysql_config_set_boolean */
+
+static int mysql_config (oconfig_item_t *ci) /* {{{ */
+{
+       mysql_database_t *db;
+       int plugin_block;
+       int status = 0;
+       int i;
+
+       if ((ci->values_num != 1)
+           || (ci->values[0].type != OCONFIG_TYPE_STRING))
+       {
+               WARNING ("mysql plugin: The `Database' block "
+                        "needs exactly one string argument.");
+               return (-1);
+       }
+
+       db = (mysql_database_t *) malloc (sizeof (*db));
+       if (db == NULL)
+       {
+               ERROR ("mysql plugin: malloc failed.");
+               return (-1);
+       }
+       memset (db, 0, sizeof (*db));
+
+       /* initialize all the pointers */
+       db->host     = NULL;
+       db->user     = NULL;
+       db->pass     = NULL;
+       db->database = NULL;
+       db->socket   = NULL;
+       db->con      = NULL;
+
+       /* trigger a notification, if it's not running */
+       db->slave_io_running  = 1;
+       db->slave_sql_running = 1;
+
+       plugin_block = 1;
+       if (strcasecmp ("Plugin", ci->key) == 0)
+       {
+               db->instance = NULL;
+       }
+       else if (strcasecmp ("Database", ci->key) == 0)
+       {
+               plugin_block = 0;
+               status = mysql_config_set_string (&db->instance, ci);
+               if (status != 0)
                {
-                       state = 1;
-                       return (con);
+                       sfree (db);
+                       return (status);
                }
+               assert (db->instance != NULL);
+       }
+       else
+       {
+               ERROR ("mysql plugin: mysql_config: "
+                               "Invalid key: %s", ci->key);
+               return (-1);
        }
 
-       if (wait_for > 0)
+       /* Fill the `mysql_database_t' structure.. */
+       for (i = 0; i < ci->children_num; i++)
        {
-               wait_for -= interval_g;
-               return (NULL);
+               oconfig_item_t *child = ci->children + i;
+
+               if (strcasecmp ("Host", child->key) == 0)
+                       status = mysql_config_set_string (&db->host, child);
+               else if (strcasecmp ("User", child->key) == 0)
+                       status = mysql_config_set_string (&db->user, child);
+               else if (strcasecmp ("Password", child->key) == 0)
+                       status = mysql_config_set_string (&db->pass, child);
+               else if (strcasecmp ("Port", child->key) == 0)
+                       status = mysql_config_set_int (&db->port, child);
+               else if (strcasecmp ("Socket", child->key) == 0)
+                       status = mysql_config_set_string (&db->socket, child);
+               /* Check if we're currently handling the `Plugin' block. If so,
+                * handle `Database' _blocks_, too. */
+               else if ((plugin_block != 0)
+                               && (strcasecmp ("Database", child->key) == 0)
+                               && (child->children != NULL))
+               {
+                       /* If `plugin_block > 1', there has been at least one
+                        * `Database' block */
+                       plugin_block++;
+                       status = mysql_config (child);
+               }
+               /* Now handle ordinary `Database' options (without children) */
+               else if ((strcasecmp ("Database", child->key) == 0)
+                               && (child->children == NULL))
+                       status = mysql_config_set_string (&db->database, child);
+               else if (strcasecmp ("MasterStats", child->key) == 0)
+                       status = mysql_config_set_boolean (&db->master_stats, child);
+               else if (strcasecmp ("SlaveStats", child->key) == 0)
+                       status = mysql_config_set_boolean (&db->slave_stats, child);
+               else if (strcasecmp ("SlaveNotifications", child->key) == 0)
+                       status = mysql_config_set_boolean (&db->slave_notif, child);
+               else
+               {
+                       WARNING ("mysql plugin: Option `%s' not allowed here.", child->key);
+                       status = -1;
+               }
+
+               if (status != 0)
+                       break;
        }
 
-       wait_for = wait_increase;
-       wait_increase *= 2;
-       if (wait_increase > 86400)
-               wait_increase = 86400;
+       /* Check if there were any `Database' blocks. */
+       if (plugin_block > 1)
+       {
+               /* There were connection blocks. Don't use any legacy stuff. */
+               if ((db->host != NULL)
+                       || (db->user != NULL)
+                       || (db->pass != NULL)
+                       || (db->database != NULL)
+                       || (db->socket != NULL)
+                       || (db->port != 0))
+               {
+                       WARNING ("mysql plugin: At least one <Database> "
+                                       "block has been found. The legacy "
+                                       "configuration will be ignored.");
+               }
+               mysql_database_free (db);
+               return (0);
+       }
+       else if (plugin_block != 0)
+       {
+               WARNING ("mysql plugin: You're using the legacy "
+                               "configuration options. Please consider "
+                               "updating your configuration!");
+       }
+
+       /* Check that all necessary options have been given. */
+       while (status == 0)
+       {
+               /* Zero is allowed and automatically handled by
+                * `mysql_real_connect'. */
+               if ((db->port < 0) || (db->port > 65535))
+               {
+                       ERROR ("mysql plugin: Database %s: Port number out "
+                                       "of range: %i",
+                                       (db->instance != NULL)
+                                       ? db->instance
+                                       : "<legacy>",
+                                       db->port);
+                       status = -1;
+               }
+               break;
+       } /* while (status == 0) */
+
+       /* If all went well, register this database for reading */
+       if (status == 0)
+       {
+               user_data_t ud;
+               char cb_name[DATA_MAX_NAME_LEN];
 
-       if ((con = mysql_init (con)) == NULL)
+               DEBUG ("mysql plugin: Registering new read callback: %s",
+                               (db->database != NULL) ? db->database : "<default>");
+
+               memset (&ud, 0, sizeof (ud));
+               ud.data = (void *) db;
+               ud.free_func = mysql_database_free;
+
+               if (db->database != NULL)
+                       ssnprintf (cb_name, sizeof (cb_name), "mysql-%s",
+                                       db->database);
+               else
+                       sstrncpy (cb_name, "mysql", sizeof (cb_name));
+
+               plugin_register_complex_read (cb_name, mysql_read,
+                                             /* interval = */ NULL, &ud);
+       }
+       else
+       {
+               mysql_database_free (db);
+               return (-1);
+       }
+
+       return (0);
+} /* }}} int mysql_config */
+
+/* }}} End of configuration handling functions */
+
+static MYSQL *getconnection (mysql_database_t *db)
+{
+       if (db->state != 0)
        {
-               ERROR ("mysql_init failed: %s", mysql_error (con));
-               state = 0;
+               int err;
+               if ((err = mysql_ping (db->con)) != 0)
+               {
+                       WARNING ("mysql_ping failed: %s", mysql_error (db->con));
+                       db->state = 0;
+               }
+               else
+               {
+                       db->state = 1;
+                       return (db->con);
+               }
+       }
+
+       if ((db->con = mysql_init (db->con)) == NULL)
+       {
+               ERROR ("mysql_init failed: %s", mysql_error (db->con));
+               db->state = 0;
                return (NULL);
        }
 
-       if (mysql_real_connect (con, host, user, pass, db, port, socket, 0) == NULL)
+       if (mysql_real_connect (db->con, db->host, db->user, db->pass,
+                               db->database, db->port, db->socket, 0) == NULL)
        {
-               ERROR ("mysql_real_connect failed: %s", mysql_error (con));
-               state = 0;
+               ERROR ("mysql plugin: Failed to connect to database %s "
+                               "at server %s: %s",
+                               (db->database != NULL) ? db->database : "<none>",
+                               (db->host != NULL) ? db->host : "localhost",
+                               mysql_error (db->con));
+               db->state = 0;
                return (NULL);
        }
        else
        {
-               state = 1;
-               wait_for = 0;
-               wait_increase = 60;
-               return (con);
+               INFO ("mysql plugin: Sucessfully connected to database %s "
+                               "at server %s (server version: %s, protocol version: %d)",
+                               (db->database != NULL) ? db->database : "<none>",
+                               mysql_get_host_info (db->con),
+                               mysql_get_server_info (db->con),
+                               mysql_get_proto_info (db->con));
+               db->state = 1;
+               return (db->con);
        }
-} /* static MYSQL *getconnection (void) */
+} /* static MYSQL *getconnection (mysql_database_t *db) */
 
-static int config (const char *key, const char *value)
+static void set_host (mysql_database_t *db, char *buf, size_t buflen)
 {
-       if (strcasecmp (key, "host") == 0)
-               return ((host = strdup (value)) == NULL ? 1 : 0);
-       else if (strcasecmp (key, "user") == 0)
-               return ((user = strdup (value)) == NULL ? 1 : 0);
-       else if (strcasecmp (key, "password") == 0)
-               return ((pass = strdup (value)) == NULL ? 1 : 0);
-       else if (strcasecmp (key, "database") == 0)
-               return ((db = strdup (value)) == NULL ? 1 : 0);
-       else if (strcasecmp (key, "socket") == 0)
-               return ((socket = strdup (value)) == NULL ? 1 : 0);
-       else if (strcasecmp (key, "port") == 0)
+       /* XXX legacy mode - use hostname_g */
+       if (db->instance == NULL)
+               sstrncpy (buf, hostname_g, buflen);
+       else
        {
-           char *endptr = NULL;
-           int temp;
-
-           errno = 0;
-           temp = strtol (value, &endptr, 0);
-           if ((errno != 0) || (value == endptr))
-           {
-               ERROR ("mysql plugin: Invalid \"Port\" argument: %s",
-                       value);
-               port = 0;
-               return (1);
-           }
-           else if ((temp < 0) || (temp >= 65535))
-           {
-               ERROR ("mysql plugin: Port number out of range: %i",
-                       temp);
-               port = 0;
-               return (1);
-           }
-
-           port = temp;
-           return (0);
+               if ((db->host == NULL)
+                               || (strcmp ("", db->host) == 0)
+                               || (strcmp ("localhost", db->host) == 0))
+                       sstrncpy (buf, hostname_g, buflen);
+               else
+                       sstrncpy (buf, db->host, buflen);
        }
+}
+
+static void set_plugin_instance (mysql_database_t *db,
+               char *buf, size_t buflen)
+{
+       /* XXX legacy mode - no plugin_instance */
+       if (db->instance == NULL)
+               sstrncpy (buf, "", buflen);
        else
-               return (-1);
-} /* int config */
+               sstrncpy (buf, db->instance, buflen);
+}
 
-static void counter_submit (const char *type, const char *type_instance,
-               counter_t value)
+static void submit (const char *type, const char *type_instance,
+               value_t *values, size_t values_len, mysql_database_t *db)
 {
-       value_t values[1];
        value_list_t vl = VALUE_LIST_INIT;
 
-       values[0].counter = value;
+       vl.values     = values;
+       vl.values_len = values_len;
+
+       set_host (db, vl.host, sizeof (vl.host));
 
-       vl.values = values;
-       vl.values_len = 1;
-       sstrncpy (vl.host, hostname_g, sizeof (vl.host));
        sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
+       set_plugin_instance (db, vl.plugin_instance, sizeof (vl.plugin_instance));
+
        sstrncpy (vl.type, type, sizeof (vl.type));
-       sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
+       if (type_instance != NULL)
+               sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 
        plugin_dispatch_values (&vl);
+} /* submit */
+
+static void counter_submit (const char *type, const char *type_instance,
+               counter_t value, mysql_database_t *db)
+{
+       value_t values[1];
+
+       values[0].counter = value;
+       submit (type, type_instance, values, STATIC_ARRAY_SIZE (values), db);
 } /* void counter_submit */
 
+static void gauge_submit (const char *type, const char *type_instance,
+               gauge_t value, mysql_database_t *db)
+{
+       value_t values[1];
+
+       values[0].gauge = value;
+       submit (type, type_instance, values, STATIC_ARRAY_SIZE (values), db);
+} /* void gauge_submit */
+
 static void qcache_submit (counter_t hits, counter_t inserts,
                counter_t not_cached, counter_t lowmem_prunes,
-               gauge_t queries_in_cache)
+               gauge_t queries_in_cache, mysql_database_t *db)
 {
        value_t values[5];
-       value_list_t vl = VALUE_LIST_INIT;
 
        values[0].counter = hits;
        values[1].counter = inserts;
@@ -179,59 +477,228 @@ static void qcache_submit (counter_t hits, counter_t inserts,
        values[3].counter = lowmem_prunes;
        values[4].gauge   = queries_in_cache;
 
-       vl.values = values;
-       vl.values_len = 5;
-       sstrncpy (vl.host, hostname_g, sizeof (vl.host));
-       sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
-       sstrncpy (vl.type, "mysql_qcache", sizeof (vl.type));
-
-       plugin_dispatch_values (&vl);
+       submit ("mysql_qcache", NULL, values, STATIC_ARRAY_SIZE (values), db);
 } /* void qcache_submit */
 
 static void threads_submit (gauge_t running, gauge_t connected, gauge_t cached,
-               counter_t created)
+               counter_t created, mysql_database_t *db)
 {
        value_t values[4];
-       value_list_t vl = VALUE_LIST_INIT;
 
        values[0].gauge   = running;
        values[1].gauge   = connected;
        values[2].gauge   = cached;
        values[3].counter = created;
 
-       vl.values = values;
-       vl.values_len = 4;
-       sstrncpy (vl.host, hostname_g, sizeof (vl.host));
-       sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
-       sstrncpy (vl.type, "mysql_threads", sizeof (vl.type));
-
-       plugin_dispatch_values (&vl);
+       submit ("mysql_threads", NULL, values, STATIC_ARRAY_SIZE (values), db);
 } /* void threads_submit */
 
-static void traffic_submit (counter_t rx, counter_t tx)
+static void traffic_submit (counter_t rx, counter_t tx, mysql_database_t *db)
 {
        value_t values[2];
-       value_list_t vl = VALUE_LIST_INIT;
 
        values[0].counter = rx;
        values[1].counter = tx;
 
-       vl.values = values;
-       vl.values_len = 2;
-       sstrncpy (vl.host, hostname_g, sizeof (vl.host));
-       sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
-       sstrncpy (vl.type, "mysql_octets", sizeof (vl.type));
-
-       plugin_dispatch_values (&vl);
+       submit ("mysql_octets", NULL, values, STATIC_ARRAY_SIZE (values), db);
 } /* void traffic_submit */
 
-static int mysql_read (void)
+static MYSQL_RES *exec_query (MYSQL *con, const char *query)
+{
+       MYSQL_RES *res;
+
+       int query_len = strlen (query);
+
+       if (mysql_real_query (con, query, query_len))
+       {
+               ERROR ("mysql plugin: Failed to execute query: %s",
+                               mysql_error (con));
+               INFO ("mysql plugin: SQL query was: %s", query);
+               return (NULL);
+       }
+
+       res = mysql_store_result (con);
+       if (res == NULL)
+       {
+               ERROR ("mysql plugin: Failed to store query result: %s",
+                               mysql_error (con));
+               INFO ("mysql plugin: SQL query was: %s", query);
+               return (NULL);
+       }
+
+       return (res);
+} /* exec_query */
+
+static int mysql_read_master_stats (mysql_database_t *db, MYSQL *con)
 {
+       MYSQL_RES *res;
+       MYSQL_ROW  row;
+
+       char *query;
+       int   field_num;
+       unsigned long long position;
+
+       query = "SHOW MASTER STATUS";
+
+       res = exec_query (con, query);
+       if (res == NULL)
+               return (-1);
+
+       row = mysql_fetch_row (res);
+       if (row == NULL)
+       {
+               ERROR ("mysql plugin: Failed to get master statistics: "
+                               "`%s' did not return any rows.", query);
+               return (-1);
+       }
+
+       field_num = mysql_num_fields (res);
+       if (field_num < 2)
+       {
+               ERROR ("mysql plugin: Failed to get master statistics: "
+                               "`%s' returned less than two columns.", query);
+               return (-1);
+       }
+
+       position = atoll (row[1]);
+       counter_submit ("mysql_log_position", "master-bin", position, db);
+
+       row = mysql_fetch_row (res);
+       if (row != NULL)
+               WARNING ("mysql plugin: `%s' returned more than one row - "
+                               "ignoring further results.", query);
+
+       mysql_free_result (res);
+
+       return (0);
+} /* mysql_read_master_stats */
+
+static int mysql_read_slave_stats (mysql_database_t *db, MYSQL *con)
+{
+       MYSQL_RES *res;
+       MYSQL_ROW  row;
+
+       char *query;
+       int   field_num;
+
+       /* WTF? libmysqlclient does not seem to provide any means to
+        * translate a column name to a column index ... :-/ */
+       const int READ_MASTER_LOG_POS_IDX   = 6;
+       const int SLAVE_IO_RUNNING_IDX      = 10;
+       const int SLAVE_SQL_RUNNING_IDX     = 11;
+       const int EXEC_MASTER_LOG_POS_IDX   = 21;
+       const int SECONDS_BEHIND_MASTER_IDX = 32;
+
+       query = "SHOW SLAVE STATUS";
+
+       res = exec_query (con, query);
+       if (res == NULL)
+               return (-1);
+
+       row = mysql_fetch_row (res);
+       if (row == NULL)
+       {
+               ERROR ("mysql plugin: Failed to get slave statistics: "
+                               "`%s' did not return any rows.", query);
+               return (-1);
+       }
+
+       field_num = mysql_num_fields (res);
+       if (field_num < 33)
+       {
+               ERROR ("mysql plugin: Failed to get slave statistics: "
+                               "`%s' returned less than 33 columns.", query);
+               return (-1);
+       }
+
+       if (db->slave_stats)
+       {
+               unsigned long long counter;
+               double gauge;
+
+               counter = atoll (row[READ_MASTER_LOG_POS_IDX]);
+               counter_submit ("mysql_log_position", "slave-read", counter, db);
+
+               counter = atoll (row[EXEC_MASTER_LOG_POS_IDX]);
+               counter_submit ("mysql_log_position", "slave-exec", counter, db);
+
+               if (row[SECONDS_BEHIND_MASTER_IDX] != NULL)
+               {
+                       gauge = atof (row[SECONDS_BEHIND_MASTER_IDX]);
+                       gauge_submit ("time_offset", NULL, gauge, db);
+               }
+       }
+
+       if (db->slave_notif)
+       {
+               notification_t n = { 0, time (NULL), "", "",
+                       "mysql", "", "time_offset", "", NULL };
+
+               char *io, *sql;
+
+               io  = row[SLAVE_IO_RUNNING_IDX];
+               sql = row[SLAVE_SQL_RUNNING_IDX];
+
+               set_host (db, n.host, sizeof (n.host));
+               set_plugin_instance (db,
+                               n.plugin_instance, sizeof (n.plugin_instance));
+
+               if (((io == NULL) || (strcasecmp (io, "yes") != 0))
+                               && (db->slave_io_running))
+               {
+                       n.severity = NOTIF_WARNING;
+                       ssnprintf (n.message, sizeof (n.message),
+                                       "slave I/O thread not started or not connected to master");
+                       plugin_dispatch_notification (&n);
+                       db->slave_io_running = 0;
+               }
+               else if (((io != NULL) && (strcasecmp (io, "yes") == 0))
+                               && (! db->slave_io_running))
+               {
+                       n.severity = NOTIF_OKAY;
+                       ssnprintf (n.message, sizeof (n.message),
+                                       "slave I/O thread started and connected to master");
+                       plugin_dispatch_notification (&n);
+                       db->slave_io_running = 1;
+               }
+
+               if (((sql == NULL) || (strcasecmp (sql, "yes") != 0))
+                               && (db->slave_sql_running))
+               {
+                       n.severity = NOTIF_WARNING;
+                       ssnprintf (n.message, sizeof (n.message),
+                                       "slave SQL thread not started");
+                       plugin_dispatch_notification (&n);
+                       db->slave_sql_running = 0;
+               }
+               else if (((sql != NULL) && (strcasecmp (sql, "yes") == 0))
+                               && (! db->slave_sql_running))
+               {
+                       n.severity = NOTIF_OKAY;
+                       ssnprintf (n.message, sizeof (n.message),
+                                       "slave SQL thread started");
+                       plugin_dispatch_notification (&n);
+                       db->slave_sql_running = 0;
+               }
+       }
+
+       row = mysql_fetch_row (res);
+       if (row != NULL)
+               WARNING ("mysql plugin: `%s' returned more than one row - "
+                               "ignoring further results.", query);
+
+       mysql_free_result (res);
+
+       return (0);
+} /* mysql_read_slave_stats */
+
+static int mysql_read (user_data_t *ud)
+{
+       mysql_database_t *db;
        MYSQL     *con;
        MYSQL_RES *res;
        MYSQL_ROW  row;
        char      *query;
-       int        query_len;
        int        field_num;
 
        unsigned long long qcache_hits          = 0ULL;
@@ -248,29 +715,25 @@ static int mysql_read (void)
        unsigned long long traffic_incoming = 0ULL;
        unsigned long long traffic_outgoing = 0ULL;
 
+       if ((ud == NULL) || (ud->data == NULL))
+       {
+               ERROR ("mysql plugin: mysql_database_read: Invalid user data.");
+               return (-1);
+       }
+
+       db = (mysql_database_t *) ud->data;
+
        /* An error message will have been printed in this case */
-       if ((con = getconnection ()) == NULL)
+       if ((con = getconnection (db)) == NULL)
                return (-1);
 
        query = "SHOW STATUS";
        if (mysql_get_server_version (con) >= 50002)
                query = "SHOW GLOBAL STATUS";
 
-       query_len = strlen (query);
-
-       if (mysql_real_query (con, query, query_len))
-       {
-               ERROR ("mysql_real_query failed: %s\n",
-                               mysql_error (con));
-               return (-1);
-       }
-
-       if ((res = mysql_store_result (con)) == NULL)
-       {
-               ERROR ("mysql_store_result failed: %s\n",
-                               mysql_error (con));
+       res = exec_query (con, query);
+       if (res == NULL)
                return (-1);
-       }
 
        field_num = mysql_num_fields (res);
        while ((row = mysql_fetch_row (res)))
@@ -288,14 +751,14 @@ static int mysql_read (void)
 
                        /* Ignore `prepared statements' */
                        if (strncmp (key, "Com_stmt_", 9) != 0)
-                               counter_submit ("mysql_commands", key + 4, val);
+                               counter_submit ("mysql_commands", key + 4, val, db);
                }
                else if (strncmp (key, "Handler_", 8) == 0)
                {
                        if (val == 0ULL)
                                continue;
 
-                       counter_submit ("mysql_handler", key + 8, val);
+                       counter_submit ("mysql_handler", key + 8, val, db);
                }
                else if (strncmp (key, "Qcache_", 7) == 0)
                {
@@ -336,21 +799,24 @@ static int mysql_read (void)
                        || (qcache_not_cached != 0ULL)
                        || (qcache_lowmem_prunes != 0ULL))
                qcache_submit (qcache_hits, qcache_inserts, qcache_not_cached,
-                               qcache_lowmem_prunes, qcache_queries_in_cache);
+                              qcache_lowmem_prunes, qcache_queries_in_cache, db);
 
        if (threads_created != 0ULL)
                threads_submit (threads_running, threads_connected,
-                               threads_cached, threads_created);
+                               threads_cached, threads_created, db);
+
+       traffic_submit  (traffic_incoming, traffic_outgoing, db);
 
-       traffic_submit  (traffic_incoming, traffic_outgoing);
+       if (db->master_stats)
+               mysql_read_master_stats (db, con);
 
-       /* mysql_close (con); */
+       if ((db->slave_stats) || (db->slave_notif))
+               mysql_read_slave_stats (db, con);
 
        return (0);
 } /* int mysql_read */
 
 void module_register (void)
 {
-       plugin_register_config ("mysql", config, config_keys, config_keys_num);
-       plugin_register_read ("mysql", mysql_read);
+       plugin_register_complex_config ("mysql", mysql_config);
 } /* void module_register */
index 902f270..51b9922 100644 (file)
@@ -1,6 +1,6 @@
 /**
  * collectd - src/network.c
- * Copyright (C) 2005-2008  Florian octo Forster
+ * Copyright (C) 2005-2009  Florian octo Forster
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
 # include <poll.h>
 #endif
 
+#if HAVE_GCRYPT_H
+# include <gcrypt.h>
+#endif
+
 /* 1500 - 40 - 8  =  Ethernet packet - IPv6 header - UDP header */
 /* #define BUFF_SIZE 1452 */
 
 # endif
 #endif /* !IP_ADD_MEMBERSHIP */
 
+/* Buffer size to allocate. */
 #define BUFF_SIZE 1024
 
 /*
+ * Maximum size required for encryption / signing:
+ * Type/length:       4
+ * Hash/orig length: 32
+ * Padding (up to):  16
+ * --------------------
+ *                   52
+ */
+#define BUFF_SIG_SIZE 52
+
+/*
  * Private data types
  */
 typedef struct sockent
@@ -67,6 +82,16 @@ typedef struct sockent
        int                      fd;
        struct sockaddr_storage *addr;
        socklen_t                addrlen;
+
+#define SECURITY_LEVEL_NONE     0
+#if HAVE_GCRYPT_H
+# define SECURITY_LEVEL_SIGN    1
+# define SECURITY_LEVEL_ENCRYPT 2
+       int security_level;
+       char *shared_secret;
+       gcry_cipher_hd_t cypher;
+#endif /* HAVE_GCRYPT_H */
+
        struct sockent          *next;
 } sockent_t;
 
@@ -136,10 +161,27 @@ struct part_values_s
 };
 typedef struct part_values_s part_values_t;
 
+struct part_signature_sha256_s
+{
+  part_header_t head;
+  char hash[32];
+};
+typedef struct part_signature_sha256_s part_signature_sha256_t;
+
+struct part_encryption_aes256_s
+{
+  part_header_t head;
+  uint16_t orig_length;
+  uint16_t random;
+  char hash[28];
+};
+typedef struct part_encryption_aes256_s part_encryption_aes256_t;
+
 struct receive_list_entry_s
 {
   char data[BUFF_SIZE];
   int  data_len;
+  int  fd;
   struct receive_list_entry_s *next;
 };
 typedef struct receive_list_entry_s receive_list_entry_t;
@@ -147,16 +189,6 @@ typedef struct receive_list_entry_s receive_list_entry_t;
 /*
  * Private variables
  */
-static const char *config_keys[] =
-{
-       "CacheFlush",
-       "Listen",
-       "Server",
-       "TimeToLive",
-       "Forward"
-};
-static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
-
 static int network_config_ttl = 0;
 static int network_config_forward = 0;
 
@@ -167,20 +199,29 @@ static receive_list_entry_t *receive_list_tail = NULL;
 static pthread_mutex_t       receive_list_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t        receive_list_cond = PTHREAD_COND_INITIALIZER;
 
-static struct pollfd *listen_sockets = NULL;
-static int listen_sockets_num = 0;
-
-static int listen_loop = 0;
-static pthread_t receive_thread_id = 0;
-static pthread_t dispatch_thread_id = 0;
-
-static char         send_buffer[BUFF_SIZE];
-static char        *send_buffer_ptr;
-static int          send_buffer_fill;
-static value_list_t send_buffer_vl = VALUE_LIST_STATIC;
-static pthread_mutex_t send_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
-
-static c_avl_tree_t      *cache_tree = NULL;
+static sockent_t     *listen_sockets = NULL;
+static struct pollfd *listen_sockets_pollfd = NULL;
+static int            listen_sockets_num = 0;
+
+/* The receive and dispatch threads will run as long as `listen_loop' is set to
+ * zero. */
+static int       listen_loop = 0;
+static int       receive_thread_running = 0;
+static pthread_t receive_thread_id;
+static int       dispatch_thread_running = 0;
+static pthread_t dispatch_thread_id;
+
+/* Buffer in which to-be-sent network packets are constructed. */
+static char             send_buffer[BUFF_SIZE];
+static char            *send_buffer_ptr;
+static int              send_buffer_fill;
+static value_list_t     send_buffer_vl = VALUE_LIST_STATIC;
+static pthread_mutex_t  send_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/* In this cache we store all the values we received, so we can send out only
+ * those values which were *not* received via the network plugin, too. This is
+ * used for the `Forward false' option. */
+static c_avl_tree_t    *cache_tree = NULL;
 static pthread_mutex_t  cache_lock = PTHREAD_MUTEX_INITIALIZER;
 static time_t           cache_flush_last = 0;
 static int              cache_flush_interval = 1800;
@@ -296,9 +337,6 @@ static int cache_check (const value_list_t *vl)
 
        pthread_mutex_unlock (&cache_lock);
 
-       DEBUG ("network plugin: cache_check: key = %s; time = %i; retval = %i",
-                       key, (int) vl->time, retval);
-
        return (retval);
 } /* int cache_check */
 
@@ -673,15 +711,161 @@ static int parse_part_string (void **ret_buffer, int *ret_buffer_len,
        return (0);
 } /* int parse_part_string */
 
-static int parse_packet (void *buffer, int buffer_len)
+#if HAVE_GCRYPT_H
+static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
+    void **ret_buffer, int *ret_buffer_len)
+{
+  char *buffer = *ret_buffer;
+  size_t buffer_len = (size_t) *ret_buffer_len;
+
+  part_signature_sha256_t ps_received;
+  part_signature_sha256_t ps_expected;
+
+  if (se->shared_secret == NULL)
+  {
+    NOTICE ("network plugin: Received signed network packet but can't verify "
+        "it because no shared secret has been configured. Will accept it.");
+    return (0);
+  }
+
+  if (buffer_len < sizeof (ps_received))
+    return (-ENOMEM);
+
+  memcpy (&ps_received, buffer, sizeof (ps_received));
+
+  memset (&ps_expected, 0, sizeof (ps_expected));
+  ps_expected.head.type = htons (TYPE_SIGN_SHA256);
+  ps_expected.head.length = htons (sizeof (ps_expected));
+  sstrncpy (ps_expected.hash, se->shared_secret, sizeof (ps_expected.hash));
+  memcpy (buffer, &ps_expected, sizeof (ps_expected));
+
+  gcry_md_hash_buffer (GCRY_MD_SHA256, ps_expected.hash, buffer, buffer_len);
+
+  *ret_buffer += sizeof (ps_received);
+
+  if (memcmp (ps_received.hash, ps_expected.hash,
+        sizeof (ps_received.hash)) == 0)
+    return (0);
+  else /* hashes do not match. */
+    return (1);
+} /* }}} int parse_part_sign_sha256 */
+/* #endif HAVE_GCRYPT_H */
+
+#else /* if !HAVE_GCRYPT_H */
+static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
+    void **ret_buffer, int *ret_buffer_len)
+{
+  INFO ("network plugin: Received signed packet, but the network "
+      "plugin was not linked with libgcrypt, so I cannot "
+      "verify the signature. The packet will be accepted.");
+  return (0);
+} /* }}} int parse_part_sign_sha256 */
+#endif /* !HAVE_GCRYPT_H */
+
+#if HAVE_GCRYPT_H
+static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
+               void **ret_buffer, int *ret_buffer_len)
+{
+  char *buffer = *ret_buffer;
+  int   buffer_len = *ret_buffer_len;
+  int   orig_buffer_len;
+  part_encryption_aes256_t pea;
+  char hash[28];
+  gcry_error_t err;
+
+  if (se->cypher == NULL)
+  {
+    NOTICE ("network plugin: Unable to decrypt packet, because no cypher "
+        "instance is present.");
+    return (-1);
+  }
+
+  /* Decrypt the packet in-place */
+  err = gcry_cipher_decrypt (se->cypher,
+      buffer + sizeof (pea.head), buffer_len - sizeof (pea.head),
+      /* in = */ NULL, /* in len = */ 0);
+  gcry_cipher_reset (se->cypher);
+  if (err != 0)
+  {
+    ERROR ("network plugin: gcry_cipher_decrypt returned: %s",
+        gcry_strerror (err));
+    return (-1);
+  }
+
+  /* Copy the header information to `pea' */
+  memcpy (&pea, buffer, sizeof (pea));
+  buffer += sizeof (pea);
+  buffer_len -= sizeof (pea);
+
+  /* Check sanity of the original length */
+  orig_buffer_len = ntohs (pea.orig_length);
+  if (orig_buffer_len > buffer_len)
+  {
+    ERROR ("network plugin: Decryption failed: Invalid original length.");
+    return (-1);
+  }
+
+  /* Check hash sum */
+  memset (hash, 0, sizeof (hash));
+  gcry_md_hash_buffer (GCRY_MD_SHA224, hash, buffer, orig_buffer_len);
+  
+  if (memcmp (hash, pea.hash, sizeof (hash)) != 0)
+  {
+    ERROR ("network plugin: Decryption failed: Checksum mismatch.");
+    return (-1);
+  }
+
+  /* Update return values */
+  *ret_buffer = buffer;
+  *ret_buffer_len = orig_buffer_len;
+
+  return (0);
+} /* }}} int parse_part_encr_aes256 */
+/* #endif HAVE_GCRYPT_H */
+
+#else /* if !HAVE_GCRYPT_H */
+static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
+    void **ret_buffer, int *ret_buffer_len)
+{
+  INFO ("network plugin: Received encrypted packet, but the network "
+      "plugin was not linked with libgcrypt, so I cannot "
+      "decrypt it. The packet will be discarded.");
+  return (-1);
+} /* }}} int parse_part_encr_aes256 */
+#endif /* !HAVE_GCRYPT_H */
+
+static int parse_packet (receive_list_entry_t *rle) /* {{{ */
 {
        int status;
 
+       void *buffer;
+       int buffer_len;
+       sockent_t *se;
+
        value_list_t vl = VALUE_LIST_INIT;
        notification_t n;
 
-       DEBUG ("network plugin: parse_packet: buffer = %p; buffer_len = %i;",
-                       buffer, buffer_len);
+       int packet_was_encrypted = 0;
+       int packet_was_signed = 0;
+#if HAVE_GCRYPT_H
+       int printed_ignore_warning = 0;
+#endif /* HAVE_GCRYPT_H */
+
+       buffer = rle->data;
+       buffer_len = rle->data_len;
+
+       /* Look for the correct `sockent_t' */
+       se = listen_sockets;
+       while ((se != NULL) && (se->fd != rle->fd))
+               se = se->next;
+
+       if (se == NULL)
+       {
+               ERROR ("network plugin: Got packet from FD %i, but can't "
+                               "find an appropriate socket entry.",
+                               rle->fd);
+               return (-1);
+       }
 
        memset (&vl, '\0', sizeof (vl));
        memset (&n, '\0', sizeof (n));
@@ -709,7 +893,72 @@ static int parse_packet (void *buffer, int buffer_len)
                if (pkg_length < (2 * sizeof (uint16_t)))
                        break;
 
-               if (pkg_type == TYPE_VALUES)
+               if (pkg_type == TYPE_ENCR_AES256)
+               {
+                       status = parse_part_encr_aes256 (se, &buffer, &buffer_len);
+                       if (status != 0)
+                       {
+                               ERROR ("network plugin: Decrypting AES256 "
+                                               "part failed "
+                                               "with status %i.", status);
+                               break;
+                       }
+                       else
+                       {
+                               packet_was_encrypted = 1;
+                       }
+               }
+#if HAVE_GCRYPT_H
+               else if ((se->security_level == SECURITY_LEVEL_ENCRYPT)
+                               && (packet_was_encrypted == 0))
+               {
+                       if (printed_ignore_warning == 0)
+                       {
+                               INFO ("network plugin: Unencrypted packet or "
+                                               "part has been ignored.");
+                               printed_ignore_warning = 1;
+                       }
+                       buffer = ((char *) buffer) + pkg_length;
+                       continue;
+               }
+#endif /* HAVE_GCRYPT_H */
+               else if (pkg_type == TYPE_SIGN_SHA256)
+               {
+                       status = parse_part_sign_sha256 (se, &buffer, &buffer_len);
+                       if (status < 0)
+                       {
+                               ERROR ("network plugin: Verifying SHA-256 "
+                                               "signature failed "
+                                               "with status %i.", status);
+                               break;
+                       }
+                       else if (status > 0)
+                       {
+                               ERROR ("network plugin: Ignoring packet with "
+                                               "invalid SHA-256 signature.");
+                               break;
+                       }
+                       else
+                       {
+                               packet_was_signed = 1;
+                       }
+               }
+#if HAVE_GCRYPT_H
+               else if ((se->security_level == SECURITY_LEVEL_SIGN)
+                               && (packet_was_encrypted == 0)
+                               && (packet_was_signed == 0))
+               {
+                       if (printed_ignore_warning == 0)
+                       {
+                               INFO ("network plugin: Unsigned packet or "
+                                               "part has been ignored.");
+                               printed_ignore_warning = 1;
+                       }
+                       buffer = ((char *) buffer) + pkg_length;
+                       continue;
+               }
+#endif /* HAVE_GCRYPT_H */
+               else if (pkg_type == TYPE_VALUES)
                {
                        status = parse_part_values (&buffer, &buffer_len,
                                        &vl.values, &vl.values_len);
@@ -845,19 +1094,30 @@ static int parse_packet (void *buffer, int buffer_len)
        } /* while (buffer_len > sizeof (part_header_t)) */
 
        return (status);
-} /* int parse_packet */
+} /* }}} int parse_packet */
 
-static void free_sockent (sockent_t *se)
+static void free_sockent (sockent_t *se) /* {{{ */
 {
        sockent_t *next;
        while (se != NULL)
        {
                next = se->next;
+
+#if HAVE_GCRYPT_H
+               if (se->cypher != NULL)
+               {
+                       gcry_cipher_close (se->cypher);
+                       se->cypher = NULL;
+               }
+               free (se->shared_secret);
+#endif /* HAVE_GCRYPT_H */
+
                free (se->addr);
                free (se);
+
                se = next;
        }
-} /* void free_sockent */
+} /* }}} void free_sockent */
 
 /*
  * int network_set_ttl
@@ -922,6 +1182,50 @@ static int network_set_ttl (const sockent_t *se, const struct addrinfo *ai)
        return (0);
 } /* int network_set_ttl */
 
+#if HAVE_GCRYPT_H
+static int network_set_encryption (sockent_t *se, /* {{{ */
+               const char *shared_secret)
+{
+  char hash[32];
+  gcry_error_t err;
+
+  se->shared_secret = sstrdup (shared_secret);
+
+  /*
+   * We use CBC *without* an initialization vector: The cipher is reset after
+   * each packet and we would have to re-set the IV each time. The first
+   * encrypted block will contain the SHA-224 checksum anyway, so this should
+   * be quite unpredictable. Also, there's a 2 byte field in the header that's
+   * being filled with random numbers. So we only use CBC so the blocks
+   * *within* one packet are chained.
+   */
+  err = gcry_cipher_open (&se->cypher,
+      GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC, /* flags = */ 0);
+  if (err != 0)
+  {
+    ERROR ("network plugin: gcry_cipher_open returned: %s",
+        gcry_strerror (err));
+    return (-1);
+  }
+
+  assert (se->shared_secret != NULL);
+  gcry_md_hash_buffer (GCRY_MD_SHA256, hash,
+      se->shared_secret, strlen (se->shared_secret));
+
+  err = gcry_cipher_setkey (se->cypher, hash, sizeof (hash));
+  if (err != 0)
+  {
+    DEBUG ("network plugin: gcry_cipher_setkey returned: %s",
+        gcry_strerror (err));
+    gcry_cipher_close (se->cypher);
+    se->cypher = NULL;
+    return (-1);
+  }
+
+  return (0);
+} /* }}} int network_set_encryption */
+#endif /* HAVE_GCRYPT_H */
+
 static int network_bind_socket (const sockent_t *se, const struct addrinfo *ai)
 {
        int loop = 0;
@@ -1029,9 +1333,12 @@ static int network_bind_socket (const sockent_t *se, const struct addrinfo *ai)
        return (0);
 } /* int network_bind_socket */
 
-static sockent_t *network_create_socket (const char *node,
+#define CREATE_SOCKET_FLAGS_LISTEN    0x0001
+static sockent_t *network_create_socket (const char *node, /* {{{ */
                const char *service,
-               int listen)
+               const char *shared_secret,
+                int security_level,
+               int flags)
 {
        struct addrinfo  ai_hints;
        struct addrinfo *ai_list, *ai_ptr;
@@ -1070,6 +1377,7 @@ static sockent_t *network_create_socket (const char *node,
        for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
        {
                sockent_t *se;
+               int status;
 
                if ((se = (sockent_t *) malloc (sizeof (sockent_t))) == NULL)
                {
@@ -1111,9 +1419,10 @@ static sockent_t *network_create_socket (const char *node,
                        continue;
                }
 
-               if (listen != 0)
+               if ((flags & CREATE_SOCKET_FLAGS_LISTEN) != 0)
                {
-                       if (network_bind_socket (se, ai_ptr) != 0)
+                       status = network_bind_socket (se, ai_ptr);
+                       if (status != 0)
                        {
                                close (se->fd);
                                free (se->addr);
@@ -1121,11 +1430,45 @@ static sockent_t *network_create_socket (const char *node,
                                continue;
                        }
                }
-               else /* listen == 0 */
+               else /* sending socket */
                {
                        network_set_ttl (se, ai_ptr);
                }
 
+#if HAVE_GCRYPT_H
+               se->security_level = security_level;
+               se->shared_secret = NULL;
+               se->cypher = NULL;
+               if (shared_secret != NULL)
+               {
+                       status = network_set_encryption (se, shared_secret);
+                       if ((status != 0) && (security_level <= SECURITY_LEVEL_SIGN))
+                       {
+                               WARNING ("network plugin: Starting cryptograp"
+                                               "hic subsystem failed. Since "
+                                               "security level `Sign' or "
+                                               "`None' is configured I will "
+                                               "continue.");
+                       }
+                       else if (status != 0)
+                       {
+                               ERROR ("network plugin: Starting cryptograp"
+                                               "hic subsystem failed. "
+                                               "Because the security level "
+                                               "is set to `Encrypt' I will "
+                                               "not continue!");
+                               close (se->fd);
+                               free (se->addr);
+                               free (se);
+                               continue;
+                       }
+               } /* if (shared_secret != NULL) */
+#else
+               /* Make compiler happy */
+               security_level = 0;
+               shared_secret = NULL;
+#endif /* HAVE_GCRYPT_H */
+
                if (se_tail == NULL)
                {
                        se_head = se;
@@ -1138,26 +1481,27 @@ static sockent_t *network_create_socket (const char *node,
                }
 
                /* We don't open more than one write-socket per node/service pair.. */
-               if (listen == 0)
+               if ((flags & CREATE_SOCKET_FLAGS_LISTEN) == 0)
                        break;
        }
 
        freeaddrinfo (ai_list);
 
        return (se_head);
-} /* sockent_t *network_create_socket */
+} /* }}} sockent_t *network_create_socket */
 
-static sockent_t *network_create_default_socket (int listen)
+static sockent_t *network_create_default_socket (int flags) /* {{{ */
 {
        sockent_t *se_ptr  = NULL;
        sockent_t *se_head = NULL;
        sockent_t *se_tail = NULL;
 
-       se_ptr = network_create_socket (NET_DEFAULT_V6_ADDR,
-                       NET_DEFAULT_PORT, listen);
+       se_ptr = network_create_socket (NET_DEFAULT_V6_ADDR, NET_DEFAULT_PORT,
+                       /* shared secret = */ NULL, SECURITY_LEVEL_NONE,
+                        flags);
 
        /* Don't send to the same machine in IPv6 and IPv4 if both are available. */
-       if ((listen == 0) && (se_ptr != NULL))
+       if (((flags & CREATE_SOCKET_FLAGS_LISTEN) == 0) && (se_ptr != NULL))
                return (se_ptr);
 
        if (se_ptr != NULL)
@@ -1168,28 +1512,36 @@ static sockent_t *network_create_default_socket (int listen)
                        se_tail = se_tail->next;
        }
 
-       se_ptr = network_create_socket (NET_DEFAULT_V4_ADDR, NET_DEFAULT_PORT, listen);
+       se_ptr = network_create_socket (NET_DEFAULT_V4_ADDR, NET_DEFAULT_PORT,
+                       /* shared secret = */ NULL, SECURITY_LEVEL_NONE,
+                        flags);
 
        if (se_tail == NULL)
                return (se_ptr);
 
        se_tail->next = se_ptr;
        return (se_head);
-} /* sockent_t *network_create_default_socket */
+} /* }}} sockent_t *network_create_default_socket */
 
-static int network_add_listen_socket (const char *node, const char *service)
+static int network_add_listen_socket (const char *node, /* {{{ */
+    const char *service, const char *shared_secret, int security_level)
 {
        sockent_t *se;
        sockent_t *se_ptr;
        int se_num = 0;
 
+        int flags;
+
+        flags = CREATE_SOCKET_FLAGS_LISTEN;
+
        if (service == NULL)
                service = NET_DEFAULT_PORT;
 
        if (node == NULL)
-               se = network_create_default_socket (1 /* listen == true */);
+               se = network_create_default_socket (flags);
        else
-               se = network_create_socket (node, service, 1 /* listen == true */);
+               se = network_create_socket (node, service,
+                    shared_secret, security_level, flags);
 
        if (se == NULL)
                return (-1);
@@ -1197,23 +1549,32 @@ static int network_add_listen_socket (const char *node, const char *service)
        for (se_ptr = se; se_ptr != NULL; se_ptr = se_ptr->next)
                se_num++;
 
-       listen_sockets = (struct pollfd *) realloc (listen_sockets,
+       listen_sockets_pollfd = realloc (listen_sockets_pollfd,
                        (listen_sockets_num + se_num)
                        * sizeof (struct pollfd));
 
        for (se_ptr = se; se_ptr != NULL; se_ptr = se_ptr->next)
        {
-               listen_sockets[listen_sockets_num].fd = se_ptr->fd;
-               listen_sockets[listen_sockets_num].events = POLLIN | POLLPRI;
-               listen_sockets[listen_sockets_num].revents = 0;
+               listen_sockets_pollfd[listen_sockets_num].fd = se_ptr->fd;
+               listen_sockets_pollfd[listen_sockets_num].events = POLLIN | POLLPRI;
+               listen_sockets_pollfd[listen_sockets_num].revents = 0;
                listen_sockets_num++;
        } /* for (se) */
 
-       free_sockent (se);
+       se_ptr = listen_sockets;
+       while ((se_ptr != NULL) && (se_ptr->next != NULL))
+               se_ptr = se_ptr->next;
+
+       if (se_ptr == NULL)
+               listen_sockets = se;
+       else
+               se_ptr->next = se;
+
        return (0);
-} /* int network_add_listen_socket */
+} /* }}} int network_add_listen_socket */
 
-static int network_add_sending_socket (const char *node, const char *service)
+static int network_add_sending_socket (const char *node, /* {{{ */
+    const char *service, const char *shared_secret, int security_level)
 {
        sockent_t *se;
        sockent_t *se_ptr;
@@ -1222,9 +1583,11 @@ static int network_add_sending_socket (const char *node, const char *service)
                service = NET_DEFAULT_PORT;
 
        if (node == NULL)
-               se = network_create_default_socket (0 /* listen == false */);
+               se = network_create_default_socket (/* flags = */ 0);
        else
-               se = network_create_socket (node, service, 0 /* listen == false */);
+               se = network_create_socket (node, service,
+                               shared_secret, security_level,
+                                /* flags = */ 0);
 
        if (se == NULL)
                return (-1);
@@ -1240,7 +1603,7 @@ static int network_add_sending_socket (const char *node, const char *service)
 
        se_ptr->next = se;
        return (0);
-} /* int network_get_listen_socket */
+} /* }}} int network_add_sending_socket */
 
 static void *dispatch_thread (void __attribute__((unused)) *arg)
 {
@@ -1265,13 +1628,13 @@ static void *dispatch_thread (void __attribute__((unused)) *arg)
     if (ent == NULL)
       break;
 
-    parse_packet (ent->data, ent->data_len);
+    parse_packet (ent);
 
     sfree (ent);
   } /* while (42) */
 
   return (NULL);
-} /* void *receive_thread */
+} /* void *dispatch_thread */
 
 static int network_receive (void)
 {
@@ -1285,7 +1648,10 @@ static int network_receive (void)
        receive_list_entry_t *private_list_tail;
 
        if (listen_sockets_num == 0)
-               network_add_listen_socket (NULL, NULL);
+               network_add_listen_socket (/* node = */ NULL,
+                               /* service = */ NULL,
+                               /* shared secret = */ NULL,
+                               /* encryption = */ 0);
 
        if (listen_sockets_num == 0)
        {
@@ -1298,7 +1664,7 @@ static int network_receive (void)
 
        while (listen_loop == 0)
        {
-               status = poll (listen_sockets, listen_sockets_num, -1);
+               status = poll (listen_sockets_pollfd, listen_sockets_num, -1);
 
                if (status <= 0)
                {
@@ -1314,11 +1680,12 @@ static int network_receive (void)
                {
                        receive_list_entry_t *ent;
 
-                       if ((listen_sockets[i].revents & (POLLIN | POLLPRI)) == 0)
+                       if ((listen_sockets_pollfd[i].revents
+                                               & (POLLIN | POLLPRI)) == 0)
                                continue;
                        status--;
 
-                       buffer_len = recv (listen_sockets[i].fd,
+                       buffer_len = recv (listen_sockets_pollfd[i].fd,
                                        buffer, sizeof (buffer),
                                        0 /* no flags */);
                        if (buffer_len < 0)
@@ -1330,6 +1697,10 @@ static int network_receive (void)
                                return (-1);
                        }
 
+                       /* TODO: Possible performance enhancement: Do not free
+                        * these entries in the dispatch thread but put them in
+                        * another list, so we don't have to allocate more and
+                        * more of these structures. */
                        ent = malloc (sizeof (receive_list_entry_t));
                        if (ent == NULL)
                        {
@@ -1337,6 +1708,7 @@ static int network_receive (void)
                                return (-1);
                        }
                        memset (ent, 0, sizeof (receive_list_entry_t));
+                       ent->fd = listen_sockets_pollfd[i].fd;
                        ent->next = NULL;
 
                        /* Hopefully this be optimized out by the compiler. It
@@ -1369,7 +1741,7 @@ static int network_receive (void)
                                pthread_cond_signal (&receive_list_cond);
                                pthread_mutex_unlock (&receive_list_lock);
                        }
-               } /* for (listen_sockets) */
+               } /* for (listen_sockets_pollfd) */
        } /* while (listen_loop == 0) */
 
        /* Make sure everything is dispatched before exiting. */
@@ -1391,43 +1763,146 @@ static int network_receive (void)
        }
 
        return (0);
-}
+} /* int network_receive */
 
 static void *receive_thread (void __attribute__((unused)) *arg)
 {
        return (network_receive () ? (void *) 1 : (void *) 0);
 } /* void *receive_thread */
 
-static void network_send_buffer (const char *buffer, int buffer_len)
+static void network_init_buffer (void)
 {
-       sockent_t *se;
-       int status;
+       memset (send_buffer, 0, sizeof (send_buffer));
+       send_buffer_ptr = send_buffer;
+       send_buffer_fill = 0;
 
-       DEBUG ("network plugin: network_send_buffer: buffer_len = %i", buffer_len);
+       memset (&send_buffer_vl, 0, sizeof (send_buffer_vl));
+} /* int network_init_buffer */
 
-       for (se = sending_sockets; se != NULL; se = se->next)
+static void networt_send_buffer_plain (const sockent_t *se, /* {{{ */
+               const char *buffer, size_t buffer_size)
+{
+       int status;
+
+       while (42)
        {
-               while (42)
+               status = sendto (se->fd, buffer, buffer_size, 0 /* no flags */,
+                               (struct sockaddr *) se->addr, se->addrlen);
+               if (status < 0)
                {
-                       status = sendto (se->fd, buffer, buffer_len, 0 /* no flags */,
-                                       (struct sockaddr *) se->addr, se->addrlen);
-                       if (status < 0)
-                       {
-                               char errbuf[1024];
-                               if (errno == EINTR)
-                                       continue;
-                               ERROR ("network plugin: sendto failed: %s",
-                                               sstrerror (errno, errbuf,
-                                                       sizeof (errbuf)));
-                               break;
-                       }
-
+                       char errbuf[1024];
+                       if (errno == EINTR)
+                               continue;
+                       ERROR ("network plugin: sendto failed: %s",
+                                       sstrerror (errno, errbuf,
+                                               sizeof (errbuf)));
                        break;
-               } /* while (42) */
-       } /* for (sending_sockets) */
-} /* void network_send_buffer */
+               }
+
+               break;
+       } /* while (42) */
+} /* }}} void networt_send_buffer_plain */
+
+#if HAVE_GCRYPT_H
+static void networt_send_buffer_signed (const sockent_t *se, /* {{{ */
+               const char *in_buffer, size_t in_buffer_size)
+{
+       part_signature_sha256_t ps;
+       char buffer[sizeof (ps) + in_buffer_size];
+       char hash[sizeof (ps.hash)];
+
+       /* Initialize the `ps' structure. */
+       memset (&ps, 0, sizeof (ps));
+       ps.head.type = htons (TYPE_SIGN_SHA256);
+       ps.head.length = htons ((uint16_t) sizeof (ps));
+       sstrncpy (ps.hash, se->shared_secret, sizeof (ps.hash));
+
+       /* Prepend the signature. */
+       memcpy (buffer, &ps, sizeof (ps));
+       memcpy (buffer + sizeof (ps), in_buffer, in_buffer_size);
+
+       /* Calculate the hash value. */
+       gcry_md_hash_buffer (GCRY_MD_SHA256, hash, buffer, sizeof (buffer));
+
+       /* Copy the hash value into the buffer. */
+       memcpy (ps.hash, hash, sizeof (ps.hash));
+       memcpy (buffer, &ps, sizeof (ps));
+
+       networt_send_buffer_plain (se, buffer, sizeof (buffer));
+} /* }}} void networt_send_buffer_signed */
+
+static void networt_send_buffer_encrypted (const sockent_t *se, /* {{{ */
+               const char *in_buffer, size_t in_buffer_size)
+{
+  part_encryption_aes256_t pea;
+  char buffer[sizeof (pea) + in_buffer_size + 16];
+  size_t buffer_size;
+  gcry_error_t err;
+
+  /* Round to the next multiple of 16, because AES has a block size of 128 bit.
+   * the first four bytes of `pea' are not encrypted and must be subtracted. */
+  buffer_size = (sizeof (pea) + in_buffer_size + 15 - sizeof (pea.head)) / 16;
+  buffer_size = buffer_size * 16;
+  buffer_size += sizeof (pea.head);
+
+  DEBUG ("network plugin: networt_send_buffer_encrypted: "
+      "buffer_size = %zu;", buffer_size);
+
+  /* Initialize the header fields */
+  memset (&pea, 0, sizeof (pea));
+  pea.head.type = htons (TYPE_ENCR_AES256);
+  pea.head.length = htons ((uint16_t) buffer_size);
+  pea.orig_length = htons ((uint16_t) in_buffer_size);
+
+  /* Fill the extra field with random values. Some entropy in the encrypted
+   * data is usually not a bad thing, I hope. */
+  gcry_randomize (&pea.random, sizeof (pea.random), GCRY_STRONG_RANDOM);
+
+  /* Create hash of the payload */
+  gcry_md_hash_buffer (GCRY_MD_SHA224, pea.hash, in_buffer, in_buffer_size);
+
+  /* Initialize the buffer */
+  memset (buffer, 0, sizeof (buffer));
+  memcpy (buffer, &pea, sizeof (pea));
+  memcpy (buffer + sizeof (pea), in_buffer, in_buffer_size);
+
+  /* Encrypt the buffer in-place */
+  err = gcry_cipher_encrypt (se->cypher,
+      buffer + sizeof (pea.head), buffer_size - sizeof (pea.head),
+      /* in = */ NULL, /* in len = */ 0);
+  gcry_cipher_reset (se->cypher);
+  if (err != 0)
+  {
+    ERROR ("network plugin: gcry_cipher_encrypt returned: %s",
+        gcry_strerror (err));
+    return;
+  }
+
+  /* Send it out without further modifications */
+  networt_send_buffer_plain (se, buffer, buffer_size);
+} /* }}} void networt_send_buffer_encrypted */
+#endif /* HAVE_GCRYPT_H */
+
+static void network_send_buffer (char *buffer, size_t buffer_len) /* {{{ */
+{
+  sockent_t *se;
 
-static int add_to_buffer (char *buffer, int buffer_size,
+  DEBUG ("network plugin: network_send_buffer: buffer_len = %zu", buffer_len);
+
+  for (se = sending_sockets; se != NULL; se = se->next)
+  {
+#if HAVE_GCRYPT_H
+    if (se->security_level == SECURITY_LEVEL_ENCRYPT)
+      networt_send_buffer_encrypted (se, buffer, buffer_len);
+    else if (se->security_level == SECURITY_LEVEL_SIGN)
+      networt_send_buffer_signed (se, buffer, buffer_len);
+    else /* if (se->security_level == SECURITY_LEVEL_NONE) */
+#endif /* HAVE_GCRYPT_H */
+      networt_send_buffer_plain (se, buffer, buffer_len);
+  } /* for (sending_sockets) */
+} /* }}} void network_send_buffer */
+
+static int add_to_buffer (char *buffer, int buffer_size, /* {{{ */
                value_list_t *vl_def,
                const data_set_t *ds, const value_list_t *vl)
 {
@@ -1495,20 +1970,19 @@ static int add_to_buffer (char *buffer, int buffer_size,
                return (-1);
 
        return (buffer - buffer_orig);
-} /* int add_to_buffer */
+} /* }}} int add_to_buffer */
 
 static void flush_buffer (void)
 {
        DEBUG ("network plugin: flush_buffer: send_buffer_fill = %i",
                        send_buffer_fill);
 
-       network_send_buffer (send_buffer, send_buffer_fill);
-       send_buffer_ptr  = send_buffer;
-       send_buffer_fill = 0;
-       memset (&send_buffer_vl, 0, sizeof (send_buffer_vl));
+       network_send_buffer (send_buffer, (size_t) send_buffer_fill);
+       network_init_buffer ();
 }
 
-static int network_write (const data_set_t *ds, const value_list_t *vl)
+static int network_write (const data_set_t *ds, const value_list_t *vl,
+               user_data_t __attribute__((unused)) *user_data)
 {
        int status;
 
@@ -1523,7 +1997,7 @@ static int network_write (const data_set_t *ds, const value_list_t *vl)
        pthread_mutex_lock (&send_buffer_lock);
 
        status = add_to_buffer (send_buffer_ptr,
-                       sizeof (send_buffer) - send_buffer_fill,
+                       sizeof (send_buffer) - (send_buffer_fill + BUFF_SIG_SIZE),
                        &send_buffer_vl,
                        ds, vl);
        if (status >= 0)
@@ -1537,7 +2011,7 @@ static int network_write (const data_set_t *ds, const value_list_t *vl)
                flush_buffer ();
 
                status = add_to_buffer (send_buffer_ptr,
-                               sizeof (send_buffer) - send_buffer_fill,
+                               sizeof (send_buffer) - (send_buffer_fill + BUFF_SIG_SIZE),
                                &send_buffer_vl,
                                ds, vl);
 
@@ -1563,76 +2037,207 @@ static int network_write (const data_set_t *ds, const value_list_t *vl)
        return ((status < 0) ? -1 : 0);
 } /* int network_write */
 
-static int network_config (const char *key, const char *val)
+static int network_config_set_boolean (const oconfig_item_t *ci, /* {{{ */
+    int *retval)
 {
-       char *node;
-       char *service;
+  if ((ci->values_num != 1)
+      || ((ci->values[0].type != OCONFIG_TYPE_BOOLEAN)
+        && (ci->values[0].type != OCONFIG_TYPE_STRING)))
+  {
+    ERROR ("network plugin: The `%s' config option needs "
+        "exactly one boolean argument.", ci->key);
+    return (-1);
+  }
 
-       char *fields[3];
-       int   fields_num;
+  if (ci->values[0].type == OCONFIG_TYPE_BOOLEAN)
+  {
+    if (ci->values[0].value.boolean)
+      *retval = 1;
+    else
+      *retval = 0;
+  }
+  else
+  {
+    char *str = ci->values[0].value.string;
+
+    if ((strcasecmp ("true", str) == 0)
+        || (strcasecmp ("yes", str) == 0)
+        || (strcasecmp ("on", str) == 0))
+      *retval = 1;
+    else if ((strcasecmp ("false", str) == 0)
+        || (strcasecmp ("no", str) == 0)
+        || (strcasecmp ("off", str) == 0))
+      *retval = 0;
+    else
+    {
+      ERROR ("network plugin: Cannot parse string value `%s' of the `%s' "
+          "option as boolean value.",
+          str, ci->key);
+      return (-1);
+    }
+  }
 
-       if ((strcasecmp ("Listen", key) == 0)
-                       || (strcasecmp ("Server", key) == 0))
-       {
-               char *val_cpy = strdup (val);
-               if (val_cpy == NULL)
-                       return (1);
+  return (0);
+} /* }}} int network_config_set_boolean */
 
-               service = NET_DEFAULT_PORT;
-               fields_num = strsplit (val_cpy, fields, 3);
-               if ((fields_num != 1)
-                               && (fields_num != 2))
-               {
-                       sfree (val_cpy);
-                       return (1);
-               }
-               else if (fields_num == 2)
-               {
-                       if ((service = strchr (fields[1], '.')) != NULL)
-                               *service = '\0';
-                       service = fields[1];
-               }
-               node = fields[0];
+static int network_config_set_ttl (const oconfig_item_t *ci) /* {{{ */
+{
+  int tmp;
+  if ((ci->values_num != 1)
+      || (ci->values[0].type != OCONFIG_TYPE_NUMBER))
+  {
+    WARNING ("network plugin: The `TimeToLive' config option needs exactly "
+        "one numeric argument.");
+    return (-1);
+  }
 
-               if (strcasecmp ("Listen", key) == 0)
-                       network_add_listen_socket (node, service);
-               else
-                       network_add_sending_socket (node, service);
+  tmp = (int) ci->values[0].value.number;
+  if ((tmp > 0) && (tmp <= 255))
+    network_config_ttl = tmp;
 
-               sfree (val_cpy);
-       }
-       else if (strcasecmp ("TimeToLive", key) == 0)
-       {
-               int tmp = atoi (val);
-               if ((tmp > 0) && (tmp < 256))
-                       network_config_ttl = tmp;
-               else
-                       return (1);
-       }
-       else if (strcasecmp ("Forward", key) == 0)
-       {
-               if ((strcasecmp ("true", val) == 0)
-                               || (strcasecmp ("yes", val) == 0)
-                               || (strcasecmp ("on", val) == 0))
-                       network_config_forward = 1;
-               else
-                       network_config_forward = 0;
-       }
-       else if (strcasecmp ("CacheFlush", key) == 0)
-       {
-               int tmp = atoi (val);
-               if (tmp > 0)
-                       cache_flush_interval = tmp;
-               else return (1);
-       }
-       else
-       {
-               return (-1);
-       }
-       return (0);
-} /* int network_config */
+  return (0);
+} /* }}} int network_config_set_ttl */
+
+#if HAVE_GCRYPT_H
+static int network_config_set_security_level (oconfig_item_t *ci, /* {{{ */
+    int *retval)
+{
+  char *str;
+  if ((ci->values_num != 1)
+      || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("network plugin: The `SecurityLevel' config option needs exactly "
+        "one string argument.");
+    return (-1);
+  }
+
+  str = ci->values[0].value.string;
+  if (strcasecmp ("Encrypt", str) == 0)
+    *retval = SECURITY_LEVEL_ENCRYPT;
+  else if (strcasecmp ("Sign", str) == 0)
+    *retval = SECURITY_LEVEL_SIGN;
+  else if (strcasecmp ("None", str) == 0)
+    *retval = SECURITY_LEVEL_NONE;
+  else
+  {
+    WARNING ("network plugin: Unknown security level: %s.", str);
+    return (-1);
+  }
+
+  return (0);
+} /* }}} int network_config_set_security_level */
+#endif /* HAVE_GCRYPT_H */
+
+static int network_config_listen_server (const oconfig_item_t *ci) /* {{{ */
+{
+  char *node;
+  char *service;
+  char *shared_secret = NULL;
+  int security_level = SECURITY_LEVEL_NONE;
+  int i;
+
+  if ((ci->values_num < 1) || (ci->values_num > 2)
+      || (ci->values[0].type != OCONFIG_TYPE_STRING)
+      || ((ci->values_num > 1) && (ci->values[1].type != OCONFIG_TYPE_STRING)))
+  {
+    ERROR ("network plugin: The `%s' config option needs "
+        "one or two string arguments.", ci->key);
+    return (-1);
+  }
+
+  node = ci->values[0].value.string;
+  if (ci->values_num >= 2)
+    service = ci->values[1].value.string;
+  else
+    service = NULL;
+
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+
+#if HAVE_GCRYPT_H
+    if (strcasecmp ("Secret", child->key) == 0)
+    {
+      if ((child->values_num == 1)
+          && (child->values[0].type == OCONFIG_TYPE_STRING))
+        shared_secret = child->values[0].value.string;
+      else
+        ERROR ("network plugin: The `Secret' option needs exactly one string "
+            "argument.");
+    }
+    else if (strcasecmp ("SecurityLevel", child->key) == 0)
+      network_config_set_security_level (child, &security_level);
+    else
+#endif /* HAVE_GCRYPT_H */
+    {
+      WARNING ("network plugin: Option `%s' is not allowed here.",
+          child->key);
+    }
+  }
+
+  if ((security_level > SECURITY_LEVEL_NONE) && (shared_secret == NULL))
+  {
+    ERROR ("network plugin: A security level higher than `none' was "
+        "requested, but no shared key was given. Cowardly refusing to open "
+        "this socket!");
+    return (-1);
+  }
+
+  if (strcasecmp ("Listen", ci->key) == 0)
+    network_add_listen_socket (node, service, shared_secret, security_level);
+  else
+    network_add_sending_socket (node, service, shared_secret, security_level);
+
+  return (0);
+} /* }}} int network_config_listen_server */
+
+static int network_config_set_cache_flush (const oconfig_item_t *ci) /* {{{ */
+{
+  int tmp;
+  if ((ci->values_num != 1)
+      || (ci->values[0].type != OCONFIG_TYPE_NUMBER))
+  {
+    WARNING ("network plugin: The `CacheFlush' config option needs exactly "
+        "one numeric argument.");
+    return (-1);
+  }
 
-static int network_notification (const notification_t *n)
+  tmp = (int) ci->values[0].value.number;
+  if (tmp > 0)
+    network_config_ttl = tmp;
+
+  return (0);
+} /* }}} int network_config_set_cache_flush */
+
+static int network_config (oconfig_item_t *ci) /* {{{ */
+{
+  int i;
+
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+
+    if ((strcasecmp ("Listen", child->key) == 0)
+        || (strcasecmp ("Server", child->key) == 0))
+      network_config_listen_server (child);
+    else if (strcasecmp ("TimeToLive", child->key) == 0)
+      network_config_set_ttl (child);
+    else if (strcasecmp ("Forward", child->key) == 0)
+      network_config_set_boolean (child, &network_config_forward);
+    else if (strcasecmp ("CacheFlush", child->key) == 0)
+      network_config_set_cache_flush (child);
+    else
+    {
+      WARNING ("network plugin: Option `%s' is not allowed here.",
+          child->key);
+    }
+  }
+
+  return (0);
+} /* }}} int network_config */
+
+static int network_notification (const notification_t *n,
+               user_data_t __attribute__((unused)) *user_data)
 {
   char  buffer[BUFF_SIZE];
   char *buffer_ptr = buffer;
@@ -1708,16 +2313,27 @@ static int network_shutdown (void)
        listen_loop++;
 
        /* Kill the listening thread */
-       if (receive_thread_id != (pthread_t) 0)
+       if (receive_thread_running != 0)
        {
+               INFO ("network plugin: Stopping receive thread.");
                pthread_kill (receive_thread_id, SIGTERM);
                pthread_join (receive_thread_id, NULL /* no return value */);
-               receive_thread_id = (pthread_t) 0;
+               memset (&receive_thread_id, 0, sizeof (receive_thread_id));
+               receive_thread_running = 0;
        }
 
        /* Shutdown the dispatching thread */
-       if (dispatch_thread_id != (pthread_t) 0)
+       if (dispatch_thread_running != 0)
+       {
+               INFO ("network plugin: Stopping dispatch thread.");
+               pthread_mutex_lock (&receive_list_lock);
                pthread_cond_broadcast (&receive_list_cond);
+               pthread_mutex_unlock (&receive_list_lock);
+               pthread_join (dispatch_thread_id, /* ret = */ NULL);
+               dispatch_thread_running = 0;
+       }
+
+       free_sockent (listen_sockets);
 
        if (send_buffer_fill > 0)
                flush_buffer ();
@@ -1758,9 +2374,7 @@ static int network_init (void)
 
        plugin_register_shutdown ("network", network_shutdown);
 
-       send_buffer_ptr  = send_buffer;
-       send_buffer_fill = 0;
-       memset (&send_buffer_vl, 0, sizeof (send_buffer_vl));
+       network_init_buffer ();
 
        cache_tree = c_avl_create ((int (*) (const void *, const void *)) strcmp);
        cache_flush_last = time (NULL);
@@ -1768,14 +2382,21 @@ static int network_init (void)
        /* setup socket(s) and so on */
        if (sending_sockets != NULL)
        {
-               plugin_register_write ("network", network_write);
-               plugin_register_notification ("network", network_notification);
+               plugin_register_write ("network", network_write,
+                               /* user_data = */ NULL);
+               plugin_register_notification ("network", network_notification,
+                               /* user_data = */ NULL);
        }
 
-       if ((listen_sockets_num != 0) && (receive_thread_id == 0))
+       /* If no threads need to be started, return here. */
+       if ((listen_sockets_num == 0)
+                       || ((dispatch_thread_running != 0)
+                               && (receive_thread_running != 0)))
+               return (0);
+
+       if (dispatch_thread_running == 0)
        {
                int status;
-
                status = pthread_create (&dispatch_thread_id,
                                NULL /* no attributes */,
                                dispatch_thread,
@@ -1787,7 +2408,15 @@ static int network_init (void)
                                        sstrerror (errno, errbuf,
                                                sizeof (errbuf)));
                }
+               else
+               {
+                       dispatch_thread_running = 1;
+               }
+       }
 
+       if (receive_thread_running == 0)
+       {
+               int status;
                status = pthread_create (&receive_thread_id,
                                NULL /* no attributes */,
                                receive_thread,
@@ -1799,7 +2428,12 @@ static int network_init (void)
                                        sstrerror (errno, errbuf,
                                                sizeof (errbuf)));
                }
+               else
+               {
+                       receive_thread_running = 1;
+               }
        }
+
        return (0);
 } /* int network_init */
 
@@ -1811,7 +2445,8 @@ static int network_init (void)
  * there, good. If not, well, then there is nothing to flush.. -octo
  */
 static int network_flush (int timeout,
-               const char __attribute__((unused)) *identifier)
+               const char __attribute__((unused)) *identifier,
+               user_data_t __attribute__((unused)) *user_data)
 {
        pthread_mutex_lock (&send_buffer_lock);
 
@@ -1828,8 +2463,10 @@ static int network_flush (int timeout,
 
 void module_register (void)
 {
-       plugin_register_config ("network", network_config,
-                       config_keys, config_keys_num);
+       plugin_register_complex_config ("network", network_config);
        plugin_register_init   ("network", network_init);
-       plugin_register_flush   ("network", network_flush);
+       plugin_register_flush   ("network", network_flush,
+                       /* user_data = */ NULL);
 } /* void module_register */
+
+/* vim: set fdm=marker : */
index 4318ef9..777616c 100644 (file)
@@ -67,4 +67,7 @@
 #define TYPE_MESSAGE         0x0100
 #define TYPE_SEVERITY        0x0101
 
+#define TYPE_SIGN_SHA256     0x0200
+#define TYPE_ENCR_AES256     0x0210
+
 #endif /* NETWORK_H */
index 2e62e88..839bc61 100644 (file)
@@ -72,7 +72,8 @@ static int c_notify_config (oconfig_item_t *ci)
        return 0;
 } /* c_notify_config */
 
-static int c_notify (const notification_t *n)
+static int c_notify (const notification_t *n,
+               user_data_t __attribute__((unused)) *user_data)
 {
        NotifyNotification *notification = NULL;
        NotifyUrgency       urgency      = NOTIFY_URGENCY_LOW;
@@ -145,7 +146,8 @@ static int c_notify_init (void)
                free (spec_version);
        }
 
-       plugin_register_notification ("notify_desktop", c_notify);
+       plugin_register_notification ("notify_desktop", c_notify,
+                       /* user_data = */ NULL);
        plugin_register_shutdown ("notify_desktop", c_notify_shutdown);
        return 0;
 } /* c_notify_init */
index 32bd916..62e1c48 100644 (file)
@@ -203,7 +203,8 @@ static int notify_email_config (const char *key, const char *value)
   return 0;
 } /* int notify_email_config (const char *, const char *) */
 
-static int notify_email_notification (const notification_t *n)
+static int notify_email_notification (const notification_t *n,
+    user_data_t __attribute__((unused)) *user_data)
 {
   smtp_recipient_t recipient;
 
@@ -282,7 +283,8 @@ void module_register (void)
   plugin_register_shutdown ("notify_email", notify_email_shutdown);
   plugin_register_config ("notify_email", notify_email_config,
       config_keys, config_keys_num);
-  plugin_register_notification ("notify_email", notify_email_notification);
+  plugin_register_notification ("notify_email", notify_email_notification,
+      /* user_data = */ NULL);
 } /* void module_register (void) */
 
 /* vim: set sw=2 sts=2 ts=8 et : */
index c40d5ad..261457a 100644 (file)
@@ -59,12 +59,14 @@ static ow_family_features_t ow_family_features[] =
 static int ow_family_features_num = STATIC_ARRAY_SIZE (ow_family_features);
 
 static char *device_g = NULL;
+static int   ow_interval = 0;
 
 static const char *config_keys[] =
 {
   "Device",
   "IgnoreSelected",
   "Sensor",
+  "Interval"
 };
 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
 
@@ -104,33 +106,22 @@ static int cow_load_config (const char *key, const char *value)
     sfree (device_g);
     device_g = temp;
   }
-  else
+  else if (strcasecmp ("Interval", key) == 0)
   {
-    return (-1);
+    int tmp;
+    tmp = atoi (value);
+    if (tmp > 0)
+      ow_interval = tmp;
+    else
+      ERROR ("onewire plugin: Invalid `Interval' setting: %s", value);
   }
-
-  return (0);
-}
-
-static int cow_init (void)
-{
-  int status;
-
-  if (device_g == NULL)
+  else
   {
-    ERROR ("onewire plugin: cow_init: No device configured.");
     return (-1);
   }
 
-  status = (int) OW_init (device_g);
-  if (status != 0)
-  {
-    ERROR ("onewire plugin: OW_init(%s) failed: %i.", device_g, status);
-    return (1);
-  }
-
   return (0);
-} /* int cow_init */
+}
 
 static int cow_read_values (const char *path, const char *name,
     const ow_family_features_t *family_info)
@@ -287,7 +278,7 @@ static int cow_read_bus (const char *path)
   return (0);
 } /* int cow_read_bus */
 
-static int cow_read (void)
+static int cow_read (user_data_t *ud __attribute__((unused)))
 {
   return (cow_read_bus ("/"));
 } /* int cow_read */
@@ -299,11 +290,38 @@ static int cow_shutdown (void)
   return (0);
 } /* int cow_shutdown */
 
+static int cow_init (void)
+{
+  int status;
+  struct timespec cb_interval;
+
+  if (device_g == NULL)
+  {
+    ERROR ("onewire plugin: cow_init: No device configured.");
+    return (-1);
+  }
+
+  status = (int) OW_init (device_g);
+  if (status != 0)
+  {
+    ERROR ("onewire plugin: OW_init(%s) failed: %i.", device_g, status);
+    return (1);
+  }
+
+  memset (&cb_interval, 0, sizeof (cb_interval));
+  if (ow_interval > 0)
+    cb_interval.tv_sec = (time_t) ow_interval;
+
+  plugin_register_complex_read ("onewire", cow_read,
+      &cb_interval, /* user data = */ NULL);
+  plugin_register_shutdown ("onewire", cow_shutdown);
+
+  return (0);
+} /* int cow_init */
+
 void module_register (void)
 {
   plugin_register_init ("onewire", cow_init);
-  plugin_register_read ("onewire", cow_read);
-  plugin_register_shutdown ("onewire", cow_shutdown);
   plugin_register_config ("onewire", cow_load_config,
     config_keys, config_keys_num);
 }
index 81ef720..b6e7b22 100644 (file)
@@ -1527,6 +1527,9 @@ static XS (Collectd_plugin_register_ds)
 
        dXSARGS;
 
+       log_warn ("Using plugin_register() to register new data-sets is "
+                       "deprecated - add new entries to a custom types.db instead.");
+
        if (2 != items) {
                log_err ("Usage: Collectd::plugin_register_data_set(type, dataset)");
                XSRETURN_EMPTY;
@@ -1907,7 +1910,8 @@ static int perl_read (void)
        return pplugin_call_all (aTHX_ PLUGIN_READ);
 } /* static int perl_read (void) */
 
-static int perl_write (const data_set_t *ds, const value_list_t *vl)
+static int perl_write (const data_set_t *ds, const value_list_t *vl,
+               user_data_t __attribute__((unused)) *user_data)
 {
        dTHX;
 
@@ -1929,7 +1933,8 @@ static int perl_write (const data_set_t *ds, const value_list_t *vl)
        return pplugin_call_all (aTHX_ PLUGIN_WRITE, ds, vl);
 } /* static int perl_write (const data_set_t *, const value_list_t *) */
 
-static void perl_log (int level, const char *msg)
+static void perl_log (int level, const char *msg,
+               user_data_t __attribute__((unused)) *user_data)
 {
        dTHX;
 
@@ -1950,7 +1955,8 @@ static void perl_log (int level, const char *msg)
        return;
 } /* static void perl_log (int, const char *) */
 
-static int perl_notify (const notification_t *notif)
+static int perl_notify (const notification_t *notif,
+               user_data_t __attribute__((unused)) *user_data)
 {
        dTHX;
 
@@ -1969,7 +1975,8 @@ static int perl_notify (const notification_t *notif)
        return pplugin_call_all (aTHX_ PLUGIN_NOTIF, notif);
 } /* static int perl_notify (const notification_t *) */
 
-static int perl_flush (int timeout, const char *identifier)
+static int perl_flush (int timeout, const char *identifier,
+               user_data_t __attribute__((unused)) *user_data)
 {
        dTHX;
 
@@ -2215,14 +2222,15 @@ static int init_pi (int argc, char **argv)
 
        perl_run (aTHX);
 
-       plugin_register_log ("perl", perl_log);
-       plugin_register_notification ("perl", perl_notify);
+       plugin_register_log ("perl", perl_log, /* user_data = */ NULL);
+       plugin_register_notification ("perl", perl_notify,
+                       /* user_data = */ NULL);
        plugin_register_init ("perl", perl_init);
 
        plugin_register_read ("perl", perl_read);
 
-       plugin_register_write ("perl", perl_write);
-       plugin_register_flush ("perl", perl_flush);
+       plugin_register_write ("perl", perl_write, /* user_data = */ NULL);
+       plugin_register_flush ("perl", perl_flush, /* user_data = */ NULL);
        plugin_register_shutdown ("perl", perl_shutdown);
        return 0;
 } /* static int init_pi (const char **, const int) */
index 7ffbfaf..de9c45b 100644 (file)
@@ -1,6 +1,6 @@
 /**
  * collectd - src/ping.c
- * Copyright (C) 2005,2006  Florian octo Forster
+ * Copyright (C) 2005-2009  Florian octo Forster
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
 #include "plugin.h"
 #include "configfile.h"
 
+#include <pthread.h>
 #include <netinet/in.h>
-#include "liboping/oping.h"
+#if HAVE_NETDB_H
+# include <netdb.h> /* NI_MAXHOST */
+#endif
+
+#include <oping.h>
+
+#ifndef NI_MAXHOST
+# define NI_MAXHOST 1025
+#endif
 
 /*
  * Private data types
  */
 struct hostlist_s
 {
-       char *host;
-       int   wait_time;
-       int   wait_left;
-       struct hostlist_s *next;
+  char *host;
+
+  uint32_t pkg_sent;
+  uint32_t pkg_recv;
+
+  double latency_total;
+  double latency_squared;
+
+  struct hostlist_s *next;
 };
 typedef struct hostlist_s hostlist_t;
 
 /*
  * Private variables
  */
-static pingobj_t *pingobj = NULL;
-static hostlist_t *hosts = NULL;
+static hostlist_t *hostlist_head = NULL;
+
+static int    ping_ttl = PING_DEF_TTL;
+static double ping_interval = 1.0;
+static double ping_timeout = 0.9;
+
+static int             ping_thread_loop = 0;
+static int             ping_thread_error = 0;
+static pthread_t       ping_thread_id;
+static pthread_mutex_t ping_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t  ping_cond = PTHREAD_COND_INITIALIZER;
 
 static const char *config_keys[] =
 {
-       "Host",
-       "TTL",
-       NULL
+  "Host",
+  "TTL",
+  "Interval",
+  "Timeout"
 };
-static int config_keys_num = 2;
+static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
 
 /*
  * Private functions
  */
-static void add_hosts (void)
+/* Assure that `ts->tv_nsec' is in the range 0 .. 999999999 */
+static void time_normalize (struct timespec *ts) /* {{{ */
+{
+  while (ts->tv_nsec < 0)
+  {
+    if (ts->tv_sec == 0)
+    {
+      ts->tv_nsec = 0;
+      return;
+    }
+
+    ts->tv_sec  -= 1;
+    ts->tv_nsec += 1000000000;
+  }
+
+  while (ts->tv_nsec >= 1000000000)
+  {
+    ts->tv_sec  += 1;
+    ts->tv_nsec -= 1000000000;
+  }
+} /* }}} void time_normalize */
+
+/* Add `ts_int' to `tv_begin' and store the result in `ts_dest'. If the result
+ * is larger than `tv_end', copy `tv_end' to `ts_dest' instead. */
+static void time_calc (struct timespec *ts_dest, /* {{{ */
+    const struct timespec *ts_int,
+    const struct timeval  *tv_begin,
+    const struct timeval  *tv_end)
+{
+  ts_dest->tv_sec = tv_begin->tv_sec + ts_int->tv_sec;
+  ts_dest->tv_nsec = (tv_begin->tv_usec * 1000) + ts_int->tv_nsec;
+  time_normalize (ts_dest);
+
+  /* Assure that `(begin + interval) > end'.
+   * This may seem overly complicated, but `tv_sec' is of type `time_t'
+   * which may be `unsigned. *sigh* */
+  if ((tv_end->tv_sec > ts_dest->tv_sec)
+      || ((tv_end->tv_sec == ts_dest->tv_sec)
+        && ((tv_end->tv_usec * 1000) > ts_dest->tv_nsec)))
+  {
+    ts_dest->tv_sec = tv_end->tv_sec;
+    ts_dest->tv_nsec = 1000 * tv_end->tv_usec;
+  }
+
+  time_normalize (ts_dest);
+} /* }}} void time_calc */
+
+static void *ping_thread (void *arg) /* {{{ */
 {
-       hostlist_t *hl_this;
-       hostlist_t *hl_prev;
-
-       hl_this = hosts;
-       hl_prev = NULL;
-       while (hl_this != NULL)
-       {
-               DEBUG ("ping plugin: host = %s, wait_left = %i, "
-                               "wait_time = %i, next = %p",
-                               hl_this->host, hl_this->wait_left,
-                               hl_this->wait_time, (void *) hl_this->next);
-
-               if (hl_this->wait_left <= 0)
-               {
-                       if (ping_host_add (pingobj, hl_this->host) == 0)
-                       {
-                               DEBUG ("ping plugin: Successfully added host %s", hl_this->host);
-                               /* Remove the host from the linked list */
-                               if (hl_prev != NULL)
-                                       hl_prev->next = hl_this->next;
-                               else
-                                       hosts = hl_this->next;
-                               free (hl_this->host);
-                               free (hl_this);
-                               hl_this = (hl_prev != NULL) ? hl_prev : hosts;
-                       }
-                       else
-                       {
-                               WARNING ("ping plugin: Failed adding host "
-                                               "`%s': %s", hl_this->host,
-                                               ping_get_error (pingobj));
-                               hl_this->wait_left = hl_this->wait_time;
-                               hl_this->wait_time *= 2;
-                               if (hl_this->wait_time > 86400)
-                                       hl_this->wait_time = 86400;
-                       }
-               }
-               else
-               {
-                       hl_this->wait_left -= interval_g;
-               }
-
-               if (hl_this != NULL)
-               {
-                       hl_prev = hl_this;
-                       hl_this = hl_this->next;
-               }
-       }
-} /* void add_hosts */
-
-static int ping_init (void)
+  static pingobj_t *pingobj = NULL;
+
+  struct timeval  tv_begin;
+  struct timeval  tv_end;
+  struct timespec ts_wait;
+  struct timespec ts_int;
+
+  hostlist_t *hl;
+  int status;
+
+  pthread_mutex_lock (&ping_lock);
+
+  pingobj = ping_construct ();
+  if (pingobj == NULL)
+  {
+    ERROR ("ping plugin: ping_construct failed.");
+    ping_thread_error = 1;
+    pthread_mutex_unlock (&ping_lock);
+    return ((void *) -1);
+  }
+
+  ping_setopt (pingobj, PING_OPT_TIMEOUT, (void *) &ping_timeout);
+  ping_setopt (pingobj, PING_OPT_TTL, (void *) &ping_ttl);
+
+  /* Add all the hosts to the ping object. */
+  status = 0;
+  for (hl = hostlist_head; hl != NULL; hl = hl->next)
+  {
+    int tmp_status;
+    tmp_status = ping_host_add (pingobj, hl->host);
+    if (tmp_status != 0)
+      WARNING ("ping plugin: ping_host_add (%s) failed.", hl->host);
+    else
+      status++;
+  }
+
+  if (status == 0)
+  {
+    ERROR ("ping plugin: No host could be added to ping object. Giving up.");
+    ping_thread_error = 1;
+    pthread_mutex_unlock (&ping_lock);
+    return ((void *) -1);
+  }
+
+  /* Set up `ts_int' */
+  {
+    double temp_sec;
+    double temp_nsec;
+
+    temp_nsec = modf (ping_interval, &temp_sec);
+    ts_int.tv_sec  = (time_t) temp_sec;
+    ts_int.tv_nsec = (long) (temp_nsec * 1000000000L);
+  }
+
+  while (ping_thread_loop > 0)
+  {
+    pingobj_iter_t *iter;
+    int status;
+
+    if (gettimeofday (&tv_begin, NULL) < 0)
+    {
+      ERROR ("ping plugin: gettimeofday failed");
+      ping_thread_error = 1;
+      break;
+    }
+
+    pthread_mutex_unlock (&ping_lock);
+
+    status = ping_send (pingobj);
+    if (status < 0)
+    {
+      ERROR ("ping plugin: ping_send failed: %s", ping_get_error (pingobj));
+      pthread_mutex_lock (&ping_lock);
+      ping_thread_error = 1;
+      break;
+    }
+
+    pthread_mutex_lock (&ping_lock);
+
+    if (ping_thread_loop <= 0)
+      break;
+
+    for (iter = ping_iterator_get (pingobj);
+        iter != NULL;
+        iter = ping_iterator_next (iter))
+    { /* {{{ */
+      char userhost[NI_MAXHOST];
+      double latency;
+      size_t param_size;
+
+      param_size = sizeof (userhost);
+      status = ping_iterator_get_info (iter,
+#ifdef PING_INFO_USERNAME
+          PING_INFO_USERNAME,
+#else
+          PING_INFO_HOSTNAME,
+#endif
+          userhost, &param_size);
+      if (status != 0)
+      {
+        WARNING ("ping plugin: ping_iterator_get_info failed: %s",
+            ping_get_error (pingobj));
+        continue;
+      }
+
+      for (hl = hostlist_head; hl != NULL; hl = hl->next)
+        if (strcmp (userhost, hl->host) == 0)
+          break;
+
+      if (hl == NULL)
+      {
+        WARNING ("ping plugin: Cannot find host %s.", userhost);
+        continue;
+      }
+
+      param_size = sizeof (latency);
+      status = ping_iterator_get_info (iter, PING_INFO_LATENCY,
+          (void *) &latency, &param_size);
+      if (status != 0)
+      {
+        WARNING ("ping plugin: ping_iterator_get_info failed: %s",
+            ping_get_error (pingobj));
+        continue;
+      }
+
+      hl->pkg_sent++;
+      if (latency >= 0.0)
+      {
+        hl->pkg_recv++;
+        hl->latency_total += latency;
+        hl->latency_squared += (latency * latency);
+      }
+    } /* }}} for (iter) */
+
+    if (gettimeofday (&tv_end, NULL) < 0)
+    {
+      ERROR ("ping plugin: gettimeofday failed");
+      ping_thread_error = 1;
+      break;
+    }
+
+    /* Calculate the absolute time until which to wait and store it in
+     * `ts_wait'. */
+    time_calc (&ts_wait, &ts_int, &tv_begin, &tv_end);
+
+    status = pthread_cond_timedwait (&ping_cond, &ping_lock, &ts_wait);
+    if (ping_thread_loop <= 0)
+      break;
+  } /* while (ping_thread_loop > 0) */
+
+  pthread_mutex_unlock (&ping_lock);
+  ping_destroy (pingobj);
+
+  return ((void *) 0);
+} /* }}} void *ping_thread */
+
+static int start_thread (void) /* {{{ */
 {
-       if (pingobj == NULL)
-               return (-1);
+  int status;
+
+  pthread_mutex_lock (&ping_lock);
+
+  if (ping_thread_loop != 0)
+  {
+    pthread_mutex_unlock (&ping_lock);
+    return (-1);
+  }
+
+  ping_thread_loop = 1;
+  ping_thread_error = 0;
+  status = pthread_create (&ping_thread_id, /* attr = */ NULL,
+      ping_thread, /* arg = */ (void *) 0);
+  if (status != 0)
+  {
+    ping_thread_loop = 0;
+    ERROR ("ping plugin: Starting thread failed.");
+    pthread_mutex_unlock (&ping_lock);
+    return (-1);
+  }
+    
+  pthread_mutex_unlock (&ping_lock);
+  return (0);
+} /* }}} int start_thread */
+
+static int stop_thread (void) /* {{{ */
+{
+  int status;
+
+  pthread_mutex_lock (&ping_lock);
+
+  if (ping_thread_loop == 0)
+  {
+    pthread_mutex_unlock (&ping_lock);
+    return (-1);
+  }
 
-       if (hosts != NULL)
-               add_hosts ();
+  ping_thread_loop = 0;
+  pthread_cond_broadcast (&ping_cond);
+  pthread_mutex_unlock (&ping_lock);
 
-       return (0);
-} /* int ping_init */
+  status = pthread_join (ping_thread_id, /* return = */ NULL);
+  if (status != 0)
+  {
+    ERROR ("ping plugin: Stopping thread failed.");
+    status = -1;
+  }
 
-static int ping_config (const char *key, const char *value)
+  memset (&ping_thread_id, 0, sizeof (ping_thread_id));
+  ping_thread_error = 0;
+
+  return (status);
+} /* }}} int stop_thread */
+
+static int ping_init (void) /* {{{ */
+{
+  if (hostlist_head == NULL)
+  {
+    NOTICE ("ping plugin: No hosts have been configured.");
+    return (-1);
+  }
+
+  if (ping_timeout > ping_interval)
+  {
+    ping_timeout = 0.9 * ping_interval;
+    WARNING ("ping plugin: Timeout is greater than interval. "
+        "Will use a timeout of %gs.", ping_timeout);
+  }
+
+  if (start_thread () != 0)
+    return (-1);
+
+  return (0);
+} /* }}} int ping_init */
+
+static int ping_config (const char *key, const char *value) /* {{{ */
 {
-       if (pingobj == NULL)
-       {
-               if ((pingobj = ping_construct ()) == NULL)
-               {
-                       ERROR ("ping plugin: `ping_construct' failed.");
-                       return (1);
-               }
-       }
-
-       if (strcasecmp (key, "host") == 0)
-       {
-               hostlist_t *hl;
-               char *host;
-
-               if ((hl = (hostlist_t *) malloc (sizeof (hostlist_t))) == NULL)
-               {
-                       char errbuf[1024];
-                       ERROR ("ping plugin: malloc failed: %s",
-                                       sstrerror (errno, errbuf,
-                                               sizeof (errbuf)));
-                       return (1);
-               }
-               if ((host = strdup (value)) == NULL)
-               {
-                       char errbuf[1024];
-                       free (hl);
-                       ERROR ("ping plugin: strdup failed: %s",
-                                       sstrerror (errno, errbuf,
-                                               sizeof (errbuf)));
-                       return (1);
-               }
-
-               hl->host = host;
-               hl->wait_time = 2 * interval_g;
-               hl->wait_left = 0;
-               hl->next = hosts;
-               hosts = hl;
-       }
-       else if (strcasecmp (key, "ttl") == 0)
-       {
-               int ttl = atoi (value);
-               if (ping_setopt (pingobj, PING_OPT_TTL, (void *) &ttl))
-               {
-                       WARNING ("ping: liboping did not accept the TTL value %i", ttl);
-                       return (1);
-               }
-       }
-       else
-       {
-               return (-1);
-       }
-
-       return (0);
-}
-
-static void ping_submit (char *host, double latency)
+  if (strcasecmp (key, "Host") == 0)
+  {
+    hostlist_t *hl;
+    char *host;
+
+    hl = (hostlist_t *) malloc (sizeof (hostlist_t));
+    if (hl == NULL)
+    {
+      char errbuf[1024];
+      ERROR ("ping plugin: malloc failed: %s",
+          sstrerror (errno, errbuf, sizeof (errbuf)));
+      return (1);
+    }
+
+    host = strdup (value);
+    if (host == NULL)
+    {
+      char errbuf[1024];
+      sfree (hl);
+      ERROR ("ping plugin: strdup failed: %s",
+          sstrerror (errno, errbuf, sizeof (errbuf)));
+      return (1);
+    }
+
+    hl->host = host;
+    hl->pkg_sent = 0;
+    hl->pkg_recv = 0;
+    hl->latency_total = 0.0;
+    hl->latency_squared = 0.0;
+    hl->next = hostlist_head;
+    hostlist_head = hl;
+  }
+  else if (strcasecmp (key, "TTL") == 0)
+  {
+    int ttl = atoi (value);
+    if ((ttl > 0) && (ttl <= 255))
+      ping_ttl = ttl;
+    else
+      WARNING ("ping plugin: Ignoring invalid TTL %i.", ttl);
+  }
+  else if (strcasecmp (key, "Interval") == 0)
+  {
+    double tmp;
+
+    tmp = atof (value);
+    if (tmp > 0.0)
+      ping_interval = tmp;
+    else
+      WARNING ("ping plugin: Ignoring invalid interval %g (%s)",
+          tmp, value);
+  }
+  else if (strcasecmp (key, "Timeout") == 0)
+  {
+    double tmp;
+
+    tmp = atof (value);
+    if (tmp > 0.0)
+      ping_timeout = tmp;
+    else
+      WARNING ("ping plugin: Ignoring invalid timeout %g (%s)",
+          tmp, value);
+  }
+  else
+  {
+    return (-1);
+  }
+
+  return (0);
+} /* }}} int ping_config */
+
+static void submit (const char *host, const char *type, /* {{{ */
+    gauge_t value)
 {
-       value_t values[1];
-       value_list_t vl = VALUE_LIST_INIT;
+  value_t values[1];
+  value_list_t vl = VALUE_LIST_INIT;
 
-       values[0].gauge = latency;
+  values[0].gauge = value;
 
-       vl.values = values;
-       vl.values_len = 1;
-       sstrncpy (vl.host, hostname_g, sizeof (vl.host));
-       sstrncpy (vl.plugin, "ping", sizeof (vl.plugin));
-       sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
-       sstrncpy (vl.type_instance, host, sizeof (vl.type_instance));
-       sstrncpy (vl.type, "ping", sizeof (vl.type));
+  vl.values = values;
+  vl.values_len = 1;
+  sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+  sstrncpy (vl.plugin, "ping", sizeof (vl.plugin));
+  sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
+  sstrncpy (vl.type_instance, host, sizeof (vl.type_instance));
+  sstrncpy (vl.type, type, sizeof (vl.type));
 
-       plugin_dispatch_values (&vl);
-}
+  plugin_dispatch_values (&vl);
+} /* }}} void ping_submit */
 
-static int ping_read (void)
+static int ping_read (void) /* {{{ */
 {
-       pingobj_iter_t *iter;
-
-       char   host[512];
-       double latency;
-       size_t buf_len;
-       int    number_of_hosts;
-
-       if (pingobj == NULL)
-               return (-1);
-
-       if (hosts != NULL)
-               add_hosts ();
-
-       if (ping_send (pingobj) < 0)
-       {
-               ERROR ("ping plugin: `ping_send' failed: %s",
-                               ping_get_error (pingobj));
-               return (-1);
-       }
-
-       number_of_hosts = 0;
-       for (iter = ping_iterator_get (pingobj);
-                       iter != NULL;
-                       iter = ping_iterator_next (iter))
-       {
-               buf_len = sizeof (host);
-               if (ping_iterator_get_info (iter, PING_INFO_HOSTNAME,
-                                       host, &buf_len))
-               {
-                       WARNING ("ping plugin: ping_iterator_get_info "
-                                       "(PING_INFO_HOSTNAME) failed.");
-                       continue;
-               }
-
-               buf_len = sizeof (latency);
-               if (ping_iterator_get_info (iter, PING_INFO_LATENCY,
-                                       &latency, &buf_len))
-               {
-                       WARNING ("ping plugin: ping_iterator_get_info (%s, "
-                                       "PING_INFO_LATENCY) failed.", host);
-                       continue;
-               }
-
-               DEBUG ("ping plugin: host = %s, latency = %f", host, latency);
-               ping_submit (host, latency);
-               number_of_hosts++;
-       }
-
-       if ((number_of_hosts == 0) && (getuid () != 0))
-       {
-               ERROR ("ping plugin: All hosts failed. Try starting collectd as root.");
-       }
-
-       return (number_of_hosts == 0 ? -1 : 0);
-} /* int ping_read */
+  hostlist_t *hl;
+
+  if (ping_thread_error != 0)
+  {
+    ERROR ("ping plugin: The ping thread had a problem. Restarting it.");
+
+    stop_thread ();
+
+    for (hl = hostlist_head; hl != NULL; hl = hl->next)
+    {
+      hl->pkg_sent = 0;
+      hl->pkg_recv = 0;
+      hl->latency_total = 0.0;
+      hl->latency_squared = 0.0;
+    }
+
+    start_thread ();
+
+    return (-1);
+  } /* if (ping_thread_error != 0) */
+
+  for (hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
+  {
+    uint32_t pkg_sent;
+    uint32_t pkg_recv;
+    double latency_total;
+    double latency_squared;
+
+    double latency_average;
+    double latency_stddev;
+
+    double droprate;
+
+    /* Locking here works, because the structure of the linked list is only
+     * changed during configure and shutdown. */
+    pthread_mutex_lock (&ping_lock);
+
+    pkg_sent = hl->pkg_sent;
+    pkg_recv = hl->pkg_recv;
+    latency_total = hl->latency_total;
+    latency_squared = hl->latency_squared;
+
+    hl->pkg_sent = 0;
+    hl->pkg_recv = 0;
+    hl->latency_total = 0.0;
+    hl->latency_squared = 0.0;
+
+    pthread_mutex_unlock (&ping_lock);
+
+    /* This e. g. happens when starting up. */
+    if (pkg_sent == 0)
+    {
+      DEBUG ("ping plugin: No packages for host %s have been sent.",
+          hl->host);
+      continue;
+    }
+
+    /* Calculate average. Beware of division by zero. */
+    if (pkg_recv == 0)
+      latency_average = NAN;
+    else
+      latency_average = latency_total / ((double) pkg_recv);
+
+    /* Calculate standard deviation. Beware even more of division by zero. */
+    if (pkg_recv == 0)
+      latency_stddev = NAN;
+    else if (pkg_recv == 1)
+      latency_stddev = 0.0;
+    else
+      latency_stddev = sqrt (((((double) pkg_recv) * latency_squared)
+          - (latency_total * latency_total))
+          / ((double) (pkg_recv * (pkg_recv - 1))));
+
+    /* Calculate drop rate. */
+    droprate = ((double) (pkg_sent - pkg_recv)) / ((double) pkg_sent);
+
+    submit (hl->host, "ping", latency_average);
+    submit (hl->host, "ping_stddev", latency_stddev);
+    submit (hl->host, "ping_droprate", droprate);
+  } /* }}} for (hl = hostlist_head; hl != NULL; hl = hl->next) */
+
+  return (0);
+} /* }}} int ping_read */
+
+static int ping_shutdown (void) /* {{{ */
+{
+  hostlist_t *hl;
+
+  INFO ("ping plugin: Shutting down thread.");
+  if (stop_thread () < 0)
+    return (-1);
+
+  hl = hostlist_head;
+  while (hl != NULL)
+  {
+    hostlist_t *hl_next;
+
+    hl_next = hl->next;
+
+    sfree (hl->host);
+    sfree (hl);
+
+    hl = hl_next;
+  }
+
+  return (0);
+} /* }}} int ping_shutdown */
 
 void module_register (void)
 {
-       plugin_register_config ("ping", ping_config,
-                       config_keys, config_keys_num);
-       plugin_register_init ("ping", ping_init);
-       plugin_register_read ("ping", ping_read);
+  plugin_register_config ("ping", ping_config,
+      config_keys, config_keys_num);
+  plugin_register_init ("ping", ping_init);
+  plugin_register_read ("ping", ping_read);
+  plugin_register_shutdown ("ping", ping_shutdown);
 } /* void module_register */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
index 74565c3..b120e7b 100644 (file)
@@ -34,6 +34,7 @@
 #include "configfile.h"
 #include "utils_avltree.h"
 #include "utils_llist.h"
+#include "utils_heap.h"
 #include "utils_cache.h"
 #include "utils_threshold.h"
 #include "filter_chain.h"
 /*
  * Private structures
  */
+struct callback_func_s
+{
+       void *cf_callback;
+       user_data_t cf_udata;
+};
+typedef struct callback_func_s callback_func_t;
+
+#define RF_SIMPLE  0
+#define RF_COMPLEX 1
 struct read_func_s
 {
-       int wait_time;
-       int wait_left;
-       int (*callback) (void);
-       enum { DONE = 0, TODO = 1, ACTIVE = 2 } needs_read;
+       /* `read_func_t' "inherits" from `callback_func_t'.
+        * The `rf_super' member MUST be the first one in this structure! */
+#define rf_callback rf_super.cf_callback
+#define rf_udata rf_super.cf_udata
+       callback_func_t rf_super;
+       char rf_name[DATA_MAX_NAME_LEN];
+       int rf_type;
+       struct timespec rf_interval;
+       struct timespec rf_effective_interval;
+       struct timespec rf_next_read;
 };
 typedef struct read_func_s read_func_t;
 
@@ -54,7 +70,6 @@ typedef struct read_func_s read_func_t;
  * Private variables
  */
 static llist_t *list_init;
-static llist_t *list_read;
 static llist_t *list_write;
 static llist_t *list_flush;
 static llist_t *list_shutdown;
@@ -68,6 +83,7 @@ static c_avl_tree_t *data_sets;
 
 static char *plugindir = NULL;
 
+static c_heap_t       *read_heap = NULL;
 static int             read_loop = 1;
 static pthread_mutex_t read_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t  read_cond = PTHREAD_COND_INITIALIZER;
@@ -85,26 +101,101 @@ static const char *plugin_get_dir (void)
                return (plugindir);
 }
 
-static int register_callback (llist_t **list, const char *name, void *callback)
+static void destroy_callback (callback_func_t *cf) /* {{{ */
+{
+       if (cf == NULL)
+               return;
+
+       if ((cf->cf_udata.data != NULL) && (cf->cf_udata.free_func != NULL))
+       {
+               cf->cf_udata.free_func (cf->cf_udata.data);
+               cf->cf_udata.data = NULL;
+               cf->cf_udata.free_func = NULL;
+       }
+       sfree (cf);
+} /* }}} void destroy_callback */
+
+static void destroy_all_callbacks (llist_t **list) /* {{{ */
+{
+       llentry_t *le;
+
+       if (*list == NULL)
+               return;
+
+       le = llist_head (*list);
+       while (le != NULL)
+       {
+               llentry_t *le_next;
+
+               le_next = le->next;
+
+               sfree (le->key);
+               destroy_callback (le->value);
+               le->value = NULL;
+
+               le = le_next;
+       }
+
+       llist_destroy (*list);
+       *list = NULL;
+} /* }}} void destroy_all_callbacks */
+
+static void destroy_read_heap (void) /* {{{ */
+{
+       if (read_heap == NULL)
+               return;
+
+       while (42)
+       {
+               callback_func_t *cf;
+
+               cf = c_head_get_root (read_heap);
+               if (cf == NULL)
+                       break;
+
+               destroy_callback (cf);
+       }
+
+       c_heap_destroy (read_heap);
+       read_heap = NULL;
+} /* }}} void destroy_read_heap */
+
+static int register_callback (llist_t **list, /* {{{ */
+               const char *name, callback_func_t *cf)
 {
        llentry_t *le;
        char *key;
 
-       if ((*list == NULL)
-                       && ((*list = llist_create ()) == NULL))
+       if (*list == NULL)
+       {
+               *list = llist_create ();
+               if (*list == NULL)
+               {
+                       ERROR ("plugin: create_register_callback: "
+                                       "llist_create failed.");
+                       destroy_callback (cf);
+                       return (-1);
+               }
+       }
+
+       key = strdup (name);
+       if (key == NULL)
+       {
+               ERROR ("plugin: create_register_callback: strdup failed.");
+               destroy_callback (cf);
                return (-1);
+       }
 
        le = llist_search (*list, name);
        if (le == NULL)
        {
-               key = strdup (name);
-               if (key == NULL)
-                       return (-1);
-
-               le = llentry_create (key, callback);
+               le = llentry_create (key, cf);
                if (le == NULL)
                {
+                       ERROR ("plugin: create_register_callback: "
+                                       "llentry_create failed.");
                        free (key);
+                       destroy_callback (cf);
                        return (-1);
                }
 
@@ -112,27 +203,65 @@ static int register_callback (llist_t **list, const char *name, void *callback)
        }
        else
        {
-               le->value = callback;
+               callback_func_t *old_cf;
+
+               old_cf = le->value;
+               le->value = cf;
+
+               destroy_callback (old_cf);
+               sfree (key);
        }
 
        return (0);
-} /* int register_callback */
+} /* }}} int register_callback */
 
-static int plugin_unregister (llist_t *list, const char *name)
+static int create_register_callback (llist_t **list, /* {{{ */
+               const char *name, void *callback, user_data_t *ud)
+{
+       callback_func_t *cf;
+
+       cf = (callback_func_t *) malloc (sizeof (*cf));
+       if (cf == NULL)
+       {
+               ERROR ("plugin: create_register_callback: malloc failed.");
+               return (-1);
+       }
+       memset (cf, 0, sizeof (*cf));
+
+       cf->cf_callback = callback;
+       if (ud == NULL)
+       {
+               cf->cf_udata.data = NULL;
+               cf->cf_udata.free_func = NULL;
+       }
+       else
+       {
+               cf->cf_udata = *ud;
+       }
+
+       return (register_callback (list, name, cf));
+} /* }}} int create_register_callback */
+
+static int plugin_unregister (llist_t *list, const char *name) /* {{{ */
 {
        llentry_t *e;
 
-       e = llist_search (list, name);
+       if (list == NULL)
+               return (-1);
 
+       e = llist_search (list, name);
        if (e == NULL)
                return (-1);
 
        llist_remove (list, e);
-       free (e->key);
+
+       sfree (e->key);
+       destroy_callback (e->value);
+
        llentry_destroy (e);
 
        return (0);
-} /* int plugin_unregister */
+} /* }}} int plugin_unregister */
 
 /*
  * (Try to) load the shared object `file'. Won't complain if it isn't a shared
@@ -173,78 +302,144 @@ static int plugin_load_file (char *file)
 
 static void *plugin_read_thread (void __attribute__((unused)) *args)
 {
-       llentry_t   *le;
-       read_func_t *rf;
-       int          status;
-       int          done;
-
-       pthread_mutex_lock (&read_lock);
-
        while (read_loop != 0)
        {
-               le = llist_head (list_read);
-               done = 0;
+               read_func_t *rf;
+               struct timeval now;
+               int status;
 
-               while ((read_loop != 0) && (le != NULL))
+               /* Get the read function that needs to be read next. */
+               rf = c_head_get_root (read_heap);
+               if (rf == NULL)
                {
-                       rf = (read_func_t *) le->value;
+                       struct timespec abstime;
 
-                       if (rf->needs_read != TODO)
-                       {
-                               le = le->next;
-                               continue;
-                       }
+                       gettimeofday (&now, /* timezone = */ NULL);
 
-                       /* We will do this read function */
-                       rf->needs_read = ACTIVE;
+                       abstime.tv_sec = now.tv_sec + interval_g;
+                       abstime.tv_nsec = 1000 * now.tv_usec;
 
-                       DEBUG ("[thread #%5lu] plugin: plugin_read_thread: Handling %s",
-                                       (unsigned long int) pthread_self (), le->key);
+                       pthread_mutex_lock (&read_lock);
+                       pthread_cond_timedwait (&read_cond, &read_lock,
+                                       &abstime);
                        pthread_mutex_unlock (&read_lock);
+                       continue;
+               }
 
-                       status = rf->callback ();
-                       done++;
+               if ((rf->rf_interval.tv_sec == 0) && (rf->rf_interval.tv_nsec == 0))
+               {
+                       gettimeofday (&now, /* timezone = */ NULL);
 
-                       if (status != 0)
-                       {
-                               if (rf->wait_time < interval_g)
-                                       rf->wait_time = interval_g;
-                               rf->wait_left = rf->wait_time;
-                               rf->wait_time = rf->wait_time * 2;
-                               if (rf->wait_time > 86400)
-                                       rf->wait_time = 86400;
-
-                               NOTICE ("read-function of plugin `%s' "
-                                               "failed. Will suspend it for %i "
-                                               "seconds.", le->key, rf->wait_left);
-                       }
-                       else
+                       rf->rf_interval.tv_sec = interval_g;
+                       rf->rf_interval.tv_nsec = 0;
+
+                       rf->rf_effective_interval = rf->rf_interval;
+
+                       rf->rf_next_read.tv_sec = now.tv_sec;
+                       rf->rf_next_read.tv_nsec = 1000 * now.tv_usec;
+               }
+
+               /* sleep until this entry is due,
+                * using pthread_cond_timedwait */
+               pthread_mutex_lock (&read_lock);
+               pthread_cond_timedwait (&read_cond, &read_lock,
+                               &rf->rf_next_read);
+               pthread_mutex_unlock (&read_lock);
+
+               /* Check if we're supposed to stop.. This may have interrupted
+                * the sleep, too. */
+               if (read_loop == 0)
+               {
+                       /* Insert `rf' again, so it can be free'd correctly */
+                       c_heap_insert (read_heap, rf);
+                       break;
+               }
+
+               DEBUG ("plugin_read_thread: Handling `%s'.", rf->rf_name);
+
+               if (rf->rf_type == RF_SIMPLE)
+               {
+                       int (*callback) (void);
+
+                       callback = rf->rf_callback;
+                       status = (*callback) ();
+               }
+               else
+               {
+                       plugin_read_cb callback;
+
+                       callback = rf->rf_callback;
+                       status = (*callback) (&rf->rf_udata);
+               }
+
+               /* If the function signals failure, we will increase the
+                * intervals in which it will be called. */
+               if (status != 0)
+               {
+                       rf->rf_effective_interval.tv_sec *= 2;
+                       rf->rf_effective_interval.tv_nsec *= 2;
+                       NORMALIZE_TIMESPEC (rf->rf_effective_interval);
+
+                       if (rf->rf_effective_interval.tv_sec >= 86400)
                        {
-                               rf->wait_left = 0;
-                               rf->wait_time = interval_g;
+                               rf->rf_effective_interval.tv_sec = 86400;
+                               rf->rf_effective_interval.tv_nsec = 0;
                        }
 
-                       pthread_mutex_lock (&read_lock);
-
-                       rf->needs_read = DONE;
-                       le = le->next;
-               } /* while (le != NULL) */
+                       NOTICE ("read-function of plugin `%s' failed. "
+                                       "Will suspend it for %i seconds.",
+                                       rf->rf_name,
+                                       (int) rf->rf_effective_interval.tv_sec);
+               }
+               else
+               {
+                       /* Success: Restore the interval, if it was changed. */
+                       rf->rf_effective_interval = rf->rf_interval;
+               }
 
-               if ((read_loop != 0) && (done == 0))
+               /* update the ``next read due'' field */
+               gettimeofday (&now, /* timezone = */ NULL);
+
+               DEBUG ("plugin_read_thread: Effective interval of the "
+                               "%s plugin is %i.%09i.",
+                               rf->rf_name,
+                               (int) rf->rf_effective_interval.tv_sec,
+                               (int) rf->rf_effective_interval.tv_nsec);
+
+               /* Calculate the next (absolute) time at which this function
+                * should be called. */
+               rf->rf_next_read.tv_sec = rf->rf_next_read.tv_sec
+                       + rf->rf_effective_interval.tv_sec;
+               rf->rf_next_read.tv_nsec = rf->rf_next_read.tv_nsec
+                       + rf->rf_effective_interval.tv_nsec;
+               NORMALIZE_TIMESPEC (rf->rf_next_read);
+
+               /* Check, if `rf_next_read' is in the past. */
+               if ((rf->rf_next_read.tv_sec < now.tv_sec)
+                               || ((rf->rf_next_read.tv_sec == now.tv_sec)
+                                       && (rf->rf_next_read.tv_nsec < (1000 * now.tv_usec))))
                {
-                       DEBUG ("[thread #%5lu] plugin: plugin_read_thread: Waiting on read_cond.",
-                                       (unsigned long int) pthread_self ());
-                       pthread_cond_wait (&read_cond, &read_lock);
+                       /* `rf_next_read' is in the past. Insert `now'
+                        * so this value doesn't trail off into the
+                        * past too much. */
+                       rf->rf_next_read.tv_sec = now.tv_sec;
+                       rf->rf_next_read.tv_nsec = 1000 * now.tv_usec;
                }
-       } /* while (read_loop) */
 
-       pthread_mutex_unlock (&read_lock);
+               DEBUG ("plugin_read_thread: Next read of the %s plugin at %i.%09i.",
+                               rf->rf_name,
+                               (int) rf->rf_next_read.tv_sec,
+                               (int) rf->rf_next_read.tv_nsec);
+
+               /* Re-insert this read function into the heap again. */
+               c_heap_insert (read_heap, rf);
+       } /* while (read_loop) */
 
        pthread_exit (NULL);
        return ((void *) 0);
 } /* void *plugin_read_thread */
 
-static void start_threads (int num)
+static void start_read_threads (int num)
 {
        int i;
 
@@ -254,7 +449,7 @@ static void start_threads (int num)
        read_threads = (pthread_t *) calloc (num, sizeof (pthread_t));
        if (read_threads == NULL)
        {
-               ERROR ("plugin: start_threads: calloc failed.");
+               ERROR ("plugin: start_read_threads: calloc failed.");
                return;
        }
 
@@ -268,22 +463,24 @@ static void start_threads (int num)
                }
                else
                {
-                       ERROR ("plugin: start_threads: pthread_create failed.");
+                       ERROR ("plugin: start_read_threads: pthread_create failed.");
                        return;
                }
        } /* for (i) */
-} /* void start_threads */
+} /* void start_read_threads */
 
-static void stop_threads (void)
+static void stop_read_threads (void)
 {
        int i;
 
        if (read_threads == NULL)
                return;
 
+       INFO ("collectd: Stopping %i read threads.", read_threads_num);
+
        pthread_mutex_lock (&read_lock);
        read_loop = 0;
-       DEBUG ("plugin: stop_threads: Signalling `read_cond'");
+       DEBUG ("plugin: stop_read_threads: Signalling `read_cond'");
        pthread_cond_broadcast (&read_cond);
        pthread_mutex_unlock (&read_lock);
 
@@ -291,13 +488,13 @@ static void stop_threads (void)
        {
                if (pthread_join (read_threads[i], NULL) != 0)
                {
-                       ERROR ("plugin: stop_threads: pthread_join failed.");
+                       ERROR ("plugin: stop_read_threads: pthread_join failed.");
                }
                read_threads[i] = (pthread_t) 0;
        }
        sfree (read_threads);
        read_threads_num = 0;
-} /* void stop_threads */
+} /* void stop_read_threads */
 
 /*
  * Public functions
@@ -420,14 +617,46 @@ int plugin_register_complex_config (const char *type,
 int plugin_register_init (const char *name,
                int (*callback) (void))
 {
-       return (register_callback (&list_init, name, (void *) callback));
+       return (create_register_callback (&list_init, name, (void *) callback,
+                               /* user_data = */ NULL));
 } /* plugin_register_init */
 
+static int plugin_compare_read_func (const void *arg0, const void *arg1)
+{
+       const read_func_t *rf0;
+       const read_func_t *rf1;
+
+       rf0 = arg0;
+       rf1 = arg1;
+
+       if (rf0->rf_next_read.tv_sec < rf1->rf_next_read.tv_sec)
+               return (-1);
+       else if (rf0->rf_next_read.tv_sec > rf1->rf_next_read.tv_sec)
+               return (1);
+       else if (rf0->rf_next_read.tv_nsec < rf1->rf_next_read.tv_nsec)
+               return (-1);
+       else if (rf0->rf_next_read.tv_nsec > rf1->rf_next_read.tv_nsec)
+               return (1);
+       else
+               return (0);
+} /* int plugin_compare_read_func */
+
 int plugin_register_read (const char *name,
                int (*callback) (void))
 {
        read_func_t *rf;
 
+       if (read_heap == NULL)
+       {
+               read_heap = c_heap_create (plugin_compare_read_func);
+               if (read_heap == NULL)
+               {
+                       ERROR ("plugin_register_read: "
+                                       "c_heap_create failed.");
+                       return (-1);
+               }
+       }
+
        rf = (read_func_t *) malloc (sizeof (read_func_t));
        if (rf == NULL)
        {
@@ -437,31 +666,86 @@ int plugin_register_read (const char *name,
                return (-1);
        }
 
-       memset (rf, '\0', sizeof (read_func_t));
-       rf->wait_time = interval_g;
-       rf->wait_left = 0;
-       rf->callback = callback;
-       rf->needs_read = DONE;
-
-       return (register_callback (&list_read, name, (void *) rf));
+       memset (rf, 0, sizeof (read_func_t));
+       rf->rf_callback = (void *) callback;
+       rf->rf_udata.data = NULL;
+       rf->rf_udata.free_func = NULL;
+       sstrncpy (rf->rf_name, name, sizeof (rf->rf_name));
+       rf->rf_type = RF_SIMPLE;
+       rf->rf_interval.tv_sec = 0;
+       rf->rf_interval.tv_nsec = 0;
+       rf->rf_effective_interval = rf->rf_interval;
+
+       return (c_heap_insert (read_heap, rf));
 } /* int plugin_register_read */
 
+int plugin_register_complex_read (const char *name,
+               plugin_read_cb callback,
+               const struct timespec *interval,
+               user_data_t *user_data)
+{
+       read_func_t *rf;
+
+       if (read_heap == NULL)
+       {
+               read_heap = c_heap_create (plugin_compare_read_func);
+               if (read_heap == NULL)
+               {
+                       ERROR ("plugin_register_read: c_heap_create failed.");
+                       return (-1);
+               }
+       }
+
+       rf = (read_func_t *) malloc (sizeof (read_func_t));
+       if (rf == NULL)
+       {
+               ERROR ("plugin_register_complex_read: malloc failed.");
+               return (-1);
+       }
+
+       memset (rf, 0, sizeof (read_func_t));
+       rf->rf_callback = (void *) callback;
+       sstrncpy (rf->rf_name, name, sizeof (rf->rf_name));
+       rf->rf_type = RF_COMPLEX;
+       if (interval != NULL)
+       {
+               rf->rf_interval = *interval;
+       }
+       rf->rf_effective_interval = rf->rf_interval;
+
+       /* Set user data */
+       if (user_data == NULL)
+       {
+               rf->rf_udata.data = NULL;
+               rf->rf_udata.free_func = NULL;
+       }
+       else
+       {
+               rf->rf_udata = *user_data;
+       }
+
+       return (c_heap_insert (read_heap, rf));
+} /* int plugin_register_complex_read */
+
 int plugin_register_write (const char *name,
-               int (*callback) (const data_set_t *ds, const value_list_t *vl))
+               plugin_write_cb callback, user_data_t *ud)
 {
-       return (register_callback (&list_write, name, (void *) callback));
+       return (create_register_callback (&list_write, name,
+                               (void *) callback, ud));
 } /* int plugin_register_write */
 
 int plugin_register_flush (const char *name,
-               int (*callback) (const int timeout, const char *identifier))
+               plugin_flush_cb callback, user_data_t *ud)
 {
-       return (register_callback (&list_flush, name, (void *) callback));
+       return (create_register_callback (&list_flush, name,
+                               (void *) callback, ud));
 } /* int plugin_register_flush */
 
 int plugin_register_shutdown (char *name,
                int (*callback) (void))
 {
-       return (register_callback (&list_shutdown, name, (void *) callback));
+       return (create_register_callback (&list_shutdown, name,
+                               (void *) callback, /* user_data = */ NULL));
 } /* int plugin_register_shutdown */
 
 int plugin_register_data_set (const data_set_t *ds)
@@ -501,16 +785,18 @@ int plugin_register_data_set (const data_set_t *ds)
        return (c_avl_insert (data_sets, (void *) ds_copy->type, (void *) ds_copy));
 } /* int plugin_register_data_set */
 
-int plugin_register_log (char *name,
-               void (*callback) (int priority, const char *msg))
+int plugin_register_log (const char *name,
+               plugin_log_cb callback, user_data_t *ud)
 {
-       return (register_callback (&list_log, name, (void *) callback));
+       return (create_register_callback (&list_log, name,
+                               (void *) callback, ud));
 } /* int plugin_register_log */
 
 int plugin_register_notification (const char *name,
-               int (*callback) (const notification_t *notif))
+               plugin_notification_cb callback, user_data_t *ud)
 {
-       return (register_callback (&list_notification, name, (void *) callback));
+       return (create_register_callback (&list_notification, name,
+                               (void *) callback, ud));
 } /* int plugin_register_log */
 
 int plugin_unregister_config (const char *name)
@@ -532,19 +818,9 @@ int plugin_unregister_init (const char *name)
 
 int plugin_unregister_read (const char *name)
 {
-       llentry_t *e;
-
-       e = llist_search (list_read, name);
-
-       if (e == NULL)
-               return (-1);
-
-       llist_remove (list_read, e);
-       free (e->value);
-       free (e->key);
-       llentry_destroy (e);
-
-       return (0);
+       /* TODO: Implement removal of a specific key from the heap. */
+       assert (0);
+       return (-1);
 }
 
 int plugin_unregister_write (const char *name)
@@ -591,7 +867,6 @@ int plugin_unregister_notification (const char *name)
 void plugin_init_all (void)
 {
        const char *chain_name;
-       int (*callback) (void);
        llentry_t *le;
        int status;
 
@@ -605,7 +880,7 @@ void plugin_init_all (void)
        post_cache_chain = fc_chain_get_by_name (chain_name);
 
 
-       if ((list_init == NULL) && (list_read == NULL))
+       if ((list_init == NULL) && (read_heap == NULL))
                return;
 
        /* Calling all init callbacks before checking if read callbacks
@@ -614,7 +889,11 @@ void plugin_init_all (void)
        le = llist_head (list_init);
        while (le != NULL)
        {
-               callback = (int (*) (void)) le->value;
+               callback_func_t *cf;
+               plugin_init_cb callback;
+
+               cf = le->value;
+               callback = cf->cf_callback;
                status = (*callback) ();
 
                if (status != 0)
@@ -634,82 +913,68 @@ void plugin_init_all (void)
        }
 
        /* Start read-threads */
-       if (list_read != NULL)
+       if (read_heap != NULL)
        {
                const char *rt;
                int num;
                rt = global_option_get ("ReadThreads");
                num = atoi (rt);
                if (num != -1)
-                       start_threads ((num > 0) ? num : 5);
+                       start_read_threads ((num > 0) ? num : 5);
        }
 } /* void plugin_init_all */
 
+/* TODO: Rename this function. */
 void plugin_read_all (void)
 {
-       llentry_t   *le;
-       read_func_t *rf;
-
        uc_check_timeout ();
 
-       if (list_read == NULL)
-               return;
-
-       pthread_mutex_lock (&read_lock);
-
-       le = llist_head (list_read);
-       while (le != NULL)
-       {
-               rf = (read_func_t *) le->value;
-
-               if (rf->needs_read != DONE)
-               {
-                       le = le->next;
-                       continue;
-               }
-
-               if (rf->wait_left > 0)
-                       rf->wait_left -= interval_g;
-
-               if (rf->wait_left <= 0)
-               {
-                       rf->needs_read = TODO;
-               }
-
-               le = le->next;
-       }
-
-       DEBUG ("plugin: plugin_read_all: Signalling `read_cond'");
-       pthread_cond_broadcast (&read_cond);
-       pthread_mutex_unlock (&read_lock);
+       return;
 } /* void plugin_read_all */
 
 /* Read function called when the `-T' command line argument is given. */
 int plugin_read_all_once (void)
 {
-       llentry_t   *le;
-       read_func_t *rf;
        int status;
        int return_status = 0;
 
-       if (list_read == NULL)
+       if (read_heap == NULL)
        {
                NOTICE ("No read-functions are registered.");
                return (0);
        }
 
-       for (le = llist_head (list_read);
-            le != NULL;
-            le = le->next)
+       while (42)
        {
-               rf = (read_func_t *) le->value;
-               status = rf->callback ();
+               read_func_t *rf;
+
+               rf = c_head_get_root (read_heap);
+               if (rf == NULL)
+                       break;
+
+               if (rf->rf_type == RF_SIMPLE)
+               {
+                       int (*callback) (void);
+
+                       callback = rf->rf_callback;
+                       status = (*callback) ();
+               }
+               else
+               {
+                       plugin_read_cb callback;
+
+                       callback = rf->rf_callback;
+                       status = (*callback) (&rf->rf_udata);
+               }
+
                if (status != 0)
                {
                        NOTICE ("read-function of plugin `%s' failed.",
-                               le->key);
+                                       rf->rf_name);
                        return_status = -1;
                }
+
+               destroy_callback ((void *) rf);
        }
 
        return (return_status);
@@ -718,7 +983,6 @@ int plugin_read_all_once (void)
 int plugin_write (const char *plugin, /* {{{ */
                const data_set_t *ds, const value_list_t *vl)
 {
-  int (*callback) (const data_set_t *ds, const value_list_t *vl);
   llentry_t *le;
   int status;
 
@@ -746,8 +1010,12 @@ int plugin_write (const char *plugin, /* {{{ */
     le = llist_head (list_write);
     while (le != NULL)
     {
-      callback = le->value;
-      status = (*callback) (ds, vl);
+      callback_func_t *cf = le->value;
+      plugin_write_cb callback;
+
+      DEBUG ("plugin: plugin_write: Writing values via %s.", le->key);
+      callback = cf->cf_callback;
+      status = (*callback) (ds, vl, &cf->cf_udata);
       if (status != 0)
         failure++;
       else
@@ -763,6 +1031,9 @@ int plugin_write (const char *plugin, /* {{{ */
   }
   else /* plugin != NULL */
   {
+    callback_func_t *cf;
+    plugin_write_cb callback;
+
     le = llist_head (list_write);
     while (le != NULL)
     {
@@ -775,8 +1046,11 @@ int plugin_write (const char *plugin, /* {{{ */
     if (le == NULL)
       return (ENOENT);
 
-    callback = le->value;
-    status = (*callback) (ds, vl);
+    cf = le->value;
+
+    DEBUG ("plugin: plugin_write: Writing values via %s.", le->key);
+    callback = cf->cf_callback;
+    status = (*callback) (ds, vl, &cf->cf_udata);
   }
 
   return (status);
@@ -784,7 +1058,6 @@ int plugin_write (const char *plugin, /* {{{ */
 
 int plugin_flush (const char *plugin, int timeout, const char *identifier)
 {
-  int (*callback) (int timeout, const char *identifier);
   llentry_t *le;
 
   if (list_flush == NULL)
@@ -793,6 +1066,9 @@ int plugin_flush (const char *plugin, int timeout, const char *identifier)
   le = llist_head (list_flush);
   while (le != NULL)
   {
+    callback_func_t *cf;
+    plugin_flush_cb callback;
+
     if ((plugin != NULL)
         && (strcmp (plugin, le->key) != 0))
     {
@@ -800,8 +1076,10 @@ int plugin_flush (const char *plugin, int timeout, const char *identifier)
       continue;
     }
 
-    callback = (int (*) (int, const char *)) le->value;
-    (*callback) (timeout, identifier);
+    cf = le->value;
+    callback = cf->cf_callback;
+
+    (*callback) (timeout, identifier, &cf->cf_udata);
 
     le = le->next;
   }
@@ -810,18 +1088,27 @@ int plugin_flush (const char *plugin, int timeout, const char *identifier)
 
 void plugin_shutdown_all (void)
 {
-       int (*callback) (void);
        llentry_t *le;
 
-       stop_threads ();
+       stop_read_threads ();
 
-       if (list_shutdown == NULL)
-               return;
+       destroy_all_callbacks (&list_init);
+       destroy_read_heap ();
+
+       plugin_flush (/* plugin = */ NULL, /* timeout = */ -1,
+                       /* identifier = */ NULL);
+
+       le = NULL;
+       if (list_shutdown != NULL)
+               le = llist_head (list_shutdown);
 
-       le = llist_head (list_shutdown);
        while (le != NULL)
        {
-               callback = (int (*) (void)) le->value;
+               callback_func_t *cf;
+               plugin_shutdown_cb callback;
+
+               cf = le->value;
+               callback = cf->cf_callback;
 
                /* Advance the pointer before calling the callback allows
                 * shutdown functions to unregister themselves. If done the
@@ -831,6 +1118,12 @@ void plugin_shutdown_all (void)
 
                (*callback) ();
        }
+
+       destroy_all_callbacks (&list_write);
+       destroy_all_callbacks (&list_flush);
+       destroy_all_callbacks (&list_notification);
+       destroy_all_callbacks (&list_shutdown);
+       destroy_all_callbacks (&list_log);
 } /* void plugin_shutdown_all */
 
 int plugin_dispatch_values (value_list_t *vl)
@@ -873,6 +1166,9 @@ int plugin_dispatch_values (value_list_t *vl)
        if (vl->time == 0)
                vl->time = time (NULL);
 
+       if (vl->interval <= 0)
+               vl->interval = interval_g;
+
        DEBUG ("plugin_dispatch_values: time = %u; interval = %i; "
                        "host = %s; "
                        "plugin = %s; plugin_instance = %s; "
@@ -989,7 +1285,6 @@ int plugin_dispatch_values (value_list_t *vl)
 
 int plugin_dispatch_notification (const notification_t *notif)
 {
-       int (*callback) (const notification_t *);
        llentry_t *le;
        /* Possible TODO: Add flap detection here */
 
@@ -1005,8 +1300,19 @@ int plugin_dispatch_notification (const notification_t *notif)
        le = llist_head (list_notification);
        while (le != NULL)
        {
-               callback = (int (*) (const notification_t *)) le->value;
-               (*callback) (notif);
+               callback_func_t *cf;
+               plugin_notification_cb callback;
+               int status;
+
+               cf = le->value;
+               callback = cf->cf_callback;
+               status = (*callback) (notif, &cf->cf_udata);
+               if (status != 0)
+               {
+                       WARNING ("plugin_dispatch_notification: Notification "
+                                       "callback %s returned %i.",
+                                       le->key, status);
+               }
 
                le = le->next;
        }
@@ -1018,8 +1324,6 @@ void plugin_log (int level, const char *format, ...)
 {
        char msg[1024];
        va_list ap;
-
-       void (*callback) (int, const char *);
        llentry_t *le;
 
        if (list_log == NULL)
@@ -1038,8 +1342,13 @@ void plugin_log (int level, const char *format, ...)
        le = llist_head (list_log);
        while (le != NULL)
        {
-               callback = (void (*) (int, const char *)) le->value;
-               (*callback) (level, msg);
+               callback_func_t *cf;
+               plugin_log_cb callback;
+
+               cf = le->value;
+               callback = cf->cf_callback;
+
+               (*callback) (level, msg, &cf->cf_udata);
 
                le = le->next;
        }
@@ -1232,3 +1541,5 @@ int plugin_notification_meta_free (notification_meta_t *n)
 
   return (0);
 } /* int plugin_notification_meta_free */
+
+/* vim: set sw=8 ts=8 noet fdm=marker : */
index 3088e06..e54b27d 100644 (file)
@@ -136,6 +136,28 @@ typedef struct notification_s
        notification_meta_t *meta;
 } notification_t;
 
+struct user_data_s
+{
+       void *data;
+       void (*free_func) (void *);
+};
+typedef struct user_data_s user_data_t;
+
+/*
+ * Callback types
+ */
+typedef int (*plugin_init_cb) (void);
+typedef int (*plugin_read_cb) (user_data_t *);
+typedef int (*plugin_write_cb) (const data_set_t *, const value_list_t *,
+               user_data_t *);
+typedef int (*plugin_flush_cb) (int timeout, const char *identifier,
+               user_data_t *);
+typedef void (*plugin_log_cb) (int severity, const char *message,
+               user_data_t *);
+typedef int (*plugin_shutdown_cb) (void);
+typedef int (*plugin_notification_cb) (const notification_t *,
+               user_data_t *);
+
 /*
  * NAME
  *  plugin_set_dir
@@ -222,25 +244,30 @@ int plugin_register_config (const char *name,
 int plugin_register_complex_config (const char *type,
                int (*callback) (oconfig_item_t *));
 int plugin_register_init (const char *name,
-               int (*callback) (void));
+               plugin_init_cb callback);
 int plugin_register_read (const char *name,
                int (*callback) (void));
+int plugin_register_complex_read (const char *name,
+               plugin_read_cb callback,
+               const struct timespec *interval,
+               user_data_t *user_data);
 int plugin_register_write (const char *name,
-               int (*callback) (const data_set_t *ds, const value_list_t *vl));
+               plugin_write_cb callback, user_data_t *user_data);
 int plugin_register_flush (const char *name,
-               int (*callback) (const int timeout, const char *identifier));
+               plugin_flush_cb callback, user_data_t *user_data);
 int plugin_register_shutdown (char *name,
-               int (*callback) (void));
+               plugin_shutdown_cb callback);
 int plugin_register_data_set (const data_set_t *ds);
-int plugin_register_log (char *name,
-               void (*callback) (int, const char *));
+int plugin_register_log (const char *name,
+               plugin_log_cb callback, user_data_t *user_data);
 int plugin_register_notification (const char *name,
-               int (*callback) (const notification_t *notif));
+               plugin_notification_cb callback, user_data_t *user_data);
 
 int plugin_unregister_config (const char *name);
 int plugin_unregister_complex_config (const char *name);
 int plugin_unregister_init (const char *name);
 int plugin_unregister_read (const char *name);
+int plugin_unregister_complex_read (const char *name, void **user_data);
 int plugin_unregister_write (const char *name);
 int plugin_unregister_flush (const char *name);
 int plugin_unregister_shutdown (const char *name);
index 164137b..beb49fb 100644 (file)
@@ -289,30 +289,11 @@ static void submit (const char *plugin_instance, /* {{{ */
     return;
   }
 
-  if (ds->ds[0].type == DS_TYPE_GAUGE)
+  if (0 != parse_value (value, &values[0], ds->ds[0]))
   {
-    char *endptr = NULL;
-
-    values[0].gauge = strtod (value, &endptr);
-
-    if (endptr == value)
-    {
-      ERROR ("powerdns plugin: Cannot convert `%s' "
-          "to a floating point number.", value);
-      return;
-    }
-  }
-  else
-  {
-    char *endptr = NULL;
-
-    values[0].counter = strtoll (value, &endptr, 0);
-    if (endptr == value)
-    {
-      ERROR ("powerdns plugin: Cannot convert `%s' "
-          "to an integer number.", value);
-      return;
-    }
+    ERROR ("powerdns plugin: Cannot convert `%s' "
+        "to a number.", value);
+    return;
   }
 
   vl.values = values;
diff --git a/src/protocols.c b/src/protocols.c
new file mode 100644 (file)
index 0000000..75e9a1c
--- /dev/null
@@ -0,0 +1,248 @@
+/**
+ * collectd - src/protocols.c
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "utils_ignorelist.h"
+
+#if !KERNEL_LINUX
+# error "No applicable input method."
+#endif
+
+#define SNMP_FILE "/proc/net/snmp"
+#define NETSTAT_FILE "/proc/net/netstat"
+
+/*
+ * Global variables
+ */
+static const char *config_keys[] =
+{
+  "Value",
+  "IgnoreSelected",
+};
+static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
+
+static ignorelist_t *values_list = NULL;
+
+/* 
+ * Functions
+ */
+static void submit (const char *protocol_name,
+    const char *str_key, const char *str_value)
+{
+  value_t values[1];
+  value_list_t vl = VALUE_LIST_INIT;
+
+  char *tmp_ptr;
+
+  errno = 0;
+  tmp_ptr = NULL;
+  values[0].counter = (counter_t) strtoll (str_value, &tmp_ptr,
+      /* base = */ 0);
+  if ((errno != 0) || (tmp_ptr == str_value))
+  {
+    ERROR ("protocols plugin: Parsing string as integer failed: %s",
+        str_value);
+    return;
+  }
+
+  vl.values = values;
+  vl.values_len = 1;
+  sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+  sstrncpy (vl.plugin, "protocols", sizeof (vl.plugin));
+  sstrncpy (vl.plugin_instance, protocol_name, sizeof (vl.plugin_instance));
+  sstrncpy (vl.type, "protocol_counter", sizeof (vl.type));
+  sstrncpy (vl.type_instance, str_key, sizeof (vl.type_instance));
+
+  plugin_dispatch_values (&vl);
+} /* void submit */
+
+static int read_file (const char *path)
+{
+  FILE *fh;
+  char key_buffer[4096];
+  char value_buffer[4096];
+  char *key_ptr;
+  char *value_ptr;
+  char *key_fields[256];
+  char *value_fields[256];
+  int key_fields_num;
+  int value_fields_num;
+  int status;
+  int i;
+
+  fh = fopen (path, "r");
+  if (fh == NULL)
+  {
+    ERROR ("protocols plugin: fopen (%s) failed: %s.",
+        path, sstrerror (errno, key_buffer, sizeof (key_buffer)));
+    return (-1);
+  }
+
+  status = -1;
+  while (42)
+  {
+    clearerr (fh);
+    key_ptr = fgets (key_buffer, sizeof (key_buffer), fh);
+    if (key_ptr == NULL)
+    {
+      if (feof (fh) != 0)
+      {
+        status = 0;
+        break;
+      }
+      else if (ferror (fh) != 0)
+      {
+        ERROR ("protocols plugin: Reading from %s failed.", path);
+        break;
+      }
+      else
+      {
+        ERROR ("protocols plugin: fgets failed for an unknown reason.");
+        break;
+      }
+    } /* if (key_ptr == NULL) */
+
+    value_ptr = fgets (value_buffer, sizeof (value_buffer), fh);
+    if (value_ptr == NULL)
+    {
+      ERROR ("protocols plugin: read_file (%s): Could not read values line.",
+          path);
+      break;
+    }
+
+    key_ptr = strchr (key_buffer, ':');
+    if (key_ptr == NULL)
+    {
+      ERROR ("protocols plugin: Could not find protocol name in keys line.");
+      break;
+    }
+    *key_ptr = 0;
+    key_ptr++;
+
+    value_ptr = strchr (value_buffer, ':');
+    if (value_ptr == NULL)
+    {
+      ERROR ("protocols plugin: Could not find protocol name "
+          "in values line.");
+      break;
+    }
+    *value_ptr = 0;
+    value_ptr++;
+
+    if (strcmp (key_buffer, value_buffer) != 0)
+    {
+      ERROR ("protocols plugin: Protocol names in keys and values lines "
+          "don't match: `%s' vs. `%s'.",
+          key_buffer, value_buffer);
+      break;
+    }
+
+
+    key_fields_num = strsplit (key_ptr,
+        key_fields, STATIC_ARRAY_SIZE (key_fields));
+    value_fields_num = strsplit (value_ptr,
+        value_fields, STATIC_ARRAY_SIZE (value_fields));
+
+    if (key_fields_num != value_fields_num)
+    {
+      ERROR ("protocols plugin: Number of fields in keys and values lines "
+          "dont match: %i vs %i.",
+          key_fields_num, value_fields_num);
+      break;
+    }
+
+    for (i = 0; i < key_fields_num; i++)
+    {
+      if (values_list != NULL)
+      {
+        char match_name[2 * DATA_MAX_NAME_LEN];
+
+        ssnprintf (match_name, sizeof (match_name), "%s:%s",
+            key_buffer, key_fields[i]);
+
+        if (ignorelist_match (values_list, match_name))
+          continue;
+      } /* if (values_list != NULL) */
+
+      submit (key_buffer, key_fields[i], value_fields[i]);
+    } /* for (i = 0; i < key_fields_num; i++) */
+  } /* while (42) */
+
+  fclose (fh);
+
+  return (status);
+} /* int read_file */
+
+static int protocols_read (void)
+{
+  int status;
+  int success = 0;
+
+  status = read_file (SNMP_FILE);
+  if (status == 0)
+    success++;
+
+  status = read_file (NETSTAT_FILE);
+  if (status == 0)
+    success++;
+
+  if (success == 0)
+    return (-1);
+
+  return (0);
+} /* int protocols_read */
+
+static int protocols_config (const char *key, const char *value)
+{
+  if (values_list == NULL)
+    values_list = ignorelist_create (/* invert = */ 1);
+
+  if (strcasecmp (key, "Value") == 0)
+  {
+    ignorelist_add (values_list, value);
+  }
+  else if (strcasecmp (key, "IgnoreSelected") == 0)
+  {
+    int invert = 1;
+    if ((strcasecmp (value, "True") == 0)
+        || (strcasecmp (value, "Yes") == 0)
+        || (strcasecmp (value, "On") == 0))
+      invert = 0;
+    ignorelist_set_invert (values_list, invert);
+  }
+  else
+  {
+    return (-1);
+  }
+
+  return (0);
+} /* int protocols_config */
+
+void module_register (void)
+{
+  plugin_register_config ("protocols", protocols_config,
+      config_keys, config_keys_num);
+  plugin_register_read ("protocols", protocols_read);
+} /* void module_register */
+
+/* vim: set sw=2 sts=2 et : */
index 31c6352..326a889 100644 (file)
@@ -314,7 +314,8 @@ static int rc_init (void)
   return (0);
 } /* int rc_init */
 
-static int rc_write (const data_set_t *ds, const value_list_t *vl)
+static int rc_write (const data_set_t *ds, const value_list_t *vl,
+    user_data_t __attribute__((unused)) *user_data)
 {
   char filename[512];
   char values[512];
@@ -405,7 +406,7 @@ void module_register (void)
   plugin_register_config ("rrdcached", rc_config,
       config_keys, config_keys_num);
   plugin_register_init ("rrdcached", rc_init);
-  plugin_register_write ("rrdcached", rc_write);
+  plugin_register_write ("rrdcached", rc_write, /* user_data = */ NULL);
   plugin_register_shutdown ("rrdcached", rc_shutdown);
 } /* void module_register */
 
index b80e110..19f351a 100644 (file)
@@ -111,7 +111,8 @@ static rrd_queue_t    *queue_head = NULL;
 static rrd_queue_t    *queue_tail = NULL;
 static rrd_queue_t    *flushq_head = NULL;
 static rrd_queue_t    *flushq_tail = NULL;
-static pthread_t       queue_thread = 0;
+static pthread_t       queue_thread;
+static int             queue_thread_running = 1;
 static pthread_mutex_t queue_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t  queue_cond = PTHREAD_COND_INITIALIZER;
 
@@ -400,8 +401,9 @@ static void *rrd_queue_thread (void __attribute__((unused)) *data)
                /* Write the values to the RRD-file */
                srrd_update (queue_entry->filename, NULL,
                                values_num, (const char **)values);
-               DEBUG ("rrdtool plugin: queue thread: Wrote %i values to %s",
-                               values_num, queue_entry->filename);
+               DEBUG ("rrdtool plugin: queue thread: Wrote %i value%s to %s",
+                               values_num, (values_num == 1) ? "" : "s",
+                               queue_entry->filename);
 
                for (i = 0; i < values_num; i++)
                {
@@ -766,7 +768,8 @@ static int rrd_compare_numeric (const void *a_ptr, const void *b_ptr)
                return (0);
 } /* int rrd_compare_numeric */
 
-static int rrd_write (const data_set_t *ds, const value_list_t *vl)
+static int rrd_write (const data_set_t *ds, const value_list_t *vl,
+               user_data_t __attribute__((unused)) *user_data)
 {
        struct stat  statbuf;
        char         filename[512];
@@ -814,7 +817,8 @@ static int rrd_write (const data_set_t *ds, const value_list_t *vl)
        return (status);
 } /* int rrd_write */
 
-static int rrd_flush (int timeout, const char *identifier)
+static int rrd_flush (int timeout, const char *identifier,
+               user_data_t __attribute__((unused)) *user_data)
 {
        pthread_mutex_lock (&cache_lock);
 
@@ -991,14 +995,28 @@ static int rrd_shutdown (void)
        pthread_cond_signal (&queue_cond);
        pthread_mutex_unlock (&queue_lock);
 
+       if ((queue_thread_running != 0)
+                       && ((queue_head != NULL) || (flushq_head != NULL)))
+       {
+               INFO ("rrdtool plugin: Shutting down the queue thread. "
+                               "This may take a while.");
+       }
+       else if (queue_thread_running != 0)
+       {
+               INFO ("rrdtool plugin: Shutting down the queue thread.");
+       }
+
        /* Wait for all the values to be written to disk before returning. */
-       if (queue_thread != 0)
+       if (queue_thread_running != 0)
        {
                pthread_join (queue_thread, NULL);
-               queue_thread = 0;
+               memset (&queue_thread, 0, sizeof (queue_thread));
+               queue_thread_running = 0;
                DEBUG ("rrdtool plugin: queue_thread exited.");
        }
 
+       /* TODO: Maybe it'd be a good idea to free the cache here.. */
+
        return (0);
 } /* int rrd_shutdown */
 
@@ -1043,12 +1061,14 @@ static int rrd_init (void)
 
        pthread_mutex_unlock (&cache_lock);
 
-       status = pthread_create (&queue_thread, NULL, rrd_queue_thread, NULL);
+       status = pthread_create (&queue_thread, /* attr = */ NULL,
+                       rrd_queue_thread, /* args = */ NULL);
        if (status != 0)
        {
                ERROR ("rrdtool plugin: Cannot create queue-thread.");
                return (-1);
        }
+       queue_thread_running = 1;
 
        DEBUG ("rrdtool plugin: rrd_init: datadir = %s; stepsize = %i;"
                        " heartbeat = %i; rrarows = %i; xff = %lf;",
@@ -1066,7 +1086,7 @@ void module_register (void)
        plugin_register_config ("rrdtool", rrd_config,
                        config_keys, config_keys_num);
        plugin_register_init ("rrdtool", rrd_init);
-       plugin_register_write ("rrdtool", rrd_write);
-       plugin_register_flush ("rrdtool", rrd_flush);
+       plugin_register_write ("rrdtool", rrd_write, /* user_data = */ NULL);
+       plugin_register_flush ("rrdtool", rrd_flush, /* user_data = */ NULL);
        plugin_register_shutdown ("rrdtool", rrd_shutdown);
 }
index 352075f..23e199e 100644 (file)
@@ -70,16 +70,8 @@ struct host_definition_s
   void *sess_handle;
   c_complain_t complaint;
   uint32_t interval;
-  time_t next_update;
   data_definition_t **data_list;
   int data_list_len;
-  enum          /******************************************************/
-  {             /* This host..                                        */
-    STATE_IDLE, /* - just sits there until `next_update < interval_g' */
-    STATE_WAIT, /* - waits to be queried.                             */
-    STATE_BUSY  /* - is currently being queried.                      */
-  } state;      /******************************************************/
-  struct host_definition_s *next;
 };
 typedef struct host_definition_s host_definition_t;
 
@@ -104,20 +96,50 @@ typedef struct csnmp_table_values_s csnmp_table_values_t;
 /*
  * Private variables
  */
-static int do_shutdown = 0;
-
-pthread_t *threads = NULL;
-int threads_num = 0;
-
 static data_definition_t *data_head = NULL;
-static host_definition_t *host_head = NULL;
 
-static pthread_mutex_t host_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t  host_cond = PTHREAD_COND_INITIALIZER;
+/*
+ * Prototypes
+ */
+static int csnmp_read_host (user_data_t *ud);
 
 /*
  * Private functions
  */
+static void csnmp_host_close_session (host_definition_t *host) /* {{{ */
+{
+  if (host->sess_handle == NULL)
+    return;
+
+  snmp_sess_close (host->sess_handle);
+  host->sess_handle = NULL;
+} /* }}} void csnmp_host_close_session */
+
+static void csnmp_host_definition_destroy (void *arg) /* {{{ */
+{
+  host_definition_t *hd;
+
+  hd = arg;
+
+  if (hd == NULL)
+    return;
+
+  if (hd->name != NULL)
+  {
+    DEBUG ("snmp plugin: Destroying host definition for host `%s'.",
+       hd->name);
+  }
+
+  csnmp_host_close_session (hd);
+
+  sfree (hd->name);
+  sfree (hd->address);
+  sfree (hd->community);
+  sfree (hd->data_list);
+
+  sfree (hd);
+} /* }}} void csnmp_host_definition_destroy */
+
 /* Many functions to handle the configuration. {{{ */
 /* First there are many functions which do configuration stuff. It's a big
  * bloated and messy, I'm afraid. */
@@ -543,6 +565,11 @@ static int csnmp_config_add_host (oconfig_item_t *ci)
   int status = 0;
   int i;
 
+  /* Registration stuff. */
+  char cb_name[DATA_MAX_NAME_LEN];
+  user_data_t cb_data;
+  struct timespec cb_interval;
+
   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
   {
     WARNING ("snmp plugin: `Host' needs exactly one string argument.");
@@ -565,8 +592,6 @@ static int csnmp_config_add_host (oconfig_item_t *ci)
 
   hd->sess_handle = NULL;
   hd->interval = 0;
-  hd->next_update = 0;
-  hd->state = STATE_IDLE;
 
   for (i = 0; i < ci->children_num; i++)
   {
@@ -613,23 +638,30 @@ static int csnmp_config_add_host (oconfig_item_t *ci)
 
   if (status != 0)
   {
-    sfree (hd->name);
-    sfree (hd);
+    csnmp_host_definition_destroy (hd);
     return (-1);
   }
 
   DEBUG ("snmp plugin: hd = { name = %s, address = %s, community = %s, version = %i }",
       hd->name, hd->address, hd->community, hd->version);
 
-  if (host_head == NULL)
-    host_head = hd;
-  else
+  ssnprintf (cb_name, sizeof (cb_name), "snmp-%s", hd->name);
+
+  memset (&cb_data, 0, sizeof (cb_data));
+  cb_data.data = hd;
+  cb_data.free_func = csnmp_host_definition_destroy;
+
+  memset (&cb_interval, 0, sizeof (cb_interval));
+  if (hd->interval != 0)
+    cb_interval.tv_sec = (time_t) hd->interval;
+
+  status = plugin_register_complex_read (cb_name, csnmp_read_host,
+      /* interval = */ &cb_interval, /* user_data = */ &cb_data);
+  if (status != 0)
   {
-    host_definition_t *last;
-    last = host_head;
-    while (last->next != NULL)
-      last = last->next;
-    last->next = hd;
+    ERROR ("snmp plugin: Registering complex read function failed.");
+    csnmp_host_definition_destroy (hd);
+    return (-1);
   }
 
   return (0);
@@ -659,15 +691,6 @@ static int csnmp_config (oconfig_item_t *ci)
 
 /* }}} End of the config stuff. Now the interesting part begins */
 
-static void csnmp_host_close_session (host_definition_t *host)
-{
-  if (host->sess_handle == NULL)
-    return;
-
-  snmp_sess_close (host->sess_handle);
-  host->sess_handle = NULL;
-} /* void csnmp_host_close_session */
-
 static void csnmp_host_open_session (host_definition_t *host)
 {
   struct snmp_session sess;
@@ -1413,11 +1436,19 @@ static int csnmp_read_value (host_definition_t *host, data_definition_t *data)
   return (0);
 } /* int csnmp_read_value */
 
-static int csnmp_read_host (host_definition_t *host)
+static int csnmp_read_host (user_data_t *ud)
 {
-  int i;
+  host_definition_t *host;
   time_t time_start;
   time_t time_end;
+  int status;
+  int success;
+  int i;
+
+  host = ud->data;
+
+  if (host->interval == 0)
+    host->interval = interval_g;
 
   time_start = time (NULL);
   DEBUG ("snmp plugin: csnmp_read_host (%s) started at %u;", host->name,
@@ -1429,14 +1460,18 @@ static int csnmp_read_host (host_definition_t *host)
   if (host->sess_handle == NULL)
     return (-1);
 
+  success = 0;
   for (i = 0; i < host->data_list_len; i++)
   {
     data_definition_t *data = host->data_list[i];
 
     if (data->is_table)
-      csnmp_read_table (host, data);
+      status = csnmp_read_table (host, data);
     else
-      csnmp_read_value (host, data);
+      status = csnmp_read_value (host, data);
+
+    if (status == 0)
+      success++;
   }
 
   time_end = time (NULL);
@@ -1444,169 +1479,32 @@ static int csnmp_read_host (host_definition_t *host)
       (unsigned int) time_end);
   if ((uint32_t) (time_end - time_start) > host->interval)
   {
-    WARNING ("snmp plugin: Host `%s' should be queried every %i seconds, "
-       "but reading all values takes %u seconds.",
+    WARNING ("snmp plugin: Host `%s' should be queried every %"PRIu32
+       " seconds, but reading all values takes %u seconds.",
        host->name, host->interval, (unsigned int) (time_end - time_start));
   }
 
+  if (success == 0)
+    return (-1);
+
   return (0);
 } /* int csnmp_read_host */
 
-static void *csnmp_read_thread (void __attribute__((unused)) *data)
-{
-  host_definition_t *host;
-
-  pthread_mutex_lock (&host_lock);
-  while (do_shutdown == 0)
-  {
-    pthread_cond_wait (&host_cond, &host_lock);
-
-    for (host = host_head; host != NULL; host = host->next)
-    {
-      if (do_shutdown != 0)
-       break;
-      if (host->state != STATE_WAIT)
-       continue;
-
-      host->state = STATE_BUSY;
-      pthread_mutex_unlock (&host_lock);
-      csnmp_read_host (host);
-      pthread_mutex_lock (&host_lock);
-      host->state = STATE_IDLE;
-    } /* for (host) */
-  } /* while (do_shutdown == 0) */
-  pthread_mutex_unlock (&host_lock);
-
-  pthread_exit ((void *) 0);
-  return ((void *) 0);
-} /* void *csnmp_read_thread */
-
 static int csnmp_init (void)
 {
-  host_definition_t *host;
-  int i;
-
-  if (host_head == NULL)
-  {
-    NOTICE ("snmp plugin: No host has been defined.");
-    return (-1);
-  }
-
   call_snmp_init_once ();
 
-  threads_num = 0;
-  for (host = host_head; host != NULL; host = host->next)
-  {
-    threads_num++;
-    /* We need to initialize `interval' here, because `interval_g' isn't
-     * initialized during `configure'. */
-    host->next_update = time (NULL);
-    if (host->interval == 0)
-    {
-      host->interval = interval_g;
-    }
-    else if (host->interval < (uint32_t) interval_g)
-    {
-      host->interval = interval_g;
-      WARNING ("snmp plugin: Data for host `%s' will be collected every %i seconds.",
-         host->name, host->interval);
-    }
-
-    csnmp_host_open_session (host);
-  } /* for (host) */
-
-  /* Now start the reading threads */
-  if (threads_num > 3)
-  {
-    threads_num = 3 + ((threads_num - 3) / 10);
-    if (threads_num > 10)
-      threads_num = 10;
-  }
-
-  threads = (pthread_t *) malloc (threads_num * sizeof (pthread_t));
-  if (threads == NULL)
-  {
-    ERROR ("snmp plugin: malloc failed.");
-    return (-1);
-  }
-  memset (threads, '\0', threads_num * sizeof (pthread_t));
-
-  for (i = 0; i < threads_num; i++)
-      pthread_create (threads + i, NULL, csnmp_read_thread, (void *) 0);
-
   return (0);
 } /* int csnmp_init */
 
-static int csnmp_read (void)
-{
-  host_definition_t *host;
-  time_t now;
-
-  if (host_head == NULL)
-  {
-    INFO ("snmp plugin: No hosts configured.");
-    return (-1);
-  }
-
-  now = time (NULL);
-
-  pthread_mutex_lock (&host_lock);
-  for (host = host_head; host != NULL; host = host->next)
-  {
-    if (host->state != STATE_IDLE)
-      continue;
-
-    /* Skip this host if the next or a later iteration will be sufficient. */
-    if (host->next_update >= (now + interval_g))
-      continue;
-
-    host->state = STATE_WAIT;
-    host->next_update = now + host->interval;
-  } /* for (host) */
-
-  pthread_cond_broadcast (&host_cond);
-  pthread_mutex_unlock (&host_lock);
-
-  return (0);
-} /* int csnmp_read */
-
 static int csnmp_shutdown (void)
 {
-  host_definition_t *host_this;
-  host_definition_t *host_next;
-
   data_definition_t *data_this;
   data_definition_t *data_next;
 
-  int i;
-
-  pthread_mutex_lock (&host_lock);
-  do_shutdown = 1;
-  pthread_cond_broadcast (&host_cond);
-  pthread_mutex_unlock (&host_lock);
-
-  for (i = 0; i < threads_num; i++)
-    pthread_join (threads[i], NULL);
-
-  /* Now that all the threads have exited, let's free all the global variables.
-   * This isn't really neccessary, I guess, but I think it's good stile to do
-   * so anyway. */
-  host_this = host_head;
-  host_head = NULL;
-  while (host_this != NULL)
-  {
-    host_next = host_this->next;
-
-    csnmp_host_close_session (host_this);
-
-    sfree (host_this->name);
-    sfree (host_this->address);
-    sfree (host_this->community);
-    sfree (host_this->data_list);
-    sfree (host_this);
-
-    host_this = host_next;
-  }
+  /* When we get here, the read threads have been stopped and all the
+   * `host_definition_t' will be freed. */
+  DEBUG ("snmp plugin: Destroying all data definitions.");
 
   data_this = data_head;
   data_head = NULL;
@@ -1629,7 +1527,6 @@ void module_register (void)
 {
   plugin_register_complex_config ("snmp", csnmp_config);
   plugin_register_init ("snmp", csnmp_init);
-  plugin_register_read ("snmp", csnmp_read);
   plugin_register_shutdown ("snmp", csnmp_shutdown);
 } /* void module_register */
 
index a21bef1..ace9dc6 100644 (file)
@@ -68,7 +68,8 @@ static int sl_config (const char *key, const char *value)
        return (0);
 } /* int sl_config */
 
-static void sl_log (int severity, const char *msg)
+static void sl_log (int severity, const char *msg,
+               user_data_t __attribute__((unused)) *user_data)
 {
        if (severity > log_level)
                return;
@@ -88,6 +89,6 @@ void module_register (void)
        openlog ("collectd", LOG_CONS | LOG_PID, LOG_DAEMON);
 
        plugin_register_config ("syslog", sl_config, config_keys, config_keys_num);
-       plugin_register_log ("syslog", sl_log);
+       plugin_register_log ("syslog", sl_log, /* user_data = */ NULL);
        plugin_register_shutdown ("syslog", sl_shutdown);
 } /* void module_register(void) */
diff --git a/src/table.c b/src/table.c
new file mode 100644 (file)
index 0000000..2911bf0
--- /dev/null
@@ -0,0 +1,560 @@
+/**
+ * collectd - src/table.c
+ * Copyright (C) 2009  Sebastian Harl
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Sebastian Harl <sh at tokkee.org>
+ **/
+
+/*
+ * This module provides generic means to parse and dispatch tabular data.
+ */
+
+#include "collectd.h"
+#include "common.h"
+
+#include "configfile.h"
+#include "plugin.h"
+
+#define log_err(...) ERROR ("table plugin: " __VA_ARGS__)
+#define log_warn(...) WARNING ("table plugin: " __VA_ARGS__)
+
+/*
+ * private data types
+ */
+
+typedef struct {
+       char  *type;
+       char  *instance_prefix;
+       int   *instances;
+       size_t instances_num;
+       int   *values;
+       size_t values_num;
+
+       const data_set_t *ds;
+} tbl_result_t;
+
+typedef struct {
+       char *file;
+       char *sep;
+       char *instance;
+
+       tbl_result_t *results;
+       size_t        results_num;
+
+       size_t max_colnum;
+} tbl_t;
+
+static void tbl_result_setup (tbl_result_t *res)
+{
+       res->type            = NULL;
+
+       res->instance_prefix = NULL;
+       res->instances       = NULL;
+       res->instances_num   = 0;
+
+       res->values          = NULL;
+       res->values_num      = 0;
+
+       res->ds              = NULL;
+} /* tbl_result_setup */
+
+static void tbl_result_clear (tbl_result_t *res)
+{
+       sfree (res->type);
+
+       sfree (res->instance_prefix);
+       sfree (res->instances);
+       res->instances_num = 0;
+
+       sfree (res->values);
+       res->values_num = 0;
+
+       res->ds = NULL;
+} /* tbl_result_clear */
+
+static void tbl_setup (tbl_t *tbl, char *file)
+{
+       tbl->file        = sstrdup (file);
+       tbl->sep         = NULL;
+       tbl->instance    = NULL;
+
+       tbl->results     = NULL;
+       tbl->results_num = 0;
+
+       tbl->max_colnum  = 0;
+} /* tbl_setup */
+
+static void tbl_clear (tbl_t *tbl)
+{
+       size_t i;
+
+       sfree (tbl->file);
+       sfree (tbl->sep);
+       sfree (tbl->instance);
+
+       for (i = 0; i < tbl->results_num; ++i)
+               tbl_result_clear (tbl->results + i);
+       sfree (tbl->results);
+       tbl->results_num = 0;
+
+       tbl->max_colnum  = 0;
+} /* tbl_clear */
+
+static tbl_t *tables;
+static size_t tables_num;
+
+/*
+ * configuration handling
+ */
+
+static int tbl_config_set_s (char *name, char **var, oconfig_item_t *ci)
+{
+       if ((1 != ci->values_num)
+                       || (OCONFIG_TYPE_STRING != ci->values[0].type)) {
+               log_err ("\"%s\" expects a single string argument.", name);
+               return 1;
+       }
+
+       sfree (*var);
+       *var = sstrdup (ci->values[0].value.string);
+       return 0;
+} /* tbl_config_set_separator */
+
+static int tbl_config_append_array_i (char *name, int **var, size_t *len,
+               oconfig_item_t *ci)
+{
+       int *tmp;
+
+       size_t i;
+
+       if (1 > ci->values_num) {
+               log_err ("\"%s\" expects at least one argument.", name);
+               return 1;
+       }
+
+       for (i = 0; i < ci->values_num; ++i) {
+               if (OCONFIG_TYPE_NUMBER != ci->values[i].type) {
+                       log_err ("\"%s\" expects numerical arguments only.", name);
+                       return 1;
+               }
+       }
+
+       *len += ci->values_num;
+       tmp = (int *)realloc (*var, *len * sizeof (**var));
+       if (NULL == tmp) {
+               char errbuf[1024];
+               log_err ("realloc failed: %s.",
+                               sstrerror (errno, errbuf, sizeof (errbuf)));
+               return -1;
+       }
+
+       *var = tmp;
+
+       for (i = *len - ci->values_num; i < *len; ++i)
+               (*var)[i] = (int)ci->values[i].value.number;
+       return 0;
+} /* tbl_config_append_array_s */
+
+static int tbl_config_result (tbl_t *tbl, oconfig_item_t *ci)
+{
+       tbl_result_t *res;
+
+       int status = 0;
+       size_t i;
+
+       if (0 != ci->values_num) {
+               log_err ("<Result> does not expect any arguments.");
+               return 1;
+       }
+
+       res = (tbl_result_t *)realloc (tbl->results,
+                       (tbl->results_num + 1) * sizeof (*tbl->results));
+       if (NULL == tbl) {
+               char errbuf[1024];
+               log_err ("realloc failed: %s.",
+                               sstrerror (errno, errbuf, sizeof (errbuf)));
+               return -1;
+       }
+
+       tbl->results = res;
+       ++tbl->results_num;
+
+       res = tbl->results + tbl->results_num - 1;
+       tbl_result_setup (res);
+
+       for (i = 0; i < ci->children_num; ++i) {
+               oconfig_item_t *c = ci->children + i;
+
+               if (0 == strcasecmp (c->key, "Type"))
+                       tbl_config_set_s (c->key, &res->type, c);
+               else if (0 == strcasecmp (c->key, "InstancePrefix"))
+                       tbl_config_set_s (c->key, &res->instance_prefix, c);
+               else if (0 == strcasecmp (c->key, "InstancesFrom"))
+                       tbl_config_append_array_i (c->key,
+                                       &res->instances, &res->instances_num, c);
+               else if (0 == strcasecmp (c->key, "ValuesFrom"))
+                       tbl_config_append_array_i (c->key,
+                                       &res->values, &res->values_num, c);
+               else
+                       log_warn ("Ignoring unknown config key \"%s\" "
+                                       " in <Result>.", c->key);
+       }
+
+       if (NULL == res->type) {
+               log_err ("No \"Type\" option specified for <Result> "
+                               "in table \"%s\".", tbl->file);
+               status = 1;
+       }
+
+       if (NULL == res->values) {
+               log_err ("No \"ValuesFrom\" option specified for <Result> "
+                               "in table \"%s\".", tbl->file);
+               status = 1;
+       }
+
+       if (0 != status) {
+               tbl_result_clear (res);
+               --tbl->results_num;
+               return status;
+       }
+       return 0;
+} /* tbl_config_result */
+
+static int tbl_config_table (oconfig_item_t *ci)
+{
+       tbl_t *tbl;
+
+       int status = 0;
+       size_t i;
+
+       if ((1 != ci->values_num)
+                       || (OCONFIG_TYPE_STRING != ci->values[0].type)) {
+               log_err ("<Table> expects a single string argument.");
+               return 1;
+       }
+
+       tbl = (tbl_t *)realloc (tables, (tables_num + 1) * sizeof (*tables));
+       if (NULL == tbl) {
+               char errbuf[1024];
+               log_err ("realloc failed: %s.",
+                               sstrerror (errno, errbuf, sizeof (errbuf)));
+               return -1;
+       }
+
+       tables = tbl;
+       ++tables_num;
+
+       tbl = tables + tables_num - 1;
+       tbl_setup (tbl, ci->values[0].value.string);
+
+       for (i = 0; i < ci->children_num; ++i) {
+               oconfig_item_t *c = ci->children + i;
+
+               if (0 == strcasecmp (c->key, "Separator"))
+                       tbl_config_set_s (c->key, &tbl->sep, c);
+               else if (0 == strcasecmp (c->key, "Instance"))
+                       tbl_config_set_s (c->key, &tbl->instance, c);
+               else if (0 == strcasecmp (c->key, "Result"))
+                       tbl_config_result (tbl, c);
+               else
+                       log_warn ("Ignoring unknown config key \"%s\" "
+                                       "in <Table %s>.", c->key, tbl->file);
+       }
+
+       if (NULL == tbl->sep) {
+               log_err ("Table \"%s\" does not specify any separator.", tbl->file);
+               status = 1;
+       }
+       strunescape (tbl->sep, strlen (tbl->sep) + 1);
+
+       if (NULL == tbl->instance) {
+               tbl->instance = sstrdup (tbl->file);
+               replace_special (tbl->instance, strlen (tbl->instance));
+       }
+
+       if (NULL == tbl->results) {
+               log_err ("Table \"%s\" does not specify any (valid) results.",
+                               tbl->file);
+               status = 1;
+       }
+
+       if (0 != status) {
+               tbl_clear (tbl);
+               --tables_num;
+               return status;
+       }
+
+       for (i = 0; i < tbl->results_num; ++i) {
+               tbl_result_t *res = tbl->results + i;
+               size_t j;
+
+               for (j = 0; j < res->instances_num; ++j)
+                       if (res->instances[j] > tbl->max_colnum)
+                               tbl->max_colnum = res->instances[j];
+
+               for (j = 0; j < res->values_num; ++j)
+                       if (res->values[j] > tbl->max_colnum)
+                               tbl->max_colnum = res->values[j];
+       }
+       return 0;
+} /* tbl_config_table */
+
+static int tbl_config (oconfig_item_t *ci)
+{
+       size_t i;
+
+       for (i = 0; i < ci->children_num; ++i) {
+               oconfig_item_t *c = ci->children + i;
+
+               if (0 == strcasecmp (c->key, "Table"))
+                       tbl_config_table (c);
+               else
+                       log_warn ("Ignoring unknown config key \"%s\".", c->key);
+       }
+       return 0;
+} /* tbl_config */
+
+/*
+ * result handling
+ */
+
+static int tbl_prepare (tbl_t *tbl)
+{
+       size_t i;
+
+       for (i = 0; i < tbl->results_num; ++i) {
+               tbl_result_t *res = tbl->results + i;
+
+               res->ds = plugin_get_ds (res->type);
+               if (NULL == res->ds) {
+                       log_err ("Unknown type \"%s\". See types.db(5) for details.",
+                                       res->type);
+                       return -1;
+               }
+
+               if (res->values_num != (size_t)res->ds->ds_num) {
+                       log_err ("Invalid type \"%s\". Expected %zu data source%s, "
+                                       "got %i.", res->type, res->values_num,
+                                       (1 == res->values_num) ? "" : "s",
+                                       res->ds->ds_num);
+                       return -1;
+               }
+       }
+       return 0;
+} /* tbl_prepare */
+
+static int tbl_finish (tbl_t *tbl)
+{
+       size_t i;
+
+       for (i = 0; i < tbl->results_num; ++i)
+               tbl->results[i].ds = NULL;
+       return 0;
+} /* tbl_finish */
+
+static int tbl_result_dispatch (tbl_t *tbl, tbl_result_t *res,
+               char **fields, size_t fields_num)
+{
+       value_list_t vl = VALUE_LIST_INIT;
+       value_t values[res->values_num];
+
+       size_t i;
+
+       assert (NULL != res->ds);
+       assert (res->values_num == res->ds->ds_num);
+
+       for (i = 0; i < res->values_num; ++i) {
+               char *value;
+
+               assert (res->values[i] < fields_num);
+               value = fields[res->values[i]];
+
+               if (0 != parse_value (value, &values[i], res->ds->ds[i]))
+                       return -1;
+       }
+
+       vl.values     = values;
+       vl.values_len = STATIC_ARRAY_SIZE (values);
+
+       sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+       sstrncpy (vl.plugin, "table", sizeof (vl.plugin));
+       sstrncpy (vl.plugin_instance, tbl->instance, sizeof (vl.plugin_instance));
+       sstrncpy (vl.type, res->type, sizeof (vl.type));
+
+       if (0 == res->instances_num) {
+               if (NULL != res->instance_prefix)
+                       sstrncpy (vl.type_instance, res->instance_prefix,
+                                       sizeof (vl.type_instance));
+       }
+       else {
+               char *instances[res->instances_num];
+               char  instances_str[DATA_MAX_NAME_LEN];
+
+               for (i = 0; i < res->instances_num; ++i) {
+                       assert (res->instances[i] < fields_num);
+                       instances[i] = fields[res->instances[i]];
+               }
+
+               strjoin (instances_str, sizeof (instances_str),
+                               instances, STATIC_ARRAY_SIZE (instances), "-");
+               instances_str[sizeof (instances_str) - 1] = '\0';
+
+               vl.type_instance[sizeof (vl.type_instance) - 1] = '\0';
+               if (NULL == res->instance_prefix)
+                       strncpy (vl.type_instance, instances_str,
+                                       sizeof (vl.type_instance));
+               else
+                       snprintf (vl.type_instance, sizeof (vl.type_instance),
+                                       "%s-%s", res->instance_prefix, instances_str);
+
+               if ('\0' != vl.type_instance[sizeof (vl.type_instance) - 1]) {
+                       vl.type_instance[sizeof (vl.type_instance) - 1] = '\0';
+                       log_warn ("Truncated type instance: %s.", vl.type_instance);
+               }
+       }
+
+       plugin_dispatch_values (&vl);
+       return 0;
+} /* tbl_result_dispatch */
+
+static int tbl_parse_line (tbl_t *tbl, char *line, size_t len)
+{
+       char *fields[tbl->max_colnum + 1];
+       char *ptr, *saveptr;
+
+       size_t i;
+
+       i = 0;
+       ptr = line;
+       saveptr = NULL;
+       while (NULL != (fields[i] = strtok_r (ptr, tbl->sep, &saveptr))) {
+               ptr = NULL;
+               ++i;
+
+               if (i > tbl->max_colnum)
+                       break;
+       }
+
+       if (i <= tbl->max_colnum) {
+               log_err ("Not enough columns in line "
+                               "(expected at least %zu, got %zu).",
+                               tbl->max_colnum + 1, i);
+               return -1;
+       }
+
+       for (i = 0; i < tbl->results_num; ++i)
+               if (0 != tbl_result_dispatch (tbl, tbl->results + i,
+                                       fields, STATIC_ARRAY_SIZE (fields))) {
+                       log_err ("Failed to dispatch result.");
+                       continue;
+               }
+       return 0;
+} /* tbl_parse_line */
+
+static int tbl_read_table (tbl_t *tbl)
+{
+       FILE *fh;
+       char  buf[4096];
+
+       fh = fopen (tbl->file, "r");
+       if (NULL == fh) {
+               char errbuf[1024];
+               log_err ("Failed to open file \"%s\": %s.", tbl->file,
+                               sstrerror (errno, errbuf, sizeof (errbuf)));
+               return -1;
+       }
+
+       buf[sizeof (buf) - 1] = '\0';
+       while (NULL != fgets (buf, sizeof (buf), fh)) {
+               if ('\0' != buf[sizeof (buf) - 1]) {
+                       buf[sizeof (buf) - 1] = '\0';
+                       log_err ("Table %s: Truncated line: %s", tbl->file, buf);
+               }
+
+               if (0 != tbl_parse_line (tbl, buf, sizeof (buf))) {
+                       log_err ("Table %s: Failed to parse line: %s", tbl->file, buf);
+                       continue;
+               }
+       }
+
+       if (0 != ferror (fh)) {
+               char errbuf[1024];
+               log_err ("Failed to read from file \"%s\": %s.", tbl->file,
+                               sstrerror (errno, errbuf, sizeof (errbuf)));
+               fclose (fh);
+               return -1;
+       }
+
+       fclose (fh);
+       return 0;
+} /* tbl_read_table */
+
+/*
+ * collectd callbacks
+ */
+
+static int tbl_read (void)
+{
+       int status = -1;
+       size_t i;
+
+       if (0 == tables_num)
+               return 0;
+
+       for (i = 0; i < tables_num; ++i) {
+               tbl_t *tbl = tables + i;
+
+               if (0 != tbl_prepare (tbl)) {
+                       log_err ("Failed to prepare and parse table \"%s\".", tbl->file);
+                       continue;
+               }
+
+               if (0 == tbl_read_table (tbl))
+                       status = 0;
+
+               tbl_finish (tbl);
+       }
+       return status;
+} /* tbl_read */
+
+static int tbl_shutdown (void)
+{
+       size_t i;
+
+       for (i = 0; i < tables_num; ++i)
+               tbl_clear (&tables[i]);
+       sfree (tables);
+       return 0;
+} /* tbl_shutdown */
+
+static int tbl_init (void)
+{
+       if (0 == tables_num)
+               return 0;
+
+       plugin_register_read ("table", tbl_read);
+       plugin_register_shutdown ("table", tbl_shutdown);
+       return 0;
+} /* tbl_init */
+
+void module_register (void)
+{
+       plugin_register_complex_config ("table", tbl_config);
+       plugin_register_init ("table", tbl_init);
+} /* module_register */
+
+/* vim: set sw=4 ts=4 tw=78 noexpandtab : */
diff --git a/src/ted.c b/src/ted.c
new file mode 100644 (file)
index 0000000..8dc00e5
--- /dev/null
+++ b/src/ted.c
@@ -0,0 +1,360 @@
+/**
+ * collectd - src/ted.c
+ * Copyright (C) 2009  Eric Reed
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Eric Reed <ericr at reedhome.net>
+ *
+ *  This is a collectd module for The Energy Detective: A low-cost whole
+ * house energy monitoring system. For more information on TED, see
+ * http://theenergydetective.com
+ *
+ * This module was not created by Energy, Inc. nor is it supported by
+ * them in any way. It was created using information from two sources:
+ * David Satterfield's TED module for Misterhouse, and Micah Dowty's TED
+ * Python Module.
+ *
+ * This has only tested with the model 1001 RDU, with
+ * firmware version 9.01U. The USB port is uses the very common FTDI
+ * USB-to-serial chip, so the RDU will show up as a serial device on
+ * Windows, Mac OS, or Linux.
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "configfile.h"
+
+#if HAVE_TERMIOS_H && HAVE_SYS_IOCTL_H && HAVE_MATH_H
+# include <termios.h>
+# include <sys/ioctl.h>
+# include <math.h>
+#else
+# error "No applicable input method."
+#endif
+
+#define EXPECTED_PACKAGE_LENGTH 278
+#define ESCAPE       0x10
+#define PKT_BEGIN    0x04
+#define PKT_END      0x03
+
+#define DEFAULT_DEVICE "/dev/ttyUSB0"
+
+static char *conf_device = NULL;
+static int   conf_retries = 0;
+
+static int fd = -1;
+
+static const char *config_keys[] =
+{
+    "Device",
+    "Retries"
+};
+static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
+
+static int ted_read_value(double *ret_power, double *ret_voltage)
+{
+    unsigned char receive_buffer[300];
+    unsigned char package_buffer[300];
+    char pkt_request[1] = {0xAA};
+    int package_buffer_pos;
+
+    fd_set input;
+    struct timeval timeout;
+
+    int end_flag;
+    int escape_flag;
+
+    int status;
+
+    assert (fd >= 0);
+
+    /* Initialize the input set*/
+    FD_ZERO (&input);
+    FD_SET (fd, &input);
+
+    /* Initialize timeout structure, set to 2 seconds */
+    memset (&timeout, 0, sizeof (timeout));
+    timeout.tv_sec = 2;
+    timeout.tv_usec = 0;
+
+    /* clear out anything in the buffer */
+    tcflush (fd, TCIFLUSH);
+
+    status = write (fd, pkt_request, sizeof(pkt_request));
+    if (status <= 0)
+    {
+        ERROR ("ted plugin: swrite failed.");
+        return (-1);
+    }
+
+    /* Loop until we find the end of the package */
+    end_flag = 0;
+    escape_flag = 0;
+    package_buffer_pos = 0;
+    while (end_flag == 0)
+    {
+        ssize_t receive_buffer_length;
+        ssize_t i;
+
+        /* check for timeout or input error*/
+        status = select (fd + 1, &input, NULL, NULL, &timeout);
+        if (status == 0) /* Timeout */
+        {
+            WARNING ("ted plugin: Timeout while waiting for file descriptor "
+                    "to become ready.");
+            return (-1);
+        }
+        else if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
+        {
+            /* Some signal or something. Start over.. */
+            continue;
+        }
+        else if (status < 0)
+        {
+            char errbuf[1024];
+            ERROR ("ted plugin: select failed: %s",
+                    sstrerror (errno, errbuf, sizeof (errbuf)));
+            return (-1);
+        }
+
+        receive_buffer_length = read (fd, receive_buffer, sizeof (receive_buffer));
+        if (receive_buffer_length < 0)
+        {
+            char errbuf[1024];
+            if ((errno == EAGAIN) || (errno == EINTR))
+                continue;
+            ERROR ("ted plugin: read(2) failed: %s",
+                    sstrerror (errno, errbuf, sizeof (errbuf)));
+            return (-1);
+        }
+        else if (receive_buffer_length == 0)
+        {
+            /* Should we close the FD in this case? */
+            WARNING ("ted plugin: Received EOF from file descriptor.");
+            return (-1);
+        }
+        else if (receive_buffer_length > sizeof (receive_buffer))
+        {
+            ERROR ("ted plugin: read(2) returned invalid value %zi.",
+                    receive_buffer_length);
+            return (-1);
+        }
+
+        /*
+         * packet filter loop
+         *
+         * Handle escape sequences in `receive_buffer' and put the
+         * result in `package_buffer'.
+         */
+        /* We need to see the begin sequence first. When we receive `ESCAPE
+         * PKT_BEGIN', we set `package_buffer_pos' to zero to signal that
+         * the beginning of the package has been found. */
+
+        escape_flag = 0;
+        for (i = 0; i < receive_buffer_length; i++)
+        {
+            /* Check if previous byte was the escape byte. */
+            if (escape_flag == 1)
+            {
+                escape_flag = 0;
+                /* escape escape = single escape */
+                if ((receive_buffer[i] == ESCAPE)
+                        && (package_buffer_pos >= 0))
+                {
+                    package_buffer[package_buffer_pos] = ESCAPE;
+                    package_buffer_pos++;
+                }
+                else if (receive_buffer[i] == PKT_BEGIN)
+                {
+                    package_buffer_pos = 0;
+                }
+                else if  (receive_buffer[i] == PKT_END)
+                {
+                    end_flag = 1;
+                    break;
+                }
+                else
+                {
+                    DEBUG ("ted plugin: Unknown escaped byte: %#x",
+                            (unsigned int) receive_buffer[i]);
+                }
+            }
+            else if (receive_buffer[i] == ESCAPE)
+            {
+                escape_flag = 1;
+            }
+            /* if we are in a package add byte to buffer
+             * otherwise throw away */
+            else if (package_buffer_pos >= 0)
+            {
+                package_buffer[package_buffer_pos] = receive_buffer[i];
+                package_buffer_pos++;
+            }
+        } /* for (i = 0; i < receive_buffer_length; i++) */
+    } /* while (end_flag == 0) */
+
+    /* Check for errors inside the loop. */
+    if ((end_flag == 0) || (package_buffer_pos != EXPECTED_PACKAGE_LENGTH))
+        return (-1);
+
+    /*
+     * Power is at positions 247 and 248 (LSB first) in [10kW].
+     * Voltage is at positions 251 and 252 (LSB first) in [.1V].
+     *
+     * Power is in 10 Watt steps
+     * Voltage is in volts
+     */
+    *ret_power = 10.0 * (double) ((((int) package_buffer[248]) * 256)
+            + ((int) package_buffer[247]));
+    *ret_voltage = 0.1 * (double) ((((int) package_buffer[252]) * 256)
+            + ((int) package_buffer[251]));
+
+    /* success */
+    return (0);
+} /* int ted_read_value */
+
+static int ted_open_device (void)
+{
+    const char *dev;
+    struct termios options;
+
+    if (fd >= 0)
+        return (0);
+
+    dev = DEFAULT_DEVICE;
+    if (conf_device != NULL)
+        dev = conf_device;
+
+    fd = open (dev, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
+    if (fd < 0)
+    {
+        ERROR ("ted plugin: Unable to open device %s.", dev);
+        return (-1);
+    }
+
+    /* Get the current options for the port... */
+    tcgetattr(fd, &options);
+    options.c_cflag = B19200 | CS8 | CSTOPB | CREAD | CLOCAL;
+    options.c_iflag = IGNBRK | IGNPAR;
+    options.c_oflag = 0;
+    options.c_lflag = 0;
+    options.c_cc[VTIME] = 20;
+    options.c_cc[VMIN]  = 250;
+
+    /* Set the new options for the port... */
+    tcflush(fd, TCIFLUSH);
+    tcsetattr(fd, TCSANOW, &options);
+
+    INFO ("ted plugin: Successfully opened %s.", dev);
+    return (0);
+} /* int ted_open_device */
+
+static void ted_submit (char *type, double value)
+{
+    value_t values[1];
+    value_list_t vl = VALUE_LIST_INIT;
+
+    values[0].gauge = value;
+
+    vl.time = time (NULL);
+    vl.values = values;
+    vl.values_len = 1;
+    sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+    sstrncpy (vl.plugin, "ted", sizeof (vl.plugin));
+    sstrncpy (vl.type, type, sizeof (vl.type));
+
+    plugin_dispatch_values (&vl);
+}
+
+static int ted_config (const char *key, const char *value)
+{
+    if (strcasecmp ("Device", key) == 0)
+    {
+        sfree (conf_device);
+        conf_device = sstrdup (value);
+    }
+    else if (strcasecmp ("Retries", key) == 0)
+    {
+        int tmp;
+
+        tmp = atoi (value);
+        if (tmp < 0)
+        {
+            WARNING ("ted plugin: Invalid retry count: %i", tmp);
+            return (1);
+        }
+        conf_retries = tmp;
+    }
+    else
+    {
+        ERROR ("ted plugin: Unknown config option: %s", key);
+        return (-1);
+    }
+
+    return (0);
+} /* int ted_config */
+
+static int ted_read (void)
+{
+    double power;
+    double voltage;
+    int status;
+    int i;
+
+    status = ted_open_device ();
+    if (status != 0)
+        return (-1);
+
+    power = NAN;
+    voltage = NAN;
+    for (i = 0; i <= conf_retries; i++)
+    {
+        status = ted_read_value (&power, &voltage);
+        if (status == 0)
+            break;
+    }
+
+    if (status != 0)
+        return (-1);
+
+    ted_submit ("power", power);
+    ted_submit ("voltage", voltage);
+
+    return (0);
+} /* int ted_read */
+
+static int ted_shutdown (void)
+{
+    if (fd >= 0)
+    {
+        close (fd);
+        fd = -1;
+    }
+
+    return (0);
+} /* int ted_shutdown */
+
+void module_register (void)
+{
+    plugin_register_config ("ted", ted_config,
+            config_keys, config_keys_num);
+    plugin_register_read ("ted", ted_read);
+    plugin_register_shutdown ("ted", ted_shutdown);
+} /* void module_register */
+
+/* vim: set sw=4 et : */
index 6fc8e11..b38c207 100644 (file)
@@ -69,6 +69,7 @@ memory                        value:GAUGE:0:281474976710656
 multimeter             value:GAUGE:U:U
 mysql_commands         value:COUNTER:0:U
 mysql_handler          value:COUNTER:0:U
+mysql_log_position     value:COUNTER:0:4294967295
 mysql_octets           rx:COUNTER:0:4294967295, tx:COUNTER:0:4294967295
 mysql_qcache           hits:COUNTER:0:U, inserts:COUNTER:0:U, not_cached:COUNTER:0:U, lowmem_prunes:COUNTER:0:U, queries_in_cache:GAUGE:0:U
 mysql_threads          running:GAUGE:0:U, connected:GAUGE:0:U, cached:GAUGE:0:U, created:COUNTER:0:U
@@ -85,8 +86,11 @@ pg_numbackends               value:GAUGE:0:U
 pg_scan                        value:COUNTER:0:U
 pg_xact                        value:COUNTER:0:U
 ping                   ping:GAUGE:0:65535
+ping_droprate          value:GAUGE:0:100
+ping_stddev            value:GAUGE:0:65535
 players                        value:GAUGE:0:1000000
 power                  value:GAUGE:0:U
+protocol_counter       value:COUNTER:0:U
 ps_count               processes:GAUGE:0:1000000, threads:GAUGE:0:1000000
 ps_cputime             user:COUNTER:0:16000000, syst:COUNTER:0:16000000
 ps_pagefaults          minflt:COUNTER:0:9223372036854775807, majflt:COUNTER:0:9223372036854775807
@@ -107,6 +111,7 @@ temperature         value:GAUGE:-273.15:U
 time_dispersion                seconds:GAUGE:-1000000:1000000
 timeleft               timeleft:GAUGE:0:3600
 time_offset            seconds:GAUGE:-1000000:1000000
+uptime                 value:GAUGE:0:4294967295
 users                  users:GAUGE:0:65535
 virt_cpu_total         ns:COUNTER:0:256000000000
 virt_vcpu              ns:COUNTER:0:1000000000
index 4a1bfa4..a46eb41 100644 (file)
@@ -44,6 +44,9 @@ For example:
  TypesDB "/opt/collectd/share/collectd/types.db"
  TypesDB "/opt/collectd/etc/types.db.custom"
 
+B<Note>: Make sure to make this file available on all systems if you're
+sending values over the network.
+
 =head1 SEE ALSO
 
 L<collectd(1)>,
diff --git a/src/uptime.c b/src/uptime.c
new file mode 100644 (file)
index 0000000..4edfa84
--- /dev/null
@@ -0,0 +1,218 @@
+/**
+ * collectd - src/uptime.c
+ * Copyright (C) 2009  Marco Chiappero
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Marco Chiappero <marco at absence.it>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+
+#if KERNEL_LINUX
+# define UPTIME_FILE "/proc/uptime"
+/* No need for includes, using /proc filesystem, Linux only. */
+/* #endif KERNEL_LINUX */
+
+#elif HAVE_LIBKSTAT
+/* Using kstats chain to retrieve the boot time, this applies to:
+ * - Solaris / OpenSolaris
+ */
+/* #endif HAVE_LIBKSTAT */
+
+#elif HAVE_SYS_SYSCTL_H
+# include <sys/sysctl.h>
+/* Using sysctl interface to retrieve the boot time, this applies to:
+ * - *BSD
+ * - Darwin / OS X
+ */
+/* #endif HAVE_SYS_SYSCTL_H */
+
+#else
+# error "No applicable input method."
+#endif
+
+/* 
+ * Global variables
+ */
+#if KERNEL_LINUX
+/* global variables not needed */
+/* #endif KERNEL_LINUX */
+
+#elif HAVE_LIBKSTAT
+static time_t boottime;
+extern kstat_ctl_t *kc;
+/* #endif HAVE_LIBKSTAT */
+
+#elif HAVE_SYS_SYSCTL_H
+static time_t boottime;
+#endif
+
+static void uptime_submit (gauge_t uptime)
+{
+       value_t values[1];
+       value_list_t vl = VALUE_LIST_INIT;
+
+       values[0].gauge = uptime;
+
+       vl.values = values;
+       vl.values_len = 1;
+
+       sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+       sstrncpy (vl.plugin, "uptime", sizeof (vl.plugin));
+       sstrncpy (vl.type, "uptime", sizeof (vl.type));
+
+       plugin_dispatch_values (&vl);
+}
+
+#if !defined(KERNEL_LINUX) || !KERNEL_LINUX
+static int uptime_init (void)
+{
+/*     NOTE
+
+       On unix systems other than Linux there is no /proc filesystem which
+       calculates the uptime every time we call a read for the /proc/uptime
+       file, the only information available is the boot time (in unix time,
+       since epoch). Hence there is no need to read, every time the
+       plugin_read is called, a value that won't change: this is a right
+       task for the uptime_init function. However, since uptime_init is run
+       only once, if the function fails in retrieving the boot time, the
+       plugin is unregistered and there is no chance to try again later.
+       Nevertheless, this is very unlikely to happen.
+ */
+
+# if HAVE_LIBKSTAT
+       kstat_t *ksp;
+       kstat_named_t *knp;
+
+       ksp = NULL;
+       knp = NULL;
+
+       /* kstats chain already opened by update_kstat (using *kc), let's verify everything went fine. */
+       if (kc == NULL)
+       {
+               ERROR ("uptime plugin: kstat chain control structure not available.");
+               return (-1);
+       }
+
+       ksp = kstat_lookup (kc, "unix", 0, "system_misc");
+       if (ksp == NULL)
+       {
+               ERROR ("uptime plugin: Cannot find unix:0:system_misc kstat.");
+               return (-1);
+       }
+
+       if (kstat_read (kc, ksp, NULL) < 0)
+       {
+               ERROR ("uptime plugin: kstat_read failed.");
+               return (-1);
+       }
+
+       knp = (kstat_named_t *) kstat_data_lookup (ksp, "boot_time");
+       if (knp == NULL)
+       {
+               ERROR ("uptime plugin: kstat_data_lookup (boot_time) failed.");
+               return (-1);
+       }
+
+       boottime = (time_t) knp->value.ui32;
+/* #endif HAVE_LIBKSTAT */
+
+# elif HAVE_SYS_SYSCTL_H
+       struct timeval boottv;
+       size_t boottv_len;
+       int status;
+
+        int mib[2];
+
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_BOOTTIME;
+
+       memset (&boottv, 0, sizeof (boottv));
+        boottv_len = sizeof (boottv);
+
+       status = sysctl (mib, STATIC_ARRAY_SIZE (mib), &boottv, &boottv_len,
+                       /* new_value = */ NULL, /* new_length = */ 0);
+       if (status != 0)
+        {
+                char errbuf[1024];
+                ERROR ("uptime plugin: No value read from sysctl interface: %s",
+                        sstrerror (errno, errbuf, sizeof (errbuf)));
+                return (-1);
+        }
+
+       boottime = boottv.tv_sec;
+       if (boottime == 0)
+       {
+               ERROR ("uptime plugin: sysctl(3) returned success, "
+                               "but `boottime' is zero!");
+               return (-1);
+       }
+#endif /* HAVE_SYS_SYSCTL_H */
+
+       return (0);
+
+}
+#endif /* !KERNEL_LINUX */
+
+static int uptime_read (void)
+{
+       gauge_t uptime;
+
+#if KERNEL_LINUX
+       FILE *fh;
+
+       fh = fopen (UPTIME_FILE, "r");
+
+       if (fh == NULL)
+       {
+               char errbuf[1024];
+               ERROR ("uptime plugin: Cannot open "UPTIME_FILE": %s",
+                       sstrerror (errno, errbuf, sizeof (errbuf)));
+               return (-1);
+       }
+
+       if ( fscanf (fh, "%lf", &uptime) < 1 )
+       {
+               WARNING ("uptime plugin: No value read from "UPTIME_FILE);
+               fclose (fh);
+               return (-1);
+       }
+
+       fclose (fh);
+/* #endif KERNEL_LINUX */
+
+#elif HAVE_LIBKSTAT || HAVE_SYS_SYSCTL_H
+       time_t elapsed;
+
+       elapsed = time (NULL) - boottime;
+
+       uptime = (gauge_t) elapsed;
+#endif /* HAVE_LIBKSTAT || HAVE_SYS_SYSCTL_H */
+
+       uptime_submit (uptime);
+
+       return (0);
+}
+
+void module_register (void)
+{
+#if !defined(KERNEL_LINUX) || !KERNEL_LINUX
+       plugin_register_init ("uptime", uptime_init);
+#endif
+       plugin_register_read ("uptime", uptime_read);
+} /* void module_register */
index 5bd6ec7..826e1b0 100644 (file)
@@ -1,6 +1,6 @@
 /**
  * collectd - src/utils_cms_putval.c
- * Copyright (C) 2007,2008  Florian octo Forster
+ * Copyright (C) 2007-2009  Florian octo Forster
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -33,7 +33,7 @@
                return -1; \
        }
 
-static int parse_value (const data_set_t *ds, value_list_t *vl,
+static int dispatch_values (const data_set_t *ds, value_list_t *vl,
                FILE *fh, char *buffer)
 {
        char *dummy;
@@ -65,12 +65,13 @@ static int parse_value (const data_set_t *ds, value_list_t *vl,
                        break;
                }
 
-               if (strcmp (ptr, "U") == 0)
+               if ((strcmp (ptr, "U") == 0) && (ds->ds[i].type == DS_TYPE_GAUGE))
                        vl->values[i].gauge = NAN;
-               else if (ds->ds[i].type == DS_TYPE_COUNTER)
-                       vl->values[i].counter = atoll (ptr);
-               else if (ds->ds[i].type == DS_TYPE_GAUGE)
-                       vl->values[i].gauge = atof (ptr);
+               else if (0 != parse_value (ptr, &vl->values[i], ds->ds[i]))
+               {
+                       print_to_socket (fh, "-1 Failed to parse value `%s'.\n", ptr);
+                       return (-1);
+               }
 
                i++;
        } /* while (strtok_r) */
@@ -79,7 +80,7 @@ static int parse_value (const data_set_t *ds, value_list_t *vl,
        {
                char identifier[128];
                FORMAT_VL (identifier, sizeof (identifier), vl, ds);
-               ERROR ("cmd putval: parse_value: "
+               ERROR ("cmd putval: dispatch_values: "
                                "Number of values incorrect: "
                                "Got %i, expected %i. Identifier is `%s'.",
                                i, vl->values_len, identifier);
@@ -91,7 +92,7 @@ static int parse_value (const data_set_t *ds, value_list_t *vl,
 
        plugin_dispatch_values (vl);
        return (0);
-} /* int parse_value */
+} /* int dispatch_values */
 
 static int set_option (value_list_t *vl, const char *key, const char *value)
 {
@@ -252,7 +253,7 @@ int handle_putval (FILE *fh, char *buffer)
                }
                assert (string != NULL);
 
-               status = parse_value (ds, &vl, fh, string);
+               status = dispatch_values (ds, &vl, fh, string);
                if (status != 0)
                {
                        /* An error has already been printed. */
index c2897c7..5531b25 100644 (file)
@@ -197,7 +197,7 @@ static int udb_legacy_result_handle_result (udb_result_t *r, /* {{{ */
 {
   value_list_t vl = VALUE_LIST_INIT;
   value_t value;
-  char *endptr;
+  char *value_str;
 
   assert (r->legacy_mode == 1);
   assert (r->ds != NULL);
@@ -206,23 +206,14 @@ static int udb_legacy_result_handle_result (udb_result_t *r, /* {{{ */
   vl.values = &value;
   vl.values_len = 1;
 
-  endptr = NULL;
-  errno = 0;
-  if (r->ds->ds[0].type == DS_TYPE_COUNTER)
-    vl.values[0].counter = (counter_t) strtoll (column_values[r->legacy_position],
-        &endptr, /* base = */ 0);
-  else if (r->ds->ds[0].type == DS_TYPE_GAUGE)
-    vl.values[0].gauge = (gauge_t) strtod (column_values[r->legacy_position],
-        &endptr);
-  else
-    errno = EINVAL;
-
-  if ((endptr == column_values[r->legacy_position]) || (errno != 0))
+  value_str = column_values[r->legacy_position];
+  if (0 != parse_value (value_str, &vl.values[0], r->ds->ds[0]))
   {
-    WARNING ("db query utils: udb_result_submit: Parsing `%s' as %s failed.",
-        column_values[r->legacy_position],
+    ERROR ("db query utils: udb_legacy_result_handle_result: "
+        "Parsing `%s' as %s failed.", value_str,
         (r->ds->ds[0].type == DS_TYPE_COUNTER) ? "counter" : "gauge");
-    vl.values[0].gauge = NAN;
+    errno = EINVAL;
+    return (-1);
   }
 
   sstrncpy (vl.host, q->host, sizeof (vl.host));
@@ -351,7 +342,7 @@ static int udb_legacy_result_create (const char *query_name, /* {{{ */
 /*
  * Result private functions
  */
-static void udb_result_submit (udb_result_t *r, udb_query_t *q) /* {{{ */
+static int udb_result_submit (udb_result_t *r, udb_query_t *q) /* {{{ */
 {
   value_list_t vl = VALUE_LIST_INIT;
   size_t i;
@@ -365,30 +356,21 @@ static void udb_result_submit (udb_result_t *r, udb_query_t *q) /* {{{ */
   if (vl.values == NULL)
   {
     ERROR ("db query utils: malloc failed.");
-    return;
+    return (-1);
   }
   vl.values_len = r->ds->ds_num;
 
   for (i = 0; i < r->values_num; i++)
   {
-    char *endptr;
-
-    endptr = NULL;
-    errno = 0;
-    if (r->ds->ds[i].type == DS_TYPE_COUNTER)
-      vl.values[i].counter = (counter_t) strtoll (r->values_buffer[i],
-          &endptr, /* base = */ 0);
-    else if (r->ds->ds[i].type == DS_TYPE_GAUGE)
-      vl.values[i].gauge = (gauge_t) strtod (r->values_buffer[i], &endptr);
-    else
-      errno = EINVAL;
+    char *value_str = r->values_buffer[i];
 
-    if ((endptr == r->values_buffer[i]) || (errno != 0))
+    if (0 != parse_value (value_str, &vl.values[i], r->ds->ds[i]))
     {
-      WARNING ("db query utils: udb_result_submit: Parsing `%s' as %s failed.",
-          r->values_buffer[i],
+      ERROR ("db query utils: udb_result_submit: Parsing `%s' as %s failed.",
+          value_str,
           (r->ds->ds[i].type == DS_TYPE_COUNTER) ? "counter" : "gauge");
-      vl.values[i].gauge = NAN;
+      errno = EINVAL;
+      return (-1);
     }
   }
 
@@ -430,6 +412,7 @@ static void udb_result_submit (udb_result_t *r, udb_query_t *q) /* {{{ */
   plugin_dispatch_values (&vl);
 
   sfree (vl.values);
+  return (0);
 } /* }}} void udb_result_submit */
 
 static void udb_result_finish_result (udb_result_t *r) /* {{{ */
@@ -468,9 +451,7 @@ static int udb_result_handle_result (udb_result_t *r, /* {{{ */
   for (i = 0; i < r->values_num; i++)
     r->values_buffer[i] = column_values[r->values_pos[i]];
 
-  udb_result_submit (r, q);
-
-  return (0);
+  return udb_result_submit (r, q);
 } /* }}} int udb_result_handle_result */
 
 static int udb_result_prepare_result (udb_result_t *r, /* {{{ */
diff --git a/src/utils_heap.c b/src/utils_heap.c
new file mode 100644 (file)
index 0000000..1ecd07e
--- /dev/null
@@ -0,0 +1,223 @@
+/**
+ * collectd - src/utils_heap.c
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ **/
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <pthread.h>
+
+#include "utils_heap.h"
+
+struct c_heap_s
+{
+  pthread_mutex_t lock;
+  int (*compare) (const void *, const void *);
+
+  void **list;
+  size_t list_len; /* # entries used */
+  size_t list_size; /* # entries allocated */
+};
+
+enum reheap_direction
+{
+  DIR_UP,
+  DIR_DOWN
+};
+
+static void reheap (c_heap_t *h, size_t root, enum reheap_direction dir)
+{
+  size_t left;
+  size_t right;
+  size_t min;
+  int status;
+
+  /* Calculate the positions of the children */
+  left = (2 * root) + 1;
+  if (left >= h->list_len)
+    left = 0;
+
+  right = (2 * root) + 2;
+  if (right >= h->list_len)
+    right = 0;
+
+  /* Check which one of the children is smaller. */
+  if ((left == 0) && (right == 0))
+    return;
+  else if (left == 0)
+    min = right;
+  else if (right == 0)
+    min = left;
+  else
+  {
+    status = h->compare (h->list[left], h->list[right]);
+    if (status > 0)
+      min = right;
+    else
+      min = left;
+  }
+
+  status = h->compare (h->list[root], h->list[min]);
+  if (status <= 0)
+  {
+    /* We didn't need to change anything, so the rest of the tree should be
+     * okay now. */
+    return;
+  }
+  else /* if (status > 0) */
+  {
+    void *tmp;
+
+    tmp = h->list[root];
+    h->list[root] = h->list[min];
+    h->list[min] = tmp;
+  }
+
+  if ((dir == DIR_UP) && (root == 0))
+    return;
+
+  if (dir == DIR_UP)
+    reheap (h, root / 2, dir);
+  else if (dir == DIR_DOWN)
+    reheap (h, min, dir);
+} /* void reheap */
+
+c_heap_t *c_heap_create (int (*compare) (const void *, const void *))
+{
+  c_heap_t *h;
+
+  if (compare == NULL)
+    return (NULL);
+
+  h = malloc (sizeof (*h));
+  if (h == NULL)
+    return (NULL);
+
+  memset (h, 0, sizeof (*h));
+  pthread_mutex_init (&h->lock, /* attr = */ NULL);
+  h->compare = compare;
+  
+  h->list = NULL;
+  h->list_len = 0;
+  h->list_size = 0;
+
+  return (h);
+} /* c_heap_t *c_heap_create */
+
+void c_heap_destroy (c_heap_t *h)
+{
+  if (h == NULL)
+    return;
+
+  h->list_len = 0;
+  h->list_size = 0;
+  free (h->list);
+  h->list = NULL;
+
+  pthread_mutex_destroy (&h->lock);
+
+  free (h);
+} /* void c_heap_destroy */
+
+int c_heap_insert (c_heap_t *h, void *ptr)
+{
+  if ((h == NULL) || (ptr == NULL))
+    return (-EINVAL);
+
+  pthread_mutex_lock (&h->lock);
+
+  assert (h->list_len <= h->list_size);
+  if (h->list_len == h->list_size)
+  {
+    void **tmp;
+
+    tmp = realloc (h->list, (h->list_size + 16) * sizeof (*h->list));
+    if (tmp == NULL)
+    {
+      pthread_mutex_unlock (&h->lock);
+      return (-ENOMEM);
+    }
+
+    h->list = tmp;
+    h->list_size += 16;
+  }
+
+  /* Insert the new node as a leaf. */
+  h->list[h->list_len] = ptr;
+  h->list_len++;
+
+  /* Reorganize the heap from bottom up. */
+  reheap (h, /* parent of this node = */ (h->list_len - 1) / 2, DIR_UP);
+  
+  pthread_mutex_unlock (&h->lock);
+  return (0);
+} /* int c_heap_insert */
+
+void *c_head_get_root (c_heap_t *h)
+{
+  void *ret = NULL;
+
+  if (h == NULL)
+    return (NULL);
+
+  pthread_mutex_lock (&h->lock);
+
+  if (h->list_len == 0)
+  {
+    pthread_mutex_unlock (&h->lock);
+    return (NULL);
+  }
+  else if (h->list_len == 1)
+  {
+    ret = h->list[0];
+    h->list[0] = NULL;
+    h->list_len = 0;
+  }
+  else /* if (h->list_len > 1) */
+  {
+    ret = h->list[0];
+    h->list[0] = h->list[h->list_len - 1];
+    h->list[h->list_len - 1] = NULL;
+    h->list_len--;
+
+    reheap (h, /* root = */ 0, DIR_DOWN);
+  }
+
+  /* free some memory */
+  if ((h->list_len + 32) < h->list_size)
+  {
+    void **tmp;
+
+    tmp = realloc (h->list, (h->list_len + 16) * sizeof (*h->list));
+    if (tmp != NULL)
+    {
+      h->list = tmp;
+      h->list_size = h->list_len + 16;
+    }
+  }
+
+  pthread_mutex_unlock (&h->lock);
+
+  return (ret);
+} /* void *c_head_get_root */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
diff --git a/src/utils_heap.h b/src/utils_heap.h
new file mode 100644 (file)
index 0000000..dd0f486
--- /dev/null
@@ -0,0 +1,96 @@
+/**
+ * collectd - src/utils_heap.h
+ * Copyright (C) 2009  Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Florian octo Forster <octo at verplant.org>
+ **/
+
+#ifndef UTILS_HEAP_H
+#define UTILS_HEAP_H 1
+
+struct c_heap_s;
+typedef struct c_heap_s c_heap_t;
+
+/*
+ * NAME
+ *   c_heap_create
+ *
+ * DESCRIPTION
+ *   Allocates a new heap.
+ *
+ * PARAMETERS
+ *   `compare'  The function-pointer `compare' is used to compare two keys. It
+ *              has to return less than zero if it's first argument is smaller
+ *              then the second argument, more than zero if the first argument
+ *              is bigger than the second argument and zero if they are equal.
+ *              If your keys are char-pointers, you can use the `strcmp'
+ *              function from the libc here.
+ *
+ * RETURN VALUE
+ *   A c_heap_t-pointer upon success or NULL upon failure.
+ */
+c_heap_t *c_heap_create (int (*compare) (const void *, const void *));
+
+/*
+ * NAME
+ *   c_heap_destroy
+ *
+ * DESCRIPTION
+ *   Deallocates a heap. Stored value- and key-pointer are lost, but of course
+ *   not freed.
+ */
+void c_heap_destroy (c_heap_t *h);
+
+/*
+ * NAME
+ *   c_heap_insert
+ *
+ * DESCRIPTION
+ *   Stores the key-value-pair in the heap pointed to by `h'.
+ *
+ * PARAMETERS
+ *   `h'        Heap to store the data in.
+ *   `ptr'      Value to be stored. This is typically a pointer to a data
+ *              structure. The data structure is of course *not* copied and may
+ *              not be free'd before the pointer has been removed from the heap
+ *              again.
+ *
+ * RETURN VALUE
+ *   Zero upon success, non-zero otherwise. It's less than zero if an error
+ *   occurred or greater than zero if the key is already stored in the tree.
+ */
+int c_heap_insert (c_heap_t *h, void *ptr);
+
+/*
+ * NAME
+ *   c_head_get_root
+ *
+ * DESCRIPTION
+ *   Removes the value at the root of the heap and returns both, key and value.
+ *
+ * PARAMETERS
+ *   `h'           Heap to remove key-value-pair from.
+ *
+ * RETURN VALUE
+ *   The pointer passed to `c_heap_insert' or NULL if there are no more
+ *   elements in the heap (or an error occurred).
+ */
+void *c_head_get_root (c_heap_t *h);
+
+#endif /* UTILS_HEAP_H */
+/* vim: set sw=2 sts=2 et : */