Alvaro Barcellos <alvaro.barcellos at gmail.com>
- Don't-fork patch.
+Amit Gupta <amit.gupta221 at gmail.com>
+ - Multiple servers in the apache plugin.
+
Anthony Gialluca <tonyabg at charter.net>
- apcups plugin.
- jcollectd (two-way JMX integration).
- A few other patches to various plugins.
+Edward “Koko” Konetzko <konetzed at quixoticagony.com>
+ - fscache plugin.
+
Fabian Linzberger <e at lefant.net>
- Percentage aggregation for `collectd-nagios'.
Flavio Stanchina <flavio at stanchina.net>
- mbmon plugin.
+Franck Lombardi
+ - UNIX socket code for the memcached plugin.
+
Jason Pepas <cell at ices.utexas.edu>
- nfs plugin.
Lyonel Vincent <lyonel at ezix.org>
- processes plugin.
+Marco Chiappero <marco at absence.it>
+ - uptime plugin.
+ - ip6tables support in the iptables plugin.
+
Michael Stapelberg <michael+git at stapelberg.de>
- OpenBSD port of the tcpconns plugin.
Roman Klesel <roman.klesel at noris.de>
- Oracle schema and sample SQL statements to be used with the Oracle plugin.
+Rodolphe Quiédeville <rquiedeville at bearstech.com>
+ - Lock statistics in the mysql plugin.
+
Scott Garrett <sgarrett at technomancer.com>
- tape plugin.
+Simon Kuhnle <simon at blarzwurst.de>
+ - OpenBSD code for the cpu and memory plugins.
+
Sjoerd van der Berg <harekiet at gmail.com>
- iptables plugin.
Stefan Hacker <stefan.hacker at web.de>
- teamspeak2 plugin.
+Tomasz Pala <gotar at pld-linux.org>
+ - conntrack plugin.
+
Tommie Gannert <d00-tga at d.kth.se>
- PID-file patch.
+2009-06-02, Version 4.7.1
+ * Build system: Detection of Java has been improved and missing
+ details have been added to the configuration summary. Support for
+ libtool 2.2 has been added.
+ * collectd: Two bugs with the threshold checking have been fixed. The
+ first one prevented thresholds to be checked at all, the second one
+ caused wrong behavior with the persistency option. Thanks to Andrés
+ J. Díaz for fixing these problems.
+ * collectd: Handling of the `Include' configuration option has been
+ fixed.
+ * rrdtool plugin: Make sure initialization is run only once. This
+ resolves problems under Solaris and potentially other systems.
+ Thanks to Amit Gupta for reporting this bug.
+ * java plugin: Make it possible to use dots ('.') instead of slashes
+ ('/') as the class separator. Thanks to Randy Rizun for pointing
+ this out.
+ * swap plugin: A work-around for 32-bit Solaris has been added. Thanks
+ to Doug MacEachern for the patch.
+
+2009-05-11, Version 4.7.0
+ * apache plugin: Support to query multiple servers has been added.
+ Thanks to Amit Gupta for the patch.
+ * apache plugin: Handling of lighttpd's scoreboard statistics has been
+ improved. Thanks to Amit Gupta for the patch.
+ * conntrack plugin: The new conntrack plugin collects the connection
+ tracking table size. Thanks to Tomasz Pala for the patch.
+ * fscache plugin: The new fscache plugin collects statistics about
+ Linux' file-system based caching framework. Thanks to Edward
+ Konetzko for the patch.
+ * gmond plugin: The new gmond plugin can receive and interpret
+ multicast traffic from Ganglia's gmond daemon.
+ * java plugin: The new java plugin exports the collectd API to Java,
+ making it possible to write extensions to collectd in Java.
+ * memcachec plugin: The new memcachec plugin queries data from a
+ memcached daemon and parses it similar to the cURL plugin. Thanks to
+ Doug MacEachern for the initial code.
+ * memcached plugin: Support for connections over UNIX domain sockets
+ has been added. Thanks to Franck Lombardi for the patch.
+ * memory plugin: Support for OpenBSD and possibly other *BSDs has been
+ added. Thanks to Simon Kuhnle for the patch.
+ * mysql plugin: Support to query multiple databases has been added.
+ Thanks to Doug MacEachern for the patch.
+ * mysql plugin: Master/slave statistics have been added.
+ * mysql plugin: Lock statistics have been added. Thanks to Rodolphe
+ Quiédeville for the patch.
+ * network plugin: The possibility to sign or encrypt network traffic
+ has been added.
+ * protocols plugin: The new protocols plugin provides information
+ about network protocols, such as IP, TCP and UDP.
+ * snmp plugin: The intervals given in the configuration of the SNMP
+ plugin must no longer be a multiple of the global interval.
+ * table plugin: The new Table plugin provides parsing for table-like
+ structured files, such as many files beneath /proc.
+ * ted plugin: The new TED plugin reads power consumption measurements
+ from “The Energy Detective” (TED). Thanks to Eric Reed for this
+ plugin.
+ * onewire plugin: The new `Interval' option allows collecting
+ information from OneWire sensors at arbitrary intervals.
+ * ping plugin: Support for collecting the drop rate and standard
+ deviation of round-trip times has been added.
+ * uptime plugin: The new uptime plugin can collect the server's
+ uptime. Thanks to Marco Chiappero for the patch.
+
2009-06-02, Version 4.6.3
* Build system, various plugins: Many build fixes for FreeBSD,
OpenBSD, NetBSD, Solaris and Mac OS X. Big thanks to Doug MacEachern
Name server and resolver statistics from the `statistics-channel'
interface of BIND 9.5, 9,6 and later.
+ - conntrack
+ Number of nf_conntrack entries.
+
- cpu
CPU utilization: Time spent in the system, user, nice, idle, and related
states.
- filecount
Count the number of files in directories.
+ - fscache
+ Linux file-system based caching framework statistics.
+
+ - gmond
+ Receive multicast traffic from Ganglia instances.
+
- hddtemp
Harddisk temperatures using hddtempd.
- irq
IRQ counters: Frequency in which certain interrupts occur.
+ - java
+ Integrates a `Java Virtual Machine' (JVM) to execute plugins in Java
+ bytecode. See “Configuring with libjvm” below.
+
- load
System load average over the last 1, 5 and 15 minutes.
Motherboard sensors: temperature, fanspeed and voltage information,
using mbmon(1).
+ - memcachec
+ Query and parse data from a memcache daemon (memcached).
+
- memcached
Statistics of the memcached distributed caching system.
<http://www.danga.com/memcached/>
- 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.
- swap
Pages swapped out onto harddisk or whatever is called `swap' by the OS..
+ - table
+ Parse table-like structured files.
+
- tail
Follows (tails) logfiles, parses them by lines and submits matched
values.
- teamspeak2
TeamSpeak2 server statistics.
+ - ted
+ Plugin to read values from `The Energy Detective' (TED).
+
- thermal
Linux ACPI thermal zone information.
+ - uptime
+ System uptime statistics.
+
- users
Users currently logged in.
For the `notify_email' plugin.
<http://www.stafford.uklinux.net/libesmtp/>
+ * libganglia (optional)
+ Used by the `gmond' plugin to process data received from Ganglia.
+
+ * libgcrypt (optional)
+ Used by the `network' plugin for encryption and authentication.
+
* libhal (optional)
If present, the uuid plugin will check for UUID from HAL.
<http://hal.freedesktop.org/>
For querying iptables counters.
<http://netfilter.org/>
+ * libjvm (optional)
+ Library that encapsulates the `Java Virtual Machine' (JVM). This library is
+ used by the Java plugin to execute Java bytecode. See “Configuring with
+ libjvm” below.
+
+ * libmemcached (optional)
+ Used by the `memcachec' plugin to connect to a memcache daemon.
+
* libmysqlclient (optional)
Unsurprisingly used by the `mysql' plugin.
<http://dev.mysql.com/>
will be enabled). To enable a plugin, install missing dependencies (see
section `Prerequisites' above) and rerun `configure'. If you specify the
`--enable-<plugin>' configure option, the script will fail if the depen-
- dencies for the specified plugin are not met. If you specify the
- `--disable-<plugin>' configure option, the plugin will not be built. Both
- options are meant for package maintainers and should not be used in everyday
- situations.
+ dencies for the specified plugin are not met. In that case you can force the
+ plugin to be built using the `--enable-<plugin>=force' configure option.
+ This will most likely fail though unless you're working in a very unusual
+ setup and you really know what you're doing. If you specify the
+ `--disable-<plugin>' configure option, the plugin will not be built. If you
+ specify the `--enable-all-plugins' or `--disable-all-plugins' configure
+ options, all plugins will be enabled or disabled respectively by default.
+ Explicitly enabling or disabling a plugin overwrites the default for the
+ specified plugin. These options are meant for package maintainers and should
+ not be used in everyday situations.
By default, collectd will be installed into `/opt/collectd'. You can adjust
this setting by specifying the `--prefix' configure option - see INSTALL for
prefixed to all installation directories. This might be useful when creating
packages for collectd.
+Configuring with libjvm
+-----------------------
+
+ To determine the location of the required files of a Java installation is not
+ an easy task, because the locations vary with your kernel (Linux, SunOS, …)
+ and with your architecture (x86, SPARC, …) and there is no ‘java-config’
+ script we could use. Configuration of the JVM library is therefore a bit
+ tricky.
+
+ The easiest way to use the `--with-java=$JAVA_HOME' option, where
+ `$JAVA_HOME' is usually something like:
+ /usr/lib/jvm/java-1.5.0-sun-1.5.0.14
+
+ The configure script will then use find(1) to look for the following files:
+
+ - jni.h
+ - jni_md.h
+ - libjvm.so
+
+ If found, appropriate CPP-flags and LD-flags are set and the following
+ library checks succeed.
+
+ If this doesn't work for you, you have the possibility to specify CPP-flags,
+ C-flags and LD-flags for the ‘Java’ plugin by hand, using the following three
+ (environment) variables:
+
+ - JAVA_CPPFLAGS
+ - JAVA_CFLAGS
+ - JAVA_LDFLAGS
+
+ For example (shortened for demonstration purposes):
+
+ ./configure JAVA_CPPFLAGS="-I$JAVA_HOME/include -I$JAVA_HOME/include/linux"
+
+ Adding "-ljvm" to the JAVA_LDFLAGS is done automatically, you don't have to
+ do that.
Crosscompiling
--------------
+SUBDIRS =
+
+if BUILD_WITH_JAVA
+SUBDIRS += java
+endif
+
EXTRA_DIST = perl/Collectd.pm perl/Makefile.PL perl/Collectd/Makefile.PL \
perl/Collectd/Unixsock.pm
--- /dev/null
+EXTRA_DIST = org/collectd/api/CollectdConfigInterface.java \
+ org/collectd/api/CollectdFlushInterface.java \
+ org/collectd/api/CollectdInitInterface.java \
+ org/collectd/api/Collectd.java \
+ org/collectd/api/CollectdLogInterface.java \
+ org/collectd/api/CollectdMatchFactoryInterface.java \
+ org/collectd/api/CollectdMatchInterface.java \
+ org/collectd/api/CollectdNotificationInterface.java \
+ org/collectd/api/CollectdReadInterface.java \
+ org/collectd/api/CollectdShutdownInterface.java \
+ org/collectd/api/CollectdTargetFactoryInterface.java \
+ org/collectd/api/CollectdTargetInterface.java \
+ org/collectd/api/CollectdWriteInterface.java \
+ org/collectd/api/DataSet.java \
+ org/collectd/api/DataSource.java \
+ org/collectd/api/Notification.java \
+ org/collectd/api/OConfigItem.java \
+ org/collectd/api/OConfigValue.java \
+ org/collectd/api/PluginData.java \
+ org/collectd/api/ValueList.java
+
+java-build-stamp: org/collectd/api/*.java
+ $(JAVAC) -d "." "$(srcdir)/org/collectd/api"/*.java
+ touch "$@"
+
+all-local: java-build-stamp
+
+install-exec-local: java-build-stamp
+ mkdir -p "$(pkgdatadir)/java/org/collectd/api"
+ $(INSTALL) -m 644 "org/collectd/api"/*.class \
+ "$(DESTDIR)$(pkgdatadir)/java/org/collectd/api/"
+
+clean-local:
+ rm -f "org/collectd/api"/*.class
+ rm -f "java-build-stamp"
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ */
+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 : */
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @see Collectd#registerConfig(String, CollectdConfigInterface)
+ */
+public interface CollectdConfigInterface
+{
+ public int config (OConfigItem ci);
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @see Collectd#registerFlush
+ */
+public interface CollectdFlushInterface
+{
+ public int flush (int timeout, String identifier);
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @see Collectd#registerInit
+ */
+public interface CollectdInitInterface
+{
+ public int init ();
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @see Collectd#registerLog
+ */
+public interface CollectdLogInterface
+{
+ public void log (int severity, String message);
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @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);
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @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 */
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @see Collectd#registerNotification
+ */
+public interface CollectdNotificationInterface
+{
+ public int notification (Notification n);
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @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 ();
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @see Collectd#registerShutdown
+ */
+public interface CollectdShutdownInterface
+{
+ public int shutdown ();
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @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);
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @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 */
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ * @see Collectd#registerWrite
+ */
+public interface CollectdWriteInterface
+{
+ public int write (ValueList vl);
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ */
+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 : */
--- /dev/null
+/*
+ * 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 : */
--- /dev/null
+/*
+ * 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();
+ }
+}
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ */
+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 : */
--- /dev/null
+/*
+ * 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 <octo at verplant.org>
+ */
+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 : */
--- /dev/null
+/*
+ * 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();
+ }
+}
--- /dev/null
+/*
+ * 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 : */
--- /dev/null
+/*
+ * 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 : */
&& 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
if test "x$ac_system" = "xSolaris"
then
- CPPFLAGS="$CPPFLAGS -D_POSIX_PTHREAD_SEMANTICS"
+ AC_DEFINE(_POSIX_PTHREAD_SEMANTICS, 1, [Define to enforce POSIX thread semantics under Solaris.])
fi
# Where to install .pc files.
pkgconfigdir="${libdir}/pkgconfig"
AC_SUBST(pkgconfigdir)
+# Check for standards compliance mode
+AC_ARG_ENABLE(standards,
+ AS_HELP_STRING([--enable-standards], [Enable standards compliance mode]),
+ [enable_standards="$enableval"],
+ [enable_standards="no"])
+if test "x$enable_standards" = "xyes"
+then
+ AC_DEFINE(_ISOC99_SOURCE, 1, [Define to enforce ISO C99 compliance.])
+ AC_DEFINE(_POSIX_C_SOURCE, 200112L, [Define to enforce POSIX.1-2001 compliance.])
+ AC_DEFINE(_XOPEN_SOURCE, 600, [Define to enforce X/Open 6 (XSI) compliance.])
+ AC_DEFINE(_REENTRANT, 1, [Define to enable reentrancy interfaces.])
+fi
+AM_CONDITIONAL(BUILD_FEATURE_STANDARDS, test "x$enable_standards" = "xyes")
+
#
# Checks for header files.
#
#endif
])
-AC_CHECK_HEADERS(pwd.h grp.h sys/un.h ctype.h limits.h sys/quota.h xfs/xqm.h fs_info.h fshelp.h paths.h mntent.h mnttab.h sys/fstyp.h sys/fs_types.h sys/mntent.h sys/mnttab.h sys/statfs.h sys/statvfs.h sys/vfs.h sys/vfstab.h kvm.h wordexp.h)
+AC_CHECK_HEADERS(pwd.h grp.h sys/un.h ctype.h limits.h xfs/xqm.h fs_info.h fshelp.h paths.h mntent.h mnttab.h sys/fstyp.h sys/fs_types.h sys/mntent.h sys/mnttab.h sys/statfs.h sys/statvfs.h sys/vfs.h sys/vfstab.h kvm.h wordexp.h)
# For the dns plugin
AC_CHECK_HEADERS(arpa/nameser.h)
])
AC_CHECK_MEMBERS([struct udphdr.uh_dport, struct udphdr.uh_sport], [], [],
-[#if HAVE_STDINT_H
+[#define _BSD_SOURCE
+#if HAVE_STDINT_H
# include <stdint.h>
#endif
#if HAVE_SYS_TYPES_H
#endif
])
AC_CHECK_MEMBERS([struct udphdr.dest, struct udphdr.source], [], [],
-[#if HAVE_STDINT_H
+[#define _BSD_SOURCE
+#if HAVE_STDINT_H
# include <stdint.h>
#endif
#if HAVE_SYS_TYPES_H
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)"])
+
+ if test "$with_libgcrypt" != "no"; then
+ AM_PATH_LIBGCRYPT(1:1.2.0,,with_libgcrypt="no (version 1.2.0+ required)")
+ fi
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
+
+if test "x$with_libgcrypt" = "xyes"
+then
+ AC_DEFINE(HAVE_LIBGCRYPT, 1, [Define to 1 if you have the gcrypt library (-lgcrypt).])
+fi
+
+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.])],
fi
# }}}
+# --with-java {{{
+with_java_home="$JAVA_HOME"
+with_java_vmtype="client"
+with_java_cflags=""
+with_java_libs=""
+JAVAC="$JAVAC"
+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
+ AC_MSG_CHECKING([for jni.h])
+ TMPDIR=`find -L "$with_java_home" -name jni.h -type f -exec 'dirname' '{}' ';' | head -n 1`
+ if test "x$TMPDIR" != "x"
+ then
+ AC_MSG_RESULT([found in $TMPDIR])
+ JAVA_CPPFLAGS="$JAVA_CPPFLAGS -I$TMPDIR"
+ else
+ AC_MSG_RESULT([not found])
+ fi
+
+ AC_MSG_CHECKING([for jni_md.h])
+ TMPDIR=`find -L "$with_java_home" -name jni_md.h -type f -exec 'dirname' '{}' ';' | head -n 1`
+ if test "x$TMPDIR" != "x"
+ then
+ AC_MSG_RESULT([found in $TMPDIR])
+ JAVA_CPPFLAGS="$JAVA_CPPFLAGS -I$TMPDIR"
+ else
+ AC_MSG_RESULT([not found])
+ fi
+
+ AC_MSG_CHECKING([for libjvm.so])
+ TMPDIR=`find -L "$with_java_home" -name libjvm.so -type f -exec 'dirname' '{}' ';' | head -n 1`
+ if test "x$TMPDIR" != "x"
+ then
+ AC_MSG_RESULT([found in $TMPDIR])
+ JAVA_LDFLAGS="$JAVA_LDFLAGS -L$TMPDIR"
+ else
+ AC_MSG_RESULT([not found])
+ fi
+
+ if test "x$JAVAC" = "x"
+ then
+ AC_MSG_CHECKING([for javac])
+ TMPDIR=`find -L "$with_java_home" -name javac -type f | head -n 1`
+ if test "x$TMPDIR" != "x"
+ then
+ JAVAC="$TMPDIR"
+ AC_MSG_RESULT([$JAVAC])
+ else
+ AC_MSG_RESULT([not found])
+ fi
+ 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
+if test "x$JAVAC" = "x"
+then
+ with_javac_path="$PATH"
+ if test "x$with_java_home" != "x"
+ then
+ with_javac_path="$with_java_home:with_javac_path"
+ if test -d "$with_java_home/bin"
+ then
+ with_javac_path="$with_java_home/bin:with_javac_path"
+ fi
+ fi
+
+ AC_PATH_PROG(JAVAC, javac, [], "$with_javac_path")
+fi
+if test "x$JAVAC" = "x"
+then
+ with_java="no (javac not found)"
+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=""
# }}}
# --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 {{{
LDFLAGS=$SAVE_LDFLAGS
fi
-c_cv_have_broken_perl_load_module="no"
if test "x$with_libperl" = "xyes"
then
SAVE_CFLAGS=$CFLAGS
[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"
[AC_PLUGIN],
[
enable_plugin="no"
+ force="no"
AC_ARG_ENABLE([$1], AC_HELP_STRING([--enable-$1], [$3]),
[
if test "x$enableval" = "xyes"
then
enable_plugin="yes"
- else
- enable_plugin="no"
- fi
- ],
- [
- if test "x$2" = "xyes"
+ else if test "x$enableval" = "xforce"
then
enable_plugin="yes"
+ force="yes"
else
enable_plugin="no"
- fi
+ fi; fi
+ ],
+ [
+ if test "x$enable_all_plugins" = "xauto"
+ then
+ if test "x$2" = "xyes"
+ then
+ enable_plugin="yes"
+ else
+ enable_plugin="no"
+ fi
+ else
+ enable_plugin="$enable_all_plugins"
+ fi
])
if test "x$enable_plugin" = "xyes"
then
- if test "x$2" = "xyes"
+ if test "x$2" = "xyes" || test "x$force" = "xyes"
then
AC_DEFINE([HAVE_PLUGIN_]my_toupper([$1]), 1, [Define to 1 if the $1 plugin is enabled.])
+ if test "x$2" != "xyes"
+ then
+ dependency_warning="yes"
+ fi
else # User passed "yes" but dependency checking yielded "no" => Dependency problem.
dependency_error="yes"
enable_plugin="no (dependency error)"
AC_COLLECTD([daemon], [disable], [feature], [daemon mode])
AC_COLLECTD([getifaddrs],[enable], [feature], [getifaddrs under Linux])
+dependency_warning="no"
dependency_error="no"
+
plugin_ascent="no"
plugin_battery="no"
plugin_bind="no"
+plugin_conntrack="no"
plugin_cpu="no"
plugin_cpufreq="no"
plugin_df="no"
plugin_memory="no"
plugin_multimeter="no"
plugin_nfs="no"
+plugin_fscache="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"
if test "x$ac_system" = "xLinux"
then
plugin_battery="yes"
+ plugin_conntrack="yes"
plugin_cpu="yes"
plugin_cpufreq="yes"
plugin_disk="yes"
plugin_load="yes"
plugin_memory="yes"
plugin_nfs="yes"
+ plugin_fscache="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"
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"
if test "x$have_sysctl" = "xyes"
then
plugin_cpu="yes"
+ plugin_memory="yes"
plugin_swap="yes"
+ plugin_uptime="yes"
fi
if test "x$have_sysctlbyname" = "xyes"
then
if test "x$have_termios_h" = "xyes"
then
plugin_multimeter="yes"
+ plugin_ted="yes"
fi
if test "x$have_thread_info" = "xyes"
m4_divert_once([HELP_ENABLE], [
collectd plugins:])
+AC_ARG_ENABLE([all-plugins],
+ AC_HELP_STRING([--enable-all-plugins],
+ [enable all plugins (auto by def)]),
+ [
+ if test "x$enableval" = "xyes"
+ then
+ enable_all_plugins="yes"
+ else if test "x$enableval" = "xauto"
+ then
+ enable_all_plugins="auto"
+ else
+ enable_all_plugins="no"
+ fi; fi
+ ],
+ [enable_all_plugins="auto"])
+
+m4_divert_once([HELP_ENABLE], [])
+
AC_PLUGIN([apache], [$with_libcurl], [Apache httpd statistics])
AC_PLUGIN([apcups], [yes], [Statistics of UPSes by APC])
AC_PLUGIN([apple_sensors], [$with_libiokit], [Apple's hardware sensors])
AC_PLUGIN([ascent], [$plugin_ascent], [AscentEmu player statistics])
AC_PLUGIN([battery], [$plugin_battery], [Battery statistics])
AC_PLUGIN([bind], [$plugin_bind], [ISC Bind nameserver statistics])
+AC_PLUGIN([conntrack], [$plugin_conntrack], [nf_conntrack statistics])
AC_PLUGIN([cpufreq], [$plugin_cpufreq], [CPU frequency statistics])
AC_PLUGIN([cpu], [$plugin_cpu], [CPU usage statistics])
AC_PLUGIN([csv], [yes], [CSV output plugin])
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([fscache], [$plugin_fscache], [fscache statistics])
+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])
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])
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])
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])
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])
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"
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 bindings/java/Makefile)
if test "x$with_librrd" = "xyes" \
&& test "x$librrd_threadsafe" != "xyes"
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)"
libcurl . . . . . . . $with_libcurl
libdbi . . . . . . . $with_libdbi
libesmtp . . . . . . $with_libesmtp
+ libganglia . . . . . $with_libganglia
+ libgcrypt . . . . . . $with_libgcrypt
libiokit . . . . . . $with_libiokit
libiptc . . . . . . . $with_libiptc
+ libjvm . . . . . . . $with_java
libkstat . . . . . . $with_kstat
libkvm . . . . . . . $with_libkvm
+ libmemcached . . . . $with_libmemcached
libmysql . . . . . . $with_libmysql
libnetlink . . . . . $with_libnetlink
libnetsnmp . . . . . $with_libnetsnmp
ascent . . . . . . . $enable_ascent
battery . . . . . . . $enable_battery
bind . . . . . . . . $enable_bind
+ conntrack . . . . . . $enable_conntrack
cpu . . . . . . . . . $enable_cpu
cpufreq . . . . . . . $enable_cpufreq
csv . . . . . . . . . $enable_csv
entropy . . . . . . . $enable_entropy
exec . . . . . . . . $enable_exec
filecount . . . . . . $enable_filecount
+ fscache . . . . . . . $enable_fscache
+ 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
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
postgresql . . . . . $enable_postgresql
powerdns . . . . . . $enable_powerdns
processes . . . . . . $enable_processes
+ protocols . . . . . . $enable_protocols
rrdcached . . . . . . $enable_rrdcached
rrdtool . . . . . . . $enable_rrdtool
sensors . . . . . . . $enable_sensors
snmp . . . . . . . . $enable_snmp
swap . . . . . . . . $enable_swap
syslog . . . . . . . $enable_syslog
+ table . . . . . . . . $enable_table
tail . . . . . . . . $enable_tail
tape . . . . . . . . $enable_tape
target_notification . $enable_target_notification
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
EOF
if test "x$dependency_error" = "xyes"; then
- AC_MSG_ERROR("Some plugins are missing dependencies - see above summary for details")
+ AC_MSG_ERROR("Some plugins are missing dependencies - see the summary above for details")
+fi
+
+if test "x$dependency_warning" = "xyes"; then
+ AC_MSG_WARN("Some plugins seem to have missing dependencies but have been enabled forcibly - see the summary above for details")
fi
# vim: set fdm=marker :
interesting. Please note that no sanity- checking whatsoever is performed. You
can seriously fuck up your RRD files if you don't know what you're doing.
+collectd-network.py
+-------------------
+
+ This Python module by Adrian Perez implements the collectd network protocol
+in pure Python. It currently supports to receive data and notifications from
+collectd.
+
+collectd-unixsock.py
+--------------------
+
+ This Python module by Clay Loveless provides an interface to collect's
+unixsock plugin.
+
collectd2html.pl
----------------
This script by Vincent Stehlé will search for RRD files in
--- /dev/null
+#-*- 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)
+
'GPRINT:max:MAX:%4.1lf Max,',
'GPRINT:avg:LAST:%4.1lf Last\l'
],
+ conntrack => ['-v', 'Entries',
+ 'DEF:avg={file}:entropy:AVERAGE',
+ 'DEF:min={file}:entropy:MIN',
+ 'DEF:max={file}:entropy:MAX',
+ "AREA:max#$HalfBlue",
+ "AREA:min#$Canvas",
+ "LINE1:avg#$FullBlue:Count",
+ 'GPRINT:min:MIN:%4.0lf Min,',
+ 'GPRINT:avg:AVERAGE:%4.0lf Avg,',
+ 'GPRINT:max:MAX:%4.0lf Max,',
+ 'GPRINT:avg:LAST:%4.0lf Last\l'
+ ],
entropy => ['-v', 'Bits',
'DEF:avg={file}:entropy:AVERAGE',
'DEF:min={file}:entropy:MIN',
RRDVerticalLabel "Queries/s"
RRDFormat "%6.1lf"
</Type>
+<Type conntrack>
+ DataSources conntrack
+ DSName conntrack Conntrack count
+ RRDTitle "nf_conntrack connections on {hostname}"
+ RRDVerticalLabel "Count"
+ RRDFormat "%4.0lf"
+</Type>
<Type entropy>
DataSources entropy
DSName entropy Entropy bits
<Type mysql_commands>
Module GenericStacked
DataSources value
- RRDTitle "MySQL commands"
+ RRDTitle "MySQL commands ({plugin_instance})"
RRDVerticalLabel "Invocations"
RRDFormat "%6.2lf"
<Type mysql_handler>
Module GenericStacked
DataSources value
- RRDTitle "MySQL handler"
+ RRDTitle "MySQL handler ({plugin_instance})"
RRDVerticalLabel "Invocations"
RRDFormat "%6.2lf"
DSName commit commit
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
%attr(0644,root,root) %{_libdir}/%{name}/battery.so*
%attr(0644,root,root) %{_libdir}/%{name}/battery.la
+%attr(0644,root,root) %{_libdir}/%{name}/conntrack.so*
+%attr(0644,root,root) %{_libdir}/%{name}/conntrack.la
+
%attr(0644,root,root) %{_libdir}/%{name}/cpufreq.so*
%attr(0644,root,root) %{_libdir}/%{name}/cpufreq.la
label.removeChild(label.childNodes[--childCnt]);
label.appendChild(document.createTextNode(label_txt));
}
+ GraphPositionToolbox(null);
}
var req = null;
newOption.value = options[i].firstChild ? options[i].firstChild.data : '';
if (keepSelection && newOption.value == oldValue)
newOption.setAttribute('selected', 'selected');
- if (keepSelection && optCnt == 1 && newOption.value == '@') {
+ if (newOption.value[0] == '@') {
newOption.setAttribute('style', 'font-style: italic');
- newOption.appendChild(document.createTextNode('Meta graph'));
+ if (newOption.value == '@' || newOption.value == '@merge')
+ newOption.appendChild(document.createTextNode('Meta graph'));
+ else if (newOption.value == '@all')
+ newOption.appendChild(document.createTextNode('All entries'));
+ else if (newOption.value == '@merge_sum')
+ newOption.appendChild(document.createTextNode('Meta summed graph'));
+ else if (newOption.value == '@merge_avg')
+ newOption.appendChild(document.createTextNode('Meta averaged graph'));
+ else if (newOption.value == '@merge_stack')
+ newOption.appendChild(document.createTextNode('Meta stacked graph'));
+ else if (newOption.value == '@merge_line')
+ newOption.appendChild(document.createTextNode('Meta lines graph'));
+ else
+ newOption.appendChild(document.createTextNode(newOption.value));
} else
newOption.appendChild(document.createTextNode(newOption.value));
select.appendChild(newOption);
var time_list = document.getElementById('timespan');
var timespan = time_list.selectedIndex >= 0 ? time_list.options[time_list.selectedIndex].value : '';
var tinyLegend = document.getElementById('tinylegend').checked;
- var logarithmic = document.getElementById('logarithmic').checked
- GraphDoAppend(host, plugin, pinst, type, tinst, timespan, tinyLegend, logarithmic);
+ var logarithmic = document.getElementById('logarithmic').checked;
+ if (host[0] == '@' || plugin[0] == '@' || pinst[0] == '@' || type[0] == '@' || (tinst[0] == '@' && tinst.substr(0, 5) != '@merge')) {
+ var query = 'action=list_graphs&host='+encodeURIComponent(host)+'&plugin='+encodeURIComponent(plugin)+'&plugin_instance='+encodeURIComponent(pinst);
+ query = query+'&type='+encodeURIComponent(type)+'&type_instance='+encodeURIComponent(tinst)+'×pan='+encodeURIComponent(timespan);
+ query = query+(logarithmic ? '&logarithmic=1' : '')+(tinyLegend ? '&tinylegend=1' : '');
+ loadXMLDoc(dhtml_url, query);
+ } else
+ GraphDoAppend(host, plugin, pinst, type, tinst, timespan, tinyLegend, logarithmic);
+}
+
+function ListOfGraph(response) {
+ var graphs = response ? response.getElementsByTagName('graph') : null;
+ if (graphs && graphs.length > 0) {
+ for (i = 0; i < graphs.length; i++)
+ GraphDoAppend(graphs[i].getAttribute('host'), graphs[i].getAttribute('plugin'), graphs[i].getAttribute('plugin_instance'),
+ graphs[i].getAttribute('type'), graphs[i].getAttribute('type_instance'), graphs[i].getAttribute('timespan'),
+ graphs[i].getAttribute('tinyLegend') == '1', graphs[i].getAttribute('logarithmic') == '1');
+ } else
+ alert('No graph found for adding');
}
function GraphDoAppend(host, plugin, pinst, type, tinst, timespan, tinyLegend, logarithmic) {
newGraph.setAttribute('class', 'graph');
newGraph.setAttribute('id', graph_id);
// Graph cell + graph
- newDiv = document.createElement('div');
- newDiv.setAttribute('class', 'graph_img');
newImg = document.createElement('img');
newImg.setAttribute('src', graph_src);
newImg.setAttribute('alt', graph_alt);
newImg.setAttribute('title', graph_title);
- newDiv.appendChild(newImg);
- newGraph.appendChild(newDiv);
- // Graph tools
- newDiv = document.createElement('div');
- newDiv.setAttribute('class', 'graph_opts');
- // - move up
- newImg = document.createElement('img');
- newImg.setAttribute('src', 'move-up.png');
- newImg.setAttribute('alt', 'UP');
- newImg.setAttribute('title', 'Move graph up');
- newA = document.createElement('a');
- newA.setAttribute('href', 'javascript:GraphMoveUp("'+graph_id+'")');
- newA.appendChild(newImg);
- newDiv.appendChild(newA);
- newDiv.appendChild(document.createElement('br'));
- // - refresh
- newImg = document.createElement('img');
- newImg.setAttribute('src', 'refresh.png');
- newImg.setAttribute('alt', 'R');
- newImg.setAttribute('title', 'Refresh graph');
- newA = document.createElement('a');
- newA.setAttribute('href', 'javascript:GraphRefresh("'+graph_id+'")');
- newA.appendChild(newImg);
- newDiv.appendChild(newA);
- newDiv.appendChild(document.createElement('br'));
- // - remove
- newImg = document.createElement('img');
- newImg.setAttribute('src', 'delete.png');
- newImg.setAttribute('alt', 'RM');
- newImg.setAttribute('title', 'Remove graph');
- newA = document.createElement('a');
- newA.setAttribute('href', 'javascript:GraphRemove("'+graph_id+'")');
- newA.appendChild(newImg);
- newDiv.appendChild(newA);
- newDiv.appendChild(document.createElement('br'));
- // - move down
- newImg = document.createElement('img');
- newImg.setAttribute('src', 'move-down.png');
- newImg.setAttribute('alt', 'DN');
- newImg.setAttribute('title', 'Move graph down');
- newA = document.createElement('a');
- newA.setAttribute('href', 'javascript:GraphMoveDown("'+graph_id+'")');
- newA.appendChild(newImg);
- newDiv.appendChild(newA);
- newGraph.appendChild(newDiv);
-
+ newImg.setAttribute('onclick', 'GraphToggleTools("'+graph_id+'")');
+ newGraph.appendChild(newImg);
graphs.appendChild(newGraph);
}
document.getElementById('nograph').style.display = 'none';
RefreshButtons();
}
+function GraphToggleTools(graph) {
+ var graphId = document.getElementById('ge_graphid').value;
+ var ref_img = null;
+ if (graphId == graph || graph == '') {
+ ref_img = null;
+ } else {
+ var graphDiv = document.getElementById(graph);
+ var imgs = graphDiv ? graphDiv.getElementsByTagName('img') : null;
+ var imgCnt = imgs ? imgs.length : 0;
+ while (imgCnt > 0)
+ if (imgs[--imgCnt].parentNode.getAttribute('class') == 'graph')
+ ref_img = imgs[imgCnt];
+ }
+ if (ref_img) {
+ var ts_sel = document.getElementById('ge_timespan');
+ var src_url = ref_img.src;
+ var ge = document.getElementById('ge');
+ // Fix field values
+ var ts = src_url.match(/×pan=[^&]*/);
+ ts = ts ? ts[0].substr(10) : '';
+ document.getElementById('ge_graphid').value = graph;
+ document.getElementById('ge_tinylegend').checked = src_url.match(/&tinylegend=1/);
+ document.getElementById('ge_logarithmic').checked = src_url.match(/&logarithmic=1/);
+ for (i = 0; i < ts_sel.options.length; i++)
+ if (ts_sel.options[i].value == ts) {
+ ts_sel.selectedIndex = i;
+ break;
+ }
+ // show tools box and position it properly
+ ge.style.display = 'table';
+ GraphPositionToolbox(ref_img);
+ } else {
+ // hide tools box
+ document.getElementById('ge').style.display = 'none';
+ document.getElementById('ge_graphid').value = '';
+ }
+}
+
+function GraphPositionToolbox(ref_img) {
+ var ge = document.getElementById('ge');
+ if (ge.style.display != 'none') {
+ var wl = 0; var wt = 0;
+ var x = ref_img;
+ if (ref_img == null) {
+ var graphDiv = document.getElementById(document.getElementById('ge_graphid').value);
+ var imgs = graphDiv ? graphDiv.getElementsByTagName('img') : null;
+ var imgCnt = imgs ? imgs.length : 0;
+ while (imgCnt > 0)
+ if (imgs[--imgCnt].parentNode.getAttribute('class') == 'graph')
+ ref_img = imgs[imgCnt];
+
+ if (ref_img == null) {
+ document.getElementById('ge_graphid').value = '';
+ ge.style.display = 'none';
+ return;
+ } else
+ x = ref_img;
+ }
+ while (x != null) {
+ wl += x.offsetLeft;
+ wt += x.offsetTop;
+ x = x.offsetParent;
+ }
+ ge.style.left = (wl + (ref_img.offsetWidth - ge.offsetWidth) / 2)+'px';
+ ge.style.top = (wt + (ref_img.offsetHeight - ge.offsetHeight) / 2)+'px';
+ }
+}
+
+function GraphRefreshAll() {
+ var imgs = document.getElementById('graphs').getElementsByTagName('img');
+ var imgCnt = imgs.length;
+ var now = new Date();
+ var newTS = '&ts='+now.getTime();
+ while (imgCnt > 0)
+ if (imgs[--imgCnt].parentNode.getAttribute('class') == 'graph') {
+ var oldSrc = imgs[imgCnt].src;
+ var newSrc = oldSrc.replace(/&ts=[0-9]+/, newTS);
+ if (newSrc == oldSrc)
+ newSrc = newSrc + newTS;
+ imgs[imgCnt].setAttribute('src', newSrc);
+ }
+}
+
function GraphRefresh(graph) {
+ var graphElement = null;
if (graph == null) {
- var imgs = document.getElementById('graphs').getElementsByTagName('img');
+ var graphId = document.getElementById('ge_graphid').value;
+ if (graphId != '')
+ graphElement = document.getElementById(graphId);
+ } else
+ graphElement = document.getElementById(graph);
+ if (graphElement != null) {
+ var imgs = graphElement.getElementsByTagName('img');
var imgCnt = imgs.length;
- var now = new Date();
- var newTS = '&ts='+now.getTime();
while (imgCnt > 0)
- if (imgs[--imgCnt].parentNode.getAttribute('class') == 'graph_img') {
+ if (imgs[--imgCnt].parentNode.getAttribute('class') == 'graph') {
+ var now = new Date();
+ var newTS = '&ts='+now.getTime();
var oldSrc = imgs[imgCnt].src;
var newSrc = oldSrc.replace(/&ts=[0-9]+/, newTS);
if (newSrc == oldSrc)
- newSrc = newSrc + newTS;
+ newSrc = newSrc+newTS;
imgs[imgCnt].setAttribute('src', newSrc);
+ break;
}
- } else if (document.getElementById(graph)) {
- var imgs = document.getElementById(graph).getElementsByTagName('img');
+ }
+}
+
+function GraphAdjust(graph) {
+ var graphId = graph == null ? document.getElementById('ge_graphid').value : graph;
+ var graphElement = document.getElementById(graphId);
+ if (graphElement != null) {
+ var time_list = document.getElementById('ge_timespan');
+ var timespan = time_list.selectedIndex >= 0 ? time_list.options[time_list.selectedIndex].value : '';
+ var tinyLegend = document.getElementById('ge_tinylegend').checked;
+ var logarithmic = document.getElementById('ge_logarithmic').checked
+ var imgs = graphElement.getElementsByTagName('img');
var imgCnt = imgs.length;
+ var ref_img = null;
while (imgCnt > 0)
- if (imgs[--imgCnt].parentNode.getAttribute('class') == 'graph_img') {
+ if (imgs[--imgCnt].parentNode.getAttribute('class') == 'graph') {
var now = new Date();
var newTS = '&ts='+now.getTime();
var oldSrc = imgs[imgCnt].src;
- var newSrc = oldSrc.replace(/&ts=[0-9]+/, newTS);
+ var newSrc = oldSrc.replace(/&ts=[^&]*/, newTS);
if (newSrc == oldSrc)
newSrc = newSrc+newTS;
+ newSrc = newSrc.replace(/&logarithmic=[^&]*/, '');
+ if (logarithmic)
+ newSrc += '&logarithmic=1';
+ newSrc = newSrc.replace(/&tinylegend=[^&]*/, '');
+ if (tinyLegend)
+ newSrc += '&tinylegend=1';
+ newSrc = newSrc.replace(/×pan=[^&]*/, '');
+ if (timespan)
+ newSrc += '×pan='+encodeURIComponent(timespan);
imgs[imgCnt].setAttribute('src', newSrc);
+
+ var myList = Array();
+ for (i = 0; i < graphList.length; i++)
+ if (graphList[i].substring(0, graphId.length) == graphId && graphList[i].charAt(graphId.length) == ' ') {
+ newSrc = graphList[i];
+ newSrc = newSrc.replace(/&logarithmic=[^&]*/, '');
+ newSrc = newSrc.replace(/&tinylegend=[^&]*/, '');
+ newSrc = newSrc.replace(/×pan=[^&]*/, '');
+ newSrc = newSrc+(logarithmic ? '&logarithmic=1' : '')+(tinyLegend ? '&tinylegend=1' : '')+'×pan='+encodeURIComponent(timespan);
+ myList.push(newSrc);
+ continue;
+ } else
+ myList.push(graphList[i]);
+ graphList = myList;
+ window.setTimeout("GraphPositionToolbox(null)", 10);
+ // GraphPositionToolbox(imgs[imgCnt]);
break;
}
}
function GraphRemove(graph) {
var graphs = document.getElementById('graphs');
- if (document.getElementById(graph)) {
- graphs.removeChild(document.getElementById(graph));
+ var graphId = graph == null ? document.getElementById('ge_graphid').value : graph;
+ var graphElement = document.getElementById(graphId);
+ if (graphElement) {
+ GraphToggleTools('');
+ graphs.removeChild(graphElement);
RefreshButtons();
if (graphs.getElementsByTagName('div').length == 1)
document.getElementById('nograph').style.display = 'block';
var myList = Array();
for (i = 0; i < graphList.length; i++)
- if (graphList[i].substring(0, graph.length) == graph && graphList[i].charAt(graph.length) == ' ')
+ if (graphList[i].substring(0, graphId.length) == graphId && graphList[i].charAt(graphId.length) == ' ')
continue;
else
myList.push(graphList[i]);
function GraphMoveUp(graph) {
var graphs = document.getElementById('graphs');
+ var graphId = graph == null ? document.getElementById('ge_graphid').value : graph;
var childCnt = graphs.childNodes.length;
var prevGraph = null;
for (i = 0; i < childCnt; i++)
if (graphs.childNodes[i].nodeName == 'div' || graphs.childNodes[i].nodeName == 'DIV') {
if (graphs.childNodes[i].id == 'nograph') {
// Skip
- } else if (graphs.childNodes[i].id == graph) {
+ } else if (graphs.childNodes[i].id == graphId) {
var myGraph = graphs.childNodes[i];
if (prevGraph) {
graphs.removeChild(myGraph);
prevGraph = graphs.childNodes[i];
}
for (i = 0; i < graphList.length; i++)
- if (graphList[i].substring(0, graph.length) == graph && graphList[i].charAt(graph.length) == ' ') {
+ if (graphList[i].substring(0, graphId.length) == graphId && graphList[i].charAt(graphId.length) == ' ') {
if (i > 0) {
var tmp = graphList[i-1];
graphList[i-1] = graphList[i];
}
break;
}
+ GraphPositionToolbox(null);
}
function GraphMoveDown(graph) {
var graphs = document.getElementById('graphs');
+ var graphId = graph == null ? document.getElementById('ge_graphid').value : graph;
var childCnt = graphs.childNodes.length;
var nextGraph = null;
var myGraph = null;
if (graphs.childNodes[i].nodeName == 'div' || graphs.childNodes[i].nodeName == 'DIV') {
if (graphs.childNodes[i].id == 'nograph') {
// Skip
- } else if (graphs.childNodes[i].id == graph) {
+ } else if (graphs.childNodes[i].id == graphId) {
myGraph = graphs.childNodes[i];
} else if (myGraph) {
nextGraph = graphs.childNodes[i];
}
}
for (i = 0; i < graphList.length; i++)
- if (graphList[i].substring(0, graph.length) == graph && graphList[i].charAt(graph.length) == ' ') {
+ if (graphList[i].substring(0, graphId.length) == graphId && graphList[i].charAt(graphId.length) == ' ') {
if (i+1 < graphList.length) {
var tmp = graphList[i+1];
graphList[i+1] = graphList[i];
}
break;
}
+ GraphPositionToolbox(null);
}
function GraphListFromCookie(lname) {
'GPRINT:avg:AVERAGE:%4.1lf Avg,',
'GPRINT:max:MAX:%4.1lf Max,',
'GPRINT:avg:LAST:%4.1lf Last\l');
+ $GraphDefs['conntrack'] = array(
+ '-v', 'Entries',
+ 'DEF:avg={file}:entropy:AVERAGE',
+ 'DEF:min={file}:entropy:MIN',
+ 'DEF:max={file}:entropy:MAX',
+ "AREA:max#$HalfBlue",
+ "AREA:min#$Canvas",
+ "LINE1:avg#$FullBlue:Count",
+ 'GPRINT:min:MIN:%4.0lf Min,',
+ 'GPRINT:avg:AVERAGE:%4.0lf Avg,',
+ 'GPRINT:max:MAX:%4.0lf Max,',
+ 'GPRINT:avg:LAST:%4.0lf Last\l');
$GraphDefs['entropy'] = array(
'-v', 'Bits',
'DEF:avg={file}:entropy:AVERAGE',
$MetaGraphDefs['tcp_connections'] = 'meta_graph_tcp_connections';
$MetaGraphDefs['dns_opcode'] = 'meta_graph_dns_event';
$MetaGraphDefs['dns_qtype'] = 'meta_graph_dns_event';
+ $MetaGraphDefs['dns_qtype_cached'] = 'meta_graph_dns_event';
$MetaGraphDefs['dns_rcode'] = 'meta_graph_dns_event';
$MetaGraphDefs['dns_request'] = 'meta_graph_dns_event';
$MetaGraphDefs['dns_resolver'] = 'meta_graph_dns_event';
$sources[] = array('name'=>$inst, 'file'=>$file);
}
- return collectd_draw_meta_stack($opts, $sources);
+ if ($plugin == 'bind')
+ return collectd_draw_meta_line($opts, $sources);
+ else
+ return collectd_draw_meta_stack($opts, $sources);
}
function meta_graph_vs_threads($host, $plugin, $plugin_instance, $type, $type_instances, $opts = array()) {
return 0;
}
-/**
- * Fetch list of hosts found in collectd's datadirs.
- * @return Sorted list of hosts (sorted by label from rigth to left)
- */
-function collectd_list_hosts() {
+function collectd_walk(&$options) {
global $config;
- $hosts = array();
foreach($config['datadirs'] as $datadir)
- if ($d = @opendir($datadir)) {
- while (($dent = readdir($d)) !== false)
- if ($dent != '.' && $dent != '..' && is_dir($datadir.'/'.$dent) && preg_match(REGEXP_HOST, $dent))
- $hosts[] = $dent;
- closedir($d);
+ if ($dh = @opendir($datadir)) {
+ while (($hdent = readdir($dh)) !== false) {
+ if ($hdent == '.' || $hdent == '..' || !is_dir($datadir.'/'.$hdent))
+ continue;
+ if (!preg_match(REGEXP_HOST, $hdent))
+ continue;
+ if (isset($options['cb_host']) && ($options['cb_host'] === false || !$options['cb_host']($options, $hdent)))
+ continue;
+
+ if ($dp = @opendir($datadir.'/'.$hdent)) {
+ while (($pdent = readdir($dp)) !== false) {
+ if ($pdent == '.' || $pdent == '..' || !is_dir($datadir.'/'.$hdent.'/'.$pdent))
+ continue;
+ if ($i = strpos($pdent, '-')) {
+ $plugin = substr($pdent, 0, $i);
+ $pinst = substr($pdent, $i+1);
+ } else {
+ $plugin = $pdent;
+ $pinst = '';
+ }
+ if (isset($options['cb_plugin']) && ($options['cb_plugin'] === false || !$options['cb_plugin']($options, $hdent, $plugin)))
+ continue;
+ if (isset($options['cb_pinst']) && ($options['cb_pinst'] === false || !$options['cb_pinst']($options, $hdent, $plugin, $pinst)))
+ continue;
+
+ if ($dt = @opendir($datadir.'/'.$hdent.'/'.$pdent)) {
+ while (($tdent = readdir($dt)) !== false) {
+ if ($tdent == '.' || $tdent == '..' || !is_file($datadir.'/'.$hdent.'/'.$pdent.'/'.$tdent))
+ continue;
+ if (substr($tdent, strlen($tdent)-4) != '.rrd')
+ continue;
+ $tdent = substr($tdent, 0, strlen($tdent)-4);
+ if ($i = strpos($tdent, '-')) {
+ $type = substr($tdent, 0, $i);
+ $tinst = substr($tdent, $i+1);
+ } else {
+ $type = $tdent;
+ $tinst = '';
+ }
+ if (isset($options['cb_type']) && ($options['cb_type'] === false || !$options['cb_type']($options, $hdent, $plugin, $pinst, $type)))
+ continue;
+ if (isset($options['cb_tinst']) && ($options['cb_tinst'] === false || !$options['cb_tinst']($options, $hdent, $plugin, $pinst, $type, $tinst)))
+ continue;
+ }
+ closedir($dt);
+ }
+ }
+ closedir($dp);
+ }
+ }
+ closedir($dh);
} else
error_log('Failed to open datadir: '.$datadir);
- $hosts = array_unique($hosts);
+ return true;
+}
+
+function _collectd_list_cb_host(&$options, $host) {
+ if ($options['cb_plugin'] === false) {
+ $options['result'][] = $host;
+ return false;
+ } else if (isset($options['filter_host'])) {
+ if ($options['filter_host'] == '@all') {
+ return true; // We take anything
+ } else if (substr($options['filter_host'], 0, 2) == '@.') {
+ if ($host == substr($options['filter_host'], 2) || substr($host, 0, 1-strlen($options['filter_host'])) == substr($options['filter_host'], 1))
+ return true; // Host part of domain
+ else
+ return false;
+ } else if ($options['filter_host'] == $host) {
+ return true;
+ } else
+ return false;
+ } else
+ return true;
+}
+
+function _collectd_list_cb_plugin(&$options, $host, $plugin) {
+ if ($options['cb_pinst'] === false) {
+ $options['result'][] = $plugin;
+ return false;
+ } else if (isset($options['filter_plugin'])) {
+ if ($options['filter_plugin'] == '@all')
+ return true;
+ else if ($options['filter_plugin'] == $plugin)
+ return true;
+ else
+ return false;
+ } else
+ return true;
+}
+
+function _collectd_list_cb_pinst(&$options, $host, $plugin, $pinst) {
+ if ($options['cb_type'] === false) {
+ $options['result'][] = $pinst;
+ return false;
+ } else if (isset($options['filter_pinst'])) {
+ if ($options['filter_pinst'] == '@all')
+ return true;
+ else if (strncmp($options['filter_pinst'], '@merge_', 7) == 0)
+ return true;
+ else if ($options['filter_pinst'] == $pinst)
+ return true;
+ else
+ return false;
+ } else
+ return true;
+}
+
+function _collectd_list_cb_type(&$options, $host, $plugin, $pinst, $type) {
+ if ($options['cb_tinst'] === false) {
+ $options['result'][] = $type;
+ return false;
+ } else if (isset($options['filter_type'])) {
+ if ($options['filter_type'] == '@all')
+ return true;
+ else if ($options['filter_type'] == $type)
+ return true;
+ else
+ return false;
+ } else
+ return true;
+}
+
+function _collectd_list_cb_tinst(&$options, $host, $plugin, $pinst, $type, $tinst) {
+ $options['result'][] = $tinst;
+ return false;
+}
+
+function _collectd_list_cb_graph(&$options, $host, $plugin, $pinst, $type, $tinst) {
+ if (isset($options['filter_tinst'])) {
+ if ($options['filter_tinst'] == '@all') {
+ } else if ($options['filter_tinst'] == $tinst) {
+ } else if (strncmp($options['filter_tinst'], '@merge', 6) == 0) {
+ // Need to exclude @merge with non-existent meta graph
+ } else
+ return false;
+ }
+ if (isset($options['filter_pinst']) && strncmp($options['filter_pinst'], '@merge', 6) == 0)
+ $pinst = $options['filter_pinst'];
+ if (isset($options['filter_tinst']) && strncmp($options['filter_tinst'], '@merge', 6) == 0)
+ $tinst = $options['filter_tinst'];
+ $ident = collectd_identifier($host, $plugin, $pinst, $type, $tinst);
+ if (!in_array($ident, $options['ridentifiers'])) {
+ $options['ridentifiers'][] = $ident;
+ $options['result'][] = array('host'=>$host, 'plugin'=>$plugin, 'pinst'=>$pinst, 'type'=>$type, 'tinst'=>$tinst);
+ }
+}
+
+/**
+ * Fetch list of hosts found in collectd's datadirs.
+ * @return Sorted list of hosts (sorted by label from rigth to left)
+ */
+function collectd_list_hosts() {
+ $options = array(
+ 'result' => array(),
+ 'cb_host' => '_collectd_list_cb_host',
+ 'cb_plugin' => false,
+ 'cb_pinst' => false,
+ 'cb_type' => false,
+ 'cb_tinst' => false
+ );
+ collectd_walk($options);
+ $hosts = array_unique($options['result']);
usort($hosts, 'collectd_compare_host');
return $hosts;
}
* @arg_host Name of host for which to return plugins
* @return Sorted list of plugins (sorted alphabetically)
*/
-function collectd_list_plugins($arg_host) {
- global $config;
-
- $plugins = array();
- foreach ($config['datadirs'] as $datadir)
- if (preg_match(REGEXP_HOST, $arg_host) && ($d = @opendir($datadir.'/'.$arg_host))) {
- while (($dent = readdir($d)) !== false)
- if ($dent != '.' && $dent != '..' && is_dir($datadir.'/'.$arg_host.'/'.$dent)) {
- if ($i = strpos($dent, '-'))
- $plugins[] = substr($dent, 0, $i);
- else
- $plugins[] = $dent;
- }
- closedir($d);
- }
- $plugins = array_unique($plugins);
+function collectd_list_plugins($arg_host, $arg_plugin = null) {
+ $options = array(
+ 'result' => array(),
+ 'cb_host' => '_collectd_list_cb_host',
+ 'cb_plugin' => '_collectd_list_cb_plugin',
+ 'cb_pinst' => is_null($arg_plugin) ? false : '_collectd_list_cb_pinst',
+ 'cb_type' => false,
+ 'cb_tinst' => false,
+ 'filter_host' => $arg_host,
+ 'filter_plugin' => $arg_plugin
+ );
+ collectd_walk($options);
+ $plugins = array_unique($options['result']);
sort($plugins);
return $plugins;
}
/**
- * Fetch list of plugin instances found in collectd's datadirs for given host+plugin
- * @arg_host Name of host
- * @arg_plugin Name of plugin
- * @return Sorted list of plugin instances (sorted alphabetically)
- */
-function collectd_list_pinsts($arg_host, $arg_plugin) {
- global $config;
-
- $pinsts = array();
- foreach ($config['datadirs'] as $datadir)
- if (preg_match(REGEXP_HOST, $arg_host) && ($d = opendir($datadir.'/'.$arg_host))) {
- while (($dent = readdir($d)) !== false)
- if ($dent != '.' && $dent != '..' && is_dir($datadir.'/'.$arg_host.'/'.$dent)) {
- if ($i = strpos($dent, '-')) {
- $plugin = substr($dent, 0, $i);
- $pinst = substr($dent, $i+1);
- } else {
- $plugin = $dent;
- $pinst = '';
- }
- if ($plugin == $arg_plugin)
- $pinsts[] = $pinst;
- }
- closedir($d);
- }
- $pinsts = array_unique($pinsts);
- sort($pinsts);
- return $pinsts;
-}
-
-/**
* Fetch list of types found in collectd's datadirs for given host+plugin+instance
* @arg_host Name of host
* @arg_plugin Name of plugin
* @arg_pinst Plugin instance
* @return Sorted list of types (sorted alphabetically)
*/
-function collectd_list_types($arg_host, $arg_plugin, $arg_pinst) {
- global $config;
-
- $types = array();
- $my_plugin = $arg_plugin . (strlen($arg_pinst) ? '-'.$arg_pinst : '');
- if (!preg_match(REGEXP_PLUGIN, $my_plugin))
- return $types;
- foreach ($config['datadirs'] as $datadir)
- if (preg_match(REGEXP_HOST, $arg_host) && ($d = @opendir($datadir.'/'.$arg_host.'/'.$my_plugin))) {
- while (($dent = readdir($d)) !== false)
- if ($dent != '.' && $dent != '..' && is_file($datadir.'/'.$arg_host.'/'.$my_plugin.'/'.$dent) && substr($dent, strlen($dent)-4) == '.rrd') {
- $dent = substr($dent, 0, strlen($dent)-4);
- if ($i = strpos($dent, '-'))
- $types[] = substr($dent, 0, $i);
- else
- $types[] = $dent;
- }
- closedir($d);
- }
- $types = array_unique($types);
+function collectd_list_types($arg_host, $arg_plugin, $arg_pinst, $arg_type = null) {
+ $options = array(
+ 'result' => array(),
+ 'cb_host' => '_collectd_list_cb_host',
+ 'cb_plugin' => '_collectd_list_cb_plugin',
+ 'cb_pinst' => '_collectd_list_cb_pinst',
+ 'cb_type' => '_collectd_list_cb_type',
+ 'cb_tinst' => is_null($arg_type) ? false : '_collectd_list_cb_tinst',
+ 'filter_host' => $arg_host,
+ 'filter_plugin' => $arg_plugin,
+ 'filter_pinst' => $arg_pinst,
+ 'filter_type' => $arg_type
+ );
+ collectd_walk($options);
+ $types = array_unique($options['result']);
sort($types);
return $types;
}
-/**
- * Fetch list of type instances found in collectd's datadirs for given host+plugin+instance+type
- * @arg_host Name of host
- * @arg_plugin Name of plugin
- * @arg_pinst Plugin instance
- * @arg_type Type
- * @return Sorted list of type instances (sorted alphabetically)
- */
-function collectd_list_tinsts($arg_host, $arg_plugin, $arg_pinst, $arg_type) {
- global $config;
-
- $tinsts = array();
- $my_plugin = $arg_plugin . (strlen($arg_pinst) ? '-'.$arg_pinst : '');
- if (!preg_match(REGEXP_PLUGIN, $my_plugin))
- return $types;
- foreach ($config['datadirs'] as $datadir)
- if (preg_match(REGEXP_HOST, $arg_host) && ($d = @opendir($datadir.'/'.$arg_host.'/'.$my_plugin))) {
- while (($dent = readdir($d)) !== false)
- if ($dent != '.' && $dent != '..' && is_file($datadir.'/'.$arg_host.'/'.$my_plugin.'/'.$dent) && substr($dent, strlen($dent)-4) == '.rrd') {
- $dent = substr($dent, 0, strlen($dent)-4);
- if ($i = strpos($dent, '-')) {
- $type = substr($dent, 0, $i);
- $tinst = substr($dent, $i+1);
- } else {
- $type = $dent;
- $tinst = '';
- }
- if ($type == $arg_type)
- $tinsts[] = $tinst;
- }
- closedir($d);
- }
- $tinsts = array_unique($tinsts);
- sort($tinsts);
- return $tinsts;
+function collectd_list_graphs($arg_host, $arg_plugin, $arg_pinst, $arg_type, $arg_tinst) {
+ $options = array(
+ 'result' => array(),
+ 'ridentifiers' => array(),
+ 'cb_host' => '_collectd_list_cb_host',
+ 'cb_plugin' => '_collectd_list_cb_plugin',
+ 'cb_pinst' => '_collectd_list_cb_pinst',
+ 'cb_type' => '_collectd_list_cb_type',
+ 'cb_tinst' => '_collectd_list_cb_graph',
+ 'filter_host' => $arg_host,
+ 'filter_plugin' => $arg_plugin,
+ 'filter_pinst' => $arg_pinst,
+ 'filter_type' => $arg_type,
+ 'filter_tinst' => $arg_tinst == '@' ? '@merge' : $arg_tinst
+ );
+ collectd_walk($options);
+ return $options['result'];
}
/**
$tinylegend = (boolean)read_var('tinylegend', $_GET, false);
// Check that at least 1 RRD exists for the specified request
-$all_tinst = collectd_list_tinsts($host, $plugin, $pinst, $type);
+$all_tinst = collectd_list_types($host, $plugin, $pinst, $type);
if (count($all_tinst) == 0)
return error404($graph_identifier, "No rrd file found for graphing");
$opts['tinylegend'] = 1;
$rrd_cmd = false;
-if (isset($MetaGraphDefs[$type])) {
+if ((is_null($tinst) || $tinst == '@merge') && isset($MetaGraphDefs[$type])) {
$identifiers = array();
foreach ($all_tinst as &$atinst)
$identifiers[] = collectd_identifier($host, $plugin, is_null($pinst) ? '' : $pinst, $type, $atinst);
print("</response>");
}
+function dhtml_response_graphs(&$graphs, $method) {
+ header("Content-Type: text/xml");
+
+ print('<?xml version="1.0" encoding="utf-8" ?>'."\n");
+ print("<response>\n");
+ printf(" <method>%s</method>\n", htmlspecialchars($method));
+ print(" <result>\n");
+ foreach ($graphs as &$graph)
+ printf(' <graph host="%s" plugin="%s" plugin_instance="%s" type="%s" type_instance="%s" timespan="%s" logarithmic="%d" tinyLegend="%d" />'."\n",
+ htmlspecialchars($graph['host']), htmlspecialchars($graph['plugin']), htmlspecialchars($graph['pinst']),
+ htmlspecialchars($graph['type']), htmlspecialchars($graph['tinst']), htmlspecialchars($graph['timespan']),
+ htmlspecialchars($graph['logarithmic']), htmlspecialchars($graph['tinyLegend']));
+ print(" </result>\n");
+ print("</response>");
+}
+
/**
* Product page body with selection fields
*/
<style type="text/css">
body, html { background-color: #EEEEEE; color: #000000; }
h1 { text-align: center; }
- div.body { margin: auto; width: <?php echo isset($config['rrd_width']) ? 125+(int)$config['rrd_width'] : 600; ?>px; background: #FFFFFF; border: 1px solid #DDDDDD; }
+ div.body { margin: auto; width: <?php echo isset($config['rrd_width']) ? 110+(int)$config['rrd_width'] : 600; ?>px; background: #FFFFFF; border: 1px solid #DDDDDD; }
p.error { color: #CC0000; margin: 0em; }
div.selector { margin: 0.5em 2em; }
div.selectorbox { padding: 5px; border: 1px solid #CCCCCC; background-color: #F8F8F8; }
div.selectorbox table td.sc { padding: 0.5em 2em; text-align: center; }
a img { border: none; }
div.graphs { border-top: 1px solid #DDDDDD; padding: 5px; overflow: auto; }
- div.graphs_t { display: table; }
- div.graph { display: table-row; }
- div.graph_img { display: table-cell; vertical-align: middle; text-align: right; }
- div.graph_opts { display: table-cell; vertical-align: middle; text-align: center; line-height: 2em; }
- select { width: 100%; }
+ div.graphs_t { position: relative; }
+ div.graph { text-align: right; }
+ div.selector select { width: 100%; }
+ table.toolbox { border: 1px solid #5500dd; padding: 0px; margin: 0px; background: #ffffff;}
+ table.toolbox td.c1 { vertical-align: middle; text-align: left; padding-left: 0.3em; padding-right: 1em; border-right: 1px solid #5500dd; }
+ table.toolbox td.c2 { vertical-align: middle; text-align: center; padding-left: 5px; padding-right: 5px; }
</style>
<script type="text/javascript">// <![CDATA[
var dhtml_url = '<?php echo addslashes($url_base.basename($_SERVER['PHP_SELF'])); ?>';
<tr>
<td class="sc" colspan="3"><input id="btnAdd" name="btnAdd" type="button" disabled="disabled" onclick="GraphAppend()" value="Add graph" />
<input id="btnClear" name="btnClear" type="button" disabled="disabled" onclick="GraphDropAll()" value="Remove all graphs" />
- <input id="btnRefresh" name="btnRefresh" type="button" disabled="disabled" onclick="GraphRefresh(null)" value="Refresh all graphs" /></td>
+ <input id="btnRefresh" name="btnRefresh" type="button" disabled="disabled" onclick="GraphRefreshAll()" value="Refresh all graphs" /></td>
</tr>
<tr>
<td class="s1" rowspan="2">Graph list favorites:</td>
echo '<p class="error">Config error: RRDTOOL ('.htmlspecialchars(RRDTOOL).') is not executable</p>';
?></div>
</div></div>
+ <input type="hidden" name="ge_graphid" id="ge_graphid" value="" />
+ <table id="ge" class="toolbox" style="position: absolute; display: none; " cellspacing="1" cellpadding="0">
+ <tr>
+ <td class="c1" rowspan="3"><select id="ge_timespan" name="ge_timespan" onchange="GraphAdjust(null)"><?php
+ foreach ($config['timespan'] as &$timespan)
+ printf("\t\t\t\t\t\t<option value=\"%s\">%s</option>\n", htmlspecialchars($timespan['name']), htmlspecialchars($timespan['label']));
+ ?></select><br />
+ <label><input id="ge_logarithmic" name="ge_logarithmic" type="checkbox" value="1" onchange="GraphAdjust(null)" /> Logarithmic scale</label><br />
+ <label><input id="ge_tinylegend" name="ge_tinylegend" type="checkbox" value="1" onchange="GraphAdjust(null)" /> Minimal legend</label></td>
+ <td class="c2"><a href="javascript:GraphMoveUp(null)"><img src="move-up.png" alt="UP" title="Move graph up"/></a></td>
+ </tr>
+ <tr>
+ <td class="c2"><a href="javascript:GraphRefresh(null)"><img src="refresh.png" alt="R" title="Refresh graph"/></a> <a href="javascript:GraphRemove(null)"><img src="delete.png" alt="RM" title="Remove graph"/></a></td>
+ </tr>
+ <tr>
+ <td class="c2"><a href="javascript:GraphMoveDown(null)"><img src="move-down.png" alt="DN" title="Move graph down"/></a></td>
+ </tr>
+ </table>
</div></body>
</html><?php
}
case 'list_hosts':
// Generate a list of hosts
$hosts = collectd_list_hosts();
+ if (count($hosts) > 1)
+ array_unshift($hosts, '@all');
return dhtml_response_list($hosts, 'ListOfHost');
case 'list_plugins':
// Generate list of plugins for selected hosts
- $arg_hosts = read_var('host', $_POST, array());
- if (!is_array($arg_hosts))
- $arg_hosts = array($arg_hosts);
- $plugins = collectd_list_plugins(reset($arg_hosts));
+ $arg_hosts = read_var('host', $_POST, '');
+ if (is_array($arg_hosts))
+ $arg_hosts = reset($arg_hosts);
+ $plugins = collectd_list_plugins($arg_hosts);
+ if (count($plugins) > 1)
+ array_unshift($plugins, '@all');
return dhtml_response_list($plugins, 'ListOfPlugin');
case 'list_pinsts':
// Generate list of plugin_instances for selected hosts and plugin
- $arg_hosts = read_var('host', $_POST, array());
- if (!is_array($arg_hosts))
- $arg_hosts = array($arg_hosts);
+ $arg_hosts = read_var('host', $_POST, '');
+ if (is_array($arg_hosts))
+ $arg_hosts = reset($arg_hosts);
$arg_plugin = read_var('plugin', $_POST, '');
- $pinsts = collectd_list_pinsts(reset($arg_hosts), $arg_plugin);
+ $pinsts = collectd_list_plugins($arg_hosts, $arg_plugin);
+ if (count($pinsts) > 1)
+ array_unshift($pinsts, '@all' /* , '@merge_sum', '@merge_avg', '@merge_stack', '@merge_line' */);
return dhtml_response_list($pinsts, 'ListOfPluginInstance');
case 'list_types':
// Generate list of types for selected hosts, plugin and plugin-instance
- $arg_hosts = read_var('host', $_POST, array());
- if (!is_array($arg_hosts))
- $arg_hosts = array($arg_hosts);
+ $arg_hosts = read_var('host', $_POST, '');
+ if (is_array($arg_hosts))
+ $arg_hosts = reset($arg_hosts);
$arg_plugin = read_var('plugin', $_POST, '');
$arg_pinst = read_var('plugin_instance', $_POST, '');
- $types = collectd_list_types(reset($arg_hosts), $arg_plugin, $arg_pinst);
+ $types = collectd_list_types($arg_hosts, $arg_plugin, $arg_pinst);
+ if (count($types) > 1)
+ array_unshift($types, '@all');
return dhtml_response_list($types, 'ListOfType');
case 'list_tinsts':
// Generate list of types for selected hosts, plugin and plugin-instance
- $arg_hosts = read_var('host', $_POST, array());
- if (!is_array($arg_hosts))
- $arg_hosts = array($arg_hosts);
+ $arg_hosts = read_var('host', $_POST, '');
+ if (is_array($arg_hosts))
+ $arg_hosts = reset($arg_hosts);
$arg_plugin = read_var('plugin', $_POST, '');
$arg_pinst = read_var('plugin_instance', $_POST, '');
$arg_type = read_var('type', $_POST, '');
- $tinsts = collectd_list_tinsts(reset($arg_hosts), $arg_plugin, $arg_pinst, $arg_type);
- if (count($tinsts)) {
- require('definitions.php');
- load_graph_definitions();
- if (isset($MetaGraphDefs[$arg_type])) {
- $meta_tinsts = array('@');
- return dhtml_response_list($meta_tinsts, 'ListOfTypeInstance');
+ $tinsts = collectd_list_types($arg_hosts, $arg_plugin, $arg_pinst, $arg_type);
+ if (count($tinsts))
+ if ($arg_type != '@all') {
+ require('definitions.php');
+ load_graph_definitions();
+ if (isset($MetaGraphDefs[$arg_type]))
+ array_unshift($tinsts, '@merge');
+ if (count($tinsts) > 1)
+ array_unshift($tinsts, '@all');
+ } else {
+ array_unshift($tinsts, /* '@merge_sum', '@merge_avg', '@merge_stack', '@merge_line', */ '@merge');
+ if (count($tinsts) > 1)
+ array_unshift($tinsts, '@all');
}
- }
return dhtml_response_list($tinsts, 'ListOfTypeInstance');
+ case 'list_graphs':
+ // Generate list of types for selected hosts, plugin and plugin-instance
+ $arg_hosts = read_var('host', $_POST, '');
+ if (is_array($arg_hosts))
+ $arg_hosts = reset($arg_hosts);
+ $arg_plugin = read_var('plugin', $_POST, '');
+ $arg_pinst = read_var('plugin_instance', $_POST, '');
+ $arg_type = read_var('type', $_POST, '');
+ $arg_tinst = read_var('type_instance', $_POST, '');
+ $arg_log = (int)read_var('logarithmic', $_POST, '0');
+ $arg_legend = (int)read_var('tinyLegend', $_POST, '0');
+ $arg_period = read_var('timespan', $_POST, '');
+ $graphs = collectd_list_graphs($arg_hosts, $arg_plugin, $arg_pinst, $arg_type, $arg_tinst);
+ foreach ($graphs as &$graph) {
+ $graph['logarithmic'] = $arg_log;
+ $graph['tinyLegend'] = $arg_legend;
+ $graph['timespan'] = $arg_period;
+ }
+ return dhtml_response_graphs($graphs, 'ListOfGraph');
+
case 'overview':
default:
return build_page();
LoadPlugin apcups
#LoadPlugin apple_sensors
LoadPlugin battery
+LoadPlugin conntrack
LoadPlugin cpu
LoadPlugin cpufreq
LoadPlugin csv
%attr(0644,root,root) %{_libdir}/%{name}/battery.so*
%attr(0644,root,root) %{_libdir}/%{name}/battery.la
+%attr(0644,root,root) %{_libdir}/%{name}/conntrack.so*
+%attr(0644,root,root) %{_libdir}/%{name}/conntrack.la
+
%attr(0644,root,root) %{_libdir}/%{name}/cpufreq.so*
%attr(0644,root,root) %{_libdir}/%{name}/cpufreq.la
if BUILD_WITH_OWN_LIBOCONFIG
SUBDIRS += liboconfig
endif
-if BUILD_WITH_OWN_LIBOPING
-SUBDIRS += liboping
-endif
if COMPILER_IS_GCC
AM_CFLAGS = -Wall -Werror
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 \
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 =
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
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
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
collectd_DEPENDENCIES += bind.la
endif
+if BUILD_PLUGIN_CONNTRACK
+pkglib_LTLIBRARIES += conntrack.la
+conntrack_la_SOURCES = conntrack.c
+conntrack_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" conntrack.la
+collectd_DEPENDENCIES += conntrack.la
+endif
+
if BUILD_PLUGIN_CPU
pkglib_LTLIBRARIES += cpu.la
cpu_la_SOURCES = cpu.c
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)
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)
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
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
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
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
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
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
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
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
if BUILD_PLUGIN_NETWORK
pkglib_LTLIBRARIES += network.la
-network_la_SOURCES = network.c network.h
+network_la_SOURCES = network.c network.h \
+ utils_fbhash.c utils_fbhash.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
collectd_DEPENDENCIES += nfs.la
endif
+if BUILD_PLUGIN_FSCACHE
+pkglib_LTLIBRARIES += fscache.la
+fscache_la_SOURCES = fscache.c
+fscache_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" fscache.la
+collectd_DEPENDENCIES += fscache.la
+endif
+
if BUILD_PLUGIN_NGINX
pkglib_LTLIBRARIES += nginx.la
nginx_la_SOURCES = nginx.c
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
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
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
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
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
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
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
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
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
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
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
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) $< \
/**
* collectd - src/apache.c
- * Copyright (C) 2006-2008 Florian octo Forster
- * Copyright (C) 2007 Florent EppO Monbillard
+ * Copyright (C) 2006-2009 Florian octo Forster
+ * Copyright (C) 2007 Florent EppO Monbillard
+ * Copyright (C) 2009 Amit Gupta
*
* 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
* Florian octo Forster <octo at verplant.org>
* Florent EppO Monbillard <eppo at darox.net>
* - connections/lighttpd extension
+ * Amit Gupta <amit.gupta221 at gmail.com>
**/
#include "collectd.h"
#include <curl/curl.h>
-static char *url = NULL;
-static char *user = NULL;
-static char *pass = NULL;
-static char *verify_peer = NULL;
-static char *verify_host = NULL;
-static char *cacert = NULL;
-
-static CURL *curl = NULL;
-
-static char *apache_buffer = NULL;
-static size_t apache_buffer_size = 0;
-static size_t apache_buffer_fill = 0;
-static char apache_curl_error[CURL_ERROR_SIZE];
-
-static const char *config_keys[] =
+enum server_enum
{
- "URL",
- "User",
- "Password",
- "VerifyPeer",
- "VerifyHost",
- "CACert"
+ APACHE = 0,
+ LIGHTTPD
};
-static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
+
+struct apache_s
+{
+ int server_type;
+ char *name;
+ char *host;
+ char *url;
+ char *user;
+ char *pass;
+ int verify_peer;
+ int verify_host;
+ char *cacert;
+ char *server; /* user specific server type */
+ char *apache_buffer;
+ char apache_curl_error[CURL_ERROR_SIZE];
+ size_t apache_buffer_size;
+ size_t apache_buffer_fill;
+ CURL *curl;
+}; /* apache_s */
+
+typedef struct apache_s apache_t;
+
+/* TODO: Remove this prototype */
+static int apache_read_host (user_data_t *user_data);
+
+static void apache_free (apache_t *st)
+{
+ if (st == NULL)
+ return;
+
+ sfree (st->name);
+ sfree (st->host);
+ sfree (st->url);
+ sfree (st->user);
+ sfree (st->pass);
+ sfree (st->cacert);
+ sfree (st->server);
+ sfree (st->apache_buffer);
+ if (st->curl) {
+ curl_easy_cleanup(st->curl);
+ st->curl = NULL;
+ }
+} /* apache_free */
static size_t apache_curl_callback (void *buf, size_t size, size_t nmemb,
- void __attribute__((unused)) *stream)
+ void *user_data)
{
size_t len = size * nmemb;
+ apache_t *st;
+
+ st = user_data;
+ if (st == NULL)
+ {
+ ERROR ("apache plugin: apache_curl_callback: "
+ "user_data pointer is NULL.");
+ return (0);
+ }
if (len <= 0)
return (len);
- if ((apache_buffer_fill + len) >= apache_buffer_size)
+ if ((st->apache_buffer_fill + len) >= st->apache_buffer_size)
{
char *temp;
- temp = (char *) realloc (apache_buffer,
- apache_buffer_fill + len + 1);
+ temp = (char *) realloc (st->apache_buffer,
+ st->apache_buffer_fill + len + 1);
if (temp == NULL)
{
ERROR ("apache plugin: realloc failed.");
return (0);
}
- apache_buffer = temp;
- apache_buffer_size = apache_buffer_fill + len + 1;
+ st->apache_buffer = temp;
+ st->apache_buffer_size = st->apache_buffer_fill + len + 1;
}
- memcpy (apache_buffer + apache_buffer_fill, (char *) buf, len);
- apache_buffer_fill += len;
- apache_buffer[apache_buffer_fill] = 0;
+ memcpy (st->apache_buffer + st->apache_buffer_fill, (char *) buf, len);
+ st->apache_buffer_fill += len;
+ st->apache_buffer[st->apache_buffer_fill] = 0;
return (len);
-}
+} /* int apache_curl_callback */
-static int config_set (char **var, const char *value)
+static size_t apache_header_callback (void *buf, size_t size, size_t nmemb,
+ void *user_data)
{
- if (*var != NULL)
+ size_t len = size * nmemb;
+ apache_t *st;
+
+ st = user_data;
+ if (st == NULL)
{
- free (*var);
- *var = NULL;
+ ERROR ("apache plugin: apache_header_callback: "
+ "user_data pointer is NULL.");
+ return (0);
}
- if ((*var = strdup (value)) == NULL)
- return (1);
+ if (len <= 0)
+ return (len);
+
+ /* look for the Server header */
+ if (strncasecmp (buf, "Server: ", strlen ("Server: ")) != 0)
+ return (len);
+
+ if (strstr (buf, "Apache") != NULL)
+ st->server_type = APACHE;
+ else if (strstr (buf, "lighttpd") != NULL)
+ st->server_type = LIGHTTPD;
else
- return (0);
-}
+ {
+ const char *hdr = buf;
+
+ hdr += strlen ("Server: ");
+ NOTICE ("apache plugin: Unknown server software: %s", hdr);
+ }
-static int config (const char *key, const char *value)
+ return (len);
+} /* apache_header_callback */
+
+/* Configuration handling functiions
+ * <Plugin apache>
+ * <Instance "instance_name">
+ * URL ...
+ * </Instance>
+ * URL ...
+ * </Plugin>
+ */
+static int config_set_string (char **ret_string, /* {{{ */
+ oconfig_item_t *ci)
{
- if (strcasecmp (key, "url") == 0)
- return (config_set (&url, value));
- else if (strcasecmp (key, "user") == 0)
- return (config_set (&user, value));
- else if (strcasecmp (key, "password") == 0)
- return (config_set (&pass, value));
- else if (strcasecmp (key, "verifypeer") == 0)
- return (config_set (&verify_peer, value));
- else if (strcasecmp (key, "verifyhost") == 0)
- return (config_set (&verify_host, value));
- else if (strcasecmp (key, "cacert") == 0)
- return (config_set (&cacert, value));
- else
+ char *string;
+
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("apache 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 ("apache plugin: strdup failed.");
+ return (-1);
+ }
+
+ if (*ret_string != NULL)
+ free (*ret_string);
+ *ret_string = string;
+
+ return (0);
+} /* }}} int config_set_string */
-static int init (void)
+static int config_set_boolean (int *ret_boolean, /* {{{ */
+ oconfig_item_t *ci)
{
- static char credentials[1024];
+ if ((ci->values_num != 1)
+ || ((ci->values[0].type != OCONFIG_TYPE_BOOLEAN)
+ && (ci->values[0].type != OCONFIG_TYPE_STRING)))
+ {
+ WARNING ("apache plugin: The `%s' config option "
+ "needs exactly one boolean argument.", ci->key);
+ return (-1);
+ }
- if (url == NULL)
+ if (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)
+ {
+ if (ci->values[0].value.boolean)
+ *ret_boolean = 1;
+ else
+ *ret_boolean = 0;
+ }
+ else /* if (ci->values[0].type != OCONFIG_TYPE_STRING) */
{
- WARNING ("apache plugin: init: No URL configured, returning "
- "an error.");
+ char *string = ci->values[0].value.string;
+ if ((strcasecmp ("true", string) == 0)
+ || (strcasecmp ("yes", string) == 0)
+ || (strcasecmp ("on", string) == 0))
+ *ret_boolean = 1;
+ else if ((strcasecmp ("false", string) == 0)
+ || (strcasecmp ("no", string) == 0)
+ || (strcasecmp ("off", string) == 0))
+ *ret_boolean = 0;
+ else
+ {
+ ERROR ("apache plugin: Cannot parse string "
+ "as boolean value: %s", string);
+ return (-1);
+ }
+ }
+
+ return (0);
+} /* }}} int config_set_boolean */
+
+static int config_add (oconfig_item_t *ci)
+{
+ apache_t *st;
+ int i;
+ int status;
+
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("apache plugin: The `%s' config option "
+ "needs exactly one string argument.", ci->key);
return (-1);
}
- if (curl != NULL)
+ st = (apache_t *) malloc (sizeof (*st));
+ if (st == NULL)
{
- curl_easy_cleanup (curl);
+ ERROR ("apache plugin: malloc failed.");
+ return (-1);
}
- if ((curl = curl_easy_init ()) == NULL)
+ memset (st, 0, sizeof (*st));
+
+ status = config_set_string (&st->name, ci);
+ if (status != 0)
{
- ERROR ("apache plugin: init: `curl_easy_init' failed.");
+ sfree (st);
+ return (status);
+ }
+ assert (st->name != NULL);
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+ if (strcasecmp ("URL", child->key) == 0)
+ status = config_set_string (&st->url, child);
+ else if (strcasecmp ("Host", child->key) == 0)
+ status = config_set_string (&st->host, child);
+ else if (strcasecmp ("User", child->key) == 0)
+ status = config_set_string (&st->user, child);
+ else if (strcasecmp ("Password", child->key) == 0)
+ status = config_set_string (&st->pass, child);
+ else if (strcasecmp ("VerifyPeer", child->key) == 0)
+ status = config_set_boolean (&st->verify_peer, child);
+ else if (strcasecmp ("VerifyHost", child->key) == 0)
+ status = config_set_boolean (&st->verify_host, child);
+ else if (strcasecmp ("CACert", child->key) == 0)
+ status = config_set_string (&st->cacert, child);
+ else if (strcasecmp ("Server", child->key) == 0)
+ status = config_set_string (&st->server, child);
+ else
+ {
+ WARNING ("apache plugin: Option `%s' not allowed here.",
+ child->key);
+ status = -1;
+ }
+
+ if (status != 0)
+ break;
+ }
+
+ /* Check if struct is complete.. */
+ if ((status == 0) && (st->url == NULL))
+ {
+ ERROR ("apache plugin: Instance `%s': "
+ "No URL has been configured.",
+ st->name);
+ status = -1;
+ }
+
+ if (status == 0)
+ {
+ user_data_t ud;
+ char callback_name[3*DATA_MAX_NAME_LEN];
+
+ memset (&ud, 0, sizeof (ud));
+ ud.data = st;
+ ud.free_func = (void *) apache_free;
+
+ memset (callback_name, 0, sizeof (callback_name));
+ ssnprintf (callback_name, sizeof (callback_name),
+ "apache/%s/%s",
+ (st->host != NULL) ? st->host : hostname_g,
+ (st->name != NULL) ? st->name : "default"),
+
+ status = plugin_register_complex_read (callback_name,
+ /* callback = */ apache_read_host,
+ /* interval = */ NULL,
+ /* user_data = */ &ud);
+ }
+
+ if (status != 0)
+ {
+ apache_free(st);
return (-1);
}
- curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, apache_curl_callback);
- curl_easy_setopt (curl, CURLOPT_USERAGENT, PACKAGE_NAME"/"PACKAGE_VERSION);
- curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, apache_curl_error);
+ return (0);
+} /* int config_add */
- if (user != NULL)
+static int config (oconfig_item_t *ci)
+{
+ int status = 0;
+ int i;
+ oconfig_item_t *lci = NULL; /* legacy config */
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+ if (strcasecmp ("Instance", child->key) == 0 && child->children_num > 0)
+ config_add (child);
+ else
+ {
+ /* legacy mode - convert to <Instance ...> config */
+ if (lci == NULL)
+ {
+ lci = malloc (sizeof(*lci));
+ if (lci == NULL)
+ {
+ ERROR ("apache plugin: malloc failed.");
+ return (-1);
+ }
+ memset (lci, '\0', sizeof (*lci));
+ }
+
+ lci->children_num++;
+ lci->children =
+ realloc (lci->children,
+ lci->children_num * sizeof (*child));
+ if (lci->children == NULL)
+ {
+ ERROR ("apache plugin: realloc failed.");
+ return (-1);
+ }
+ memcpy (&lci->children[lci->children_num-1], child, sizeof (*child));
+ }
+ } /* for (ci->children) */
+
+ if (lci)
+ {
+ /* create a <Instance ""> entry */
+ lci->key = "Instance";
+ lci->values_num = 1;
+ lci->values = (oconfig_value_t *) malloc (lci->values_num * sizeof (oconfig_value_t));
+ lci->values[0].type = OCONFIG_TYPE_STRING;
+ lci->values[0].value.string = "";
+
+ status = config_add (lci);
+ sfree (lci->values);
+ sfree (lci->children);
+ sfree (lci);
+ }
+
+ return status;
+} /* int config */
+
+/* initialize curl for each host */
+static int init_host (apache_t *st) /* {{{ */
+{
+ static char credentials[1024];
+
+ assert (st->url != NULL);
+ /* (Assured by `config_add') */
+
+ if (st->curl != NULL)
+ {
+ curl_easy_cleanup (st->curl);
+ st->curl = NULL;
+ }
+
+ if ((st->curl = curl_easy_init ()) == NULL)
+ {
+ ERROR ("apache plugin: init_host: `curl_easy_init' failed.");
+ return (-1);
+ }
+
+ curl_easy_setopt (st->curl, CURLOPT_WRITEFUNCTION, apache_curl_callback);
+ curl_easy_setopt (st->curl, CURLOPT_WRITEDATA, st);
+
+ /* not set as yet if the user specified string doesn't match apache or
+ * lighttpd, then ignore it. Headers will be parsed to find out the
+ * server type */
+ st->server_type = -1;
+
+ if (st->server != NULL)
+ {
+ if (strcasecmp(st->server, "apache") == 0)
+ st->server_type = APACHE;
+ else if (strcasecmp(st->server, "lighttpd") == 0)
+ st->server_type = LIGHTTPD;
+ else
+ WARNING ("apache plugin: Unknown `Server' setting: %s",
+ st->server);
+ }
+
+ /* if not found register a header callback to determine the server_type */
+ if (st->server_type == -1)
+ {
+ curl_easy_setopt (st->curl, CURLOPT_HEADERFUNCTION, apache_header_callback);
+ curl_easy_setopt (st->curl, CURLOPT_WRITEHEADER, st);
+ }
+
+ curl_easy_setopt (st->curl, CURLOPT_USERAGENT, PACKAGE_NAME"/"PACKAGE_VERSION);
+ curl_easy_setopt (st->curl, CURLOPT_ERRORBUFFER, st->apache_curl_error);
+
+ if (st->user != NULL)
{
int status;
status = ssnprintf (credentials, sizeof (credentials), "%s:%s",
- user, (pass == NULL) ? "" : pass);
+ st->user, (st->pass == NULL) ? "" : st->pass);
if ((status < 0) || ((size_t) status >= sizeof (credentials)))
{
- ERROR ("apache plugin: init: Returning an error "
+ ERROR ("apache plugin: init_host: Returning an error "
"because the credentials have been "
"truncated.");
+ curl_easy_cleanup (st->curl);
+ st->curl = NULL;
return (-1);
}
- curl_easy_setopt (curl, CURLOPT_USERPWD, credentials);
+ curl_easy_setopt (st->curl, CURLOPT_USERPWD, credentials);
}
- curl_easy_setopt (curl, CURLOPT_URL, url);
+ curl_easy_setopt (st->curl, CURLOPT_URL, st->url);
- if ((verify_peer == NULL) || (strcmp (verify_peer, "true") == 0))
+ if (st->verify_peer != 0)
{
- curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 1);
+ curl_easy_setopt (st->curl, CURLOPT_SSL_VERIFYPEER, 1);
}
else
{
- curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0);
+ curl_easy_setopt (st->curl, CURLOPT_SSL_VERIFYPEER, 0);
}
- if ((verify_host == NULL) || (strcmp (verify_host, "true") == 0))
+ if (st->verify_host != 0)
{
- curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 2);
+ curl_easy_setopt (st->curl, CURLOPT_SSL_VERIFYHOST, 2);
}
else
{
- curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0);
+ curl_easy_setopt (st->curl, CURLOPT_SSL_VERIFYHOST, 0);
}
- if (cacert != NULL)
+ if (st->cacert != NULL)
{
- curl_easy_setopt (curl, CURLOPT_CAINFO, cacert);
+ curl_easy_setopt (st->curl, CURLOPT_CAINFO, st->cacert);
}
return (0);
-} /* int init */
+} /* }}} int init_host */
-static void submit_counter (const char *type, const char *type_instance,
- counter_t value)
+static void submit_value (const char *type, const char *type_instance,
+ value_t value, apache_t *st)
{
- value_t values[1];
value_list_t vl = VALUE_LIST_INIT;
- values[0].counter = value;
-
- vl.values = values;
+ vl.values = &value;
vl.values_len = 1;
- sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+
+ sstrncpy (vl.host, (st->host != NULL) ? st->host : hostname_g,
+ sizeof (vl.host));
+
sstrncpy (vl.plugin, "apache", sizeof (vl.plugin));
- sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
- sstrncpy (vl.type, type, sizeof (vl.type));
+ if (st->name != NULL)
+ sstrncpy (vl.plugin_instance, st->name,
+ sizeof (vl.plugin_instance));
+ sstrncpy (vl.type, type, sizeof (vl.type));
if (type_instance != NULL)
sstrncpy (vl.type_instance, type_instance,
sizeof (vl.type_instance));
plugin_dispatch_values (&vl);
+} /* void submit_value */
+
+static void submit_counter (const char *type, const char *type_instance,
+ counter_t c, apache_t *st)
+{
+ value_t v;
+ v.counter = c;
+ submit_value (type, type_instance, v, st);
} /* void submit_counter */
static void submit_gauge (const char *type, const char *type_instance,
- gauge_t value)
+ gauge_t g, apache_t *st)
{
- value_t values[1];
- value_list_t vl = VALUE_LIST_INIT;
-
- values[0].gauge = value;
+ value_t v;
+ v.gauge = g;
+ submit_value (type, type_instance, v, st);
+} /* void submit_gauge */
- vl.values = values;
- vl.values_len = 1;
- sstrncpy (vl.host, hostname_g, sizeof (vl.host));
- sstrncpy (vl.plugin, "apache", sizeof (vl.plugin));
- sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
- sstrncpy (vl.type, type, sizeof (vl.type));
-
- if (type_instance != NULL)
- sstrncpy (vl.type_instance, type_instance,
- sizeof (vl.type_instance));
-
- plugin_dispatch_values (&vl);
-} /* void submit_counter */
-
-static void submit_scoreboard (char *buf)
+static void submit_scoreboard (char *buf, apache_t *st)
{
/*
* Scoreboard Key:
- * "_" Waiting for Connection, "S" Starting up, "R" Reading Request,
+ * "_" Waiting for Connection, "S" Starting up,
+ * "R" Reading Request for apache and read-POST for lighttpd,
* "W" Sending Reply, "K" Keepalive (read), "D" DNS Lookup,
* "C" Closing connection, "L" Logging, "G" Gracefully finishing,
* "I" Idle cleanup of worker, "." Open slot with no current process
+ * Lighttpd specific legends -
+ * "E" hard error, "." connect, "h" handle-request,
+ * "q" request-start, "Q" request-end, "s" response-start
+ * "S" response-end, "r" read
*/
long long open = 0LL;
long long waiting = 0LL;
long long finishing = 0LL;
long long idle_cleanup = 0LL;
- int i;
+ /* lighttpd specific */
+ long long hard_error = 0LL;
+ long long lighttpd_read = 0LL;
+ long long handle_request = 0LL;
+ long long request_start = 0LL;
+ long long request_end = 0LL;
+ long long response_start = 0LL;
+ long long response_end = 0LL;
+ int i;
for (i = 0; buf[i] != '\0'; i++)
{
if (buf[i] == '.') open++;
else if (buf[i] == 'L') logging++;
else if (buf[i] == 'G') finishing++;
else if (buf[i] == 'I') idle_cleanup++;
+ else if (buf[i] == 'r') lighttpd_read++;
+ else if (buf[i] == 'h') handle_request++;
+ else if (buf[i] == 'E') hard_error++;
+ else if (buf[i] == 'q') request_start++;
+ else if (buf[i] == 'Q') request_end++;
+ else if (buf[i] == 's') response_start++;
+ else if (buf[i] == 'S') response_end++;
}
- submit_gauge ("apache_scoreboard", "open" , open);
- submit_gauge ("apache_scoreboard", "waiting" , waiting);
- submit_gauge ("apache_scoreboard", "starting" , starting);
- submit_gauge ("apache_scoreboard", "reading" , reading);
- submit_gauge ("apache_scoreboard", "sending" , sending);
- submit_gauge ("apache_scoreboard", "keepalive", keepalive);
- submit_gauge ("apache_scoreboard", "dnslookup", dnslookup);
- submit_gauge ("apache_scoreboard", "closing" , closing);
- submit_gauge ("apache_scoreboard", "logging" , logging);
- submit_gauge ("apache_scoreboard", "finishing", finishing);
- submit_gauge ("apache_scoreboard", "idle_cleanup", idle_cleanup);
+ if (st->server_type == APACHE)
+ {
+ submit_gauge ("apache_scoreboard", "open" , open, st);
+ submit_gauge ("apache_scoreboard", "waiting" , waiting, st);
+ submit_gauge ("apache_scoreboard", "starting" , starting, st);
+ submit_gauge ("apache_scoreboard", "reading" , reading, st);
+ submit_gauge ("apache_scoreboard", "sending" , sending, st);
+ submit_gauge ("apache_scoreboard", "keepalive", keepalive, st);
+ submit_gauge ("apache_scoreboard", "dnslookup", dnslookup, st);
+ submit_gauge ("apache_scoreboard", "closing" , closing, st);
+ submit_gauge ("apache_scoreboard", "logging" , logging, st);
+ submit_gauge ("apache_scoreboard", "finishing", finishing, st);
+ submit_gauge ("apache_scoreboard", "idle_cleanup", idle_cleanup, st);
+ }
+ else
+ {
+ submit_gauge ("apache_scoreboard", "connect" , open, st);
+ submit_gauge ("apache_scoreboard", "close" , closing, st);
+ submit_gauge ("apache_scoreboard", "hard_error" , hard_error, st);
+ submit_gauge ("apache_scoreboard", "read" , lighttpd_read, st);
+ submit_gauge ("apache_scoreboard", "read_post" , reading, st);
+ submit_gauge ("apache_scoreboard", "write" , sending, st);
+ submit_gauge ("apache_scoreboard", "handle_request", handle_request, st);
+ submit_gauge ("apache_scoreboard", "request_start" , request_start, st);
+ submit_gauge ("apache_scoreboard", "request_end" , request_end, st);
+ submit_gauge ("apache_scoreboard", "response_start", response_start, st);
+ submit_gauge ("apache_scoreboard", "response_end" , response_end, st);
+ }
}
-static int apache_read (void)
+static int apache_read_host (user_data_t *user_data) /* {{{ */
{
int i;
char *fields[4];
int fields_num;
- if (curl == NULL)
- return (-1);
- if (url == NULL)
- return (-1);
+ apache_t *st;
+
+ st = user_data->data;
+
+ assert (st->url != NULL);
+ /* (Assured by `config_add') */
+
+ if (st->curl == NULL)
+ {
+ int status;
+
+ status = init_host (st);
+ if (status != 0)
+ return (-1);
+ }
+ assert (st->curl != NULL);
- apache_buffer_fill = 0;
- if (curl_easy_perform (curl) != 0)
+ st->apache_buffer_fill = 0;
+ if (curl_easy_perform (st->curl) != 0)
{
ERROR ("apache: curl_easy_perform failed: %s",
- apache_curl_error);
+ st->apache_curl_error);
return (-1);
}
- ptr = apache_buffer;
+ /* fallback - server_type to apache if not set at this time */
+ if (st->server_type == -1)
+ {
+ WARNING ("apache plugin: Unable to determine server software "
+ "automatically. Will assume Apache.");
+ st->server_type = APACHE;
+ }
+
+ ptr = st->apache_buffer;
saveptr = NULL;
while ((lines[lines_num] = strtok_r (ptr, "\n\r", &saveptr)) != NULL)
{
if ((strcmp (fields[0], "Total") == 0)
&& (strcmp (fields[1], "Accesses:") == 0))
submit_counter ("apache_requests", "",
- atoll (fields[2]));
+ atoll (fields[2]), st);
else if ((strcmp (fields[0], "Total") == 0)
&& (strcmp (fields[1], "kBytes:") == 0))
submit_counter ("apache_bytes", "",
- 1024LL * atoll (fields[2]));
+ 1024LL * atoll (fields[2]), st);
}
else if (fields_num == 2)
{
if (strcmp (fields[0], "Scoreboard:") == 0)
- submit_scoreboard (fields[1]);
+ submit_scoreboard (fields[1], st);
else if (strcmp (fields[0], "BusyServers:") == 0)
- submit_gauge ("apache_connections", NULL, atol (fields[1]));
+ submit_gauge ("apache_connections", NULL, atol (fields[1]), st);
}
}
- apache_buffer_fill = 0;
+ st->apache_buffer_fill = 0;
return (0);
-} /* int apache_read */
+} /* }}} int apache_read_host */
void module_register (void)
{
- plugin_register_config ("apache", config,
- config_keys, config_keys_num);
- plugin_register_init ("apache", init);
- plugin_register_read ("apache", apache_read);
+ plugin_register_complex_config ("apache", config);
} /* void module_register */
+
+/* vim: set sw=8 noet fdm=marker : */
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)
{
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 */
--- /dev/null
+=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>
+
# include "config.h"
#endif
-/* Set to C99 and POSIX code */
-#if COLLECT_STANDARDS
-# include "standards.h"
-#endif /* COLLECT_STANDARDS */
-
#if !defined(__GNUC__) || !__GNUC__
# define __attribute__(x) /**/
#endif
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.
=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
# http://collectd.org/
#
+##############################################################################
+# Global #
+#----------------------------------------------------------------------------#
+# Global settings for the daemon. #
+##############################################################################
+
#Hostname "localhost"
FQDNLookup true
#BaseDir "@prefix@/var/lib/@PACKAGE_NAME@"
#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_CONNTRACK_TRUE@LoadPlugin conntrack
+@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_FSCACHE_TRUE@LoadPlugin fscache
+#@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_MEMCACHEC_TRUE@LoadPlugin memcachec
+#@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_TABLE_TRUE@LoadPlugin table
+#@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_TED_TRUE@LoadPlugin ted
+#@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"
# </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"
# 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
# Port "411"
#</Plugin>
+#<Plugin memcachec>
+# <Page "plugin_instance">
+# Server "localhost"
+# Key "page_key"
+# <Match>
+# Regex "(\\d+) bytes sent"
+# DSType CounterAdd
+# Type "ipt_octets"
+# Instance "type_instance"
+# </Match>
+# </Page>
+#</Plugin>
+
#<Plugin memcached>
# Host "127.0.0.1"
# Port "11211"
#</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>
# IgnoreSelected false
#</Plugin>
-# 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"
# Process "name"
#</Plugin>
+#<Plugin protocols>
+# Value "/^Tcp:/"
+# IgnoreSelected false
+#</Plugin>
+
#<Plugin rrdcached>
# DaemonAddress "unix:/tmp/rrdcached.sock"
# DataDir "@prefix@/var/lib/@PACKAGE_NAME@/rrd"
# Instance "IF-MIB::ifDescr"
# Values "IF-MIB::ifInOctets" "IF-MIB::ifOutOctets"
# </Data>
-#
+#
# <Host "some.switch.mydomain.org">
# Address "192.168.0.2"
# Version 1
# </Host>
#</Plugin>
+#<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>
+
#<Plugin "tail">
# <File "/var/log/exim4/mainlog">
# Instance "exim"
# Server "8767"
#</Plugin>
+#<Plugin ted>
+# Device "/dev/ttyUSB0"
+# Retries 0
+#</Plugin>
+
#<Plugin thermal>
# ForceUseProcfs false
# Device "THRM"
# 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
#@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"
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
=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),
=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
=back
+=head2 Plugin C<memcachec>
+
+The C<memcachec plugin> connects to a memcached server, queries one or more
+given I<pages> and parses the returned data according to user specification.
+The I<matches> used are the same as the matches used in the C<curl> and C<tail>
+plugins.
+
+In order to talk to the memcached server, this plugin uses the I<libmemcached>
+library. Please note that there is another library with a very similar name,
+libmemcache (notice the missing `d'), which is not applicable.
+
+Synopsis of the configuration:
+
+ <Plugin "memcachec">
+ <Page "plugin_instance">
+ Server "localhost"
+ Key "page_key"
+ <Match>
+ Regex "(\\d+) bytes sent"
+ DSType CounterAdd
+ Type "ipt_octets"
+ Instance "type_instance"
+ </Match>
+ </Page>
+ </Plugin>
+
+The configuration options are:
+
+=over 4
+
+=item E<lt>B<Page> I<Name>E<gt>
+
+Each B<Page> block defines one I<page> to be queried from the memcached server.
+The block requires one string argument which is used as I<plugin instance>.
+
+=item B<Server> I<Address>
+
+Sets the server address to connect to when querying the page. Must be inside a
+B<Page> block.
+
+=item B<Key> I<Key>
+
+When connected to the memcached server, asks for the page I<Key>.
+
+=item E<lt>B<Match>E<gt>
+
+Match blocks define which strings to look for and how matches substrings are
+interpreted. For a description of match blocks, please see L<"Plugin tail">.
+
+=back
+
=head2 Plugin C<memcached>
The C<memcached plugin> connects to a memcached server and queries statistics
=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.
+
+Synopsis:
+
+ <Plugin mysql>
+ <Database foo>
+ Host "hostname"
+ User "username"
+ Password "password"
+ Port "3306"
+ MasterStats true
+ </Database>
-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.
+ <Database bar>
+ Host "localhost"
+ Socket "/var/run/mysql/mysqld.sock"
+ SlaveStats true
+ SlaveNotifications true
+ </Database>
+ </Plugin>
-Use the following options to configure the 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
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>
=head2 Plugin C<network>
+The Network plugin sends data to a remote instance of collectd, receives data
+from a remote instance, or both at the same time. Data which has been received
+from the network is usually not transmitted again, but this can be actived, see
+the B<Forward> option below.
+
+The default IPv6 multicast group is C<ff18::efc0:4a42>. The default IPv4
+multicast group is C<239.192.74.66>. The default I<UDP> port is B<25826>.
+
+Both, B<Server> and B<Listen> can be used as single option or as block. When
+used as block, given options are valid for this socket only. For example:
+
+ <Plugin "network">
+ Server "collectd.internal.tld"
+ <Server "collectd.external.tld">
+ SecurityLevel "sign"
+ Username "myhostname"
+ Password "ohl0eQue"
+ </Server>
+ </Plugin>
+
=over 4
-=item B<Listen> I<Host> [I<Port>]
+=item B<E<lt>Server> I<Host> [I<Port>]B<E<gt>>
-=item B<Server> I<Host> [I<Port>]
+The B<Server> statement/block sets the server to send datagrams to. The
+statement may occur multiple times to send each datagram to multiple
+destinations.
-The B<Server> statement sets the server to send datagrams B<to>. The statement
-may occur multiple times to send each datagram to multiple destinations.
+The argument I<Host> may be a hostname, an IPv4 address or an IPv6 address. The
+optional second argument specifies a port number or a service name. If not
+given, the default, B<25826>, is used.
+
+The following options are recognized within B<Server> 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>. The integrity of encrypted packets is ensured using I<SHA-1>. When
+set to B<Sign>, transmitted data is signed using the I<HMAC-SHA-256> message
+authentication code. When set to B<None>, data is sent without any security.
+
+This feature is only available if the I<network> plugin was linked with
+I<libgcrypt>.
+
+=item B<Username> I<Username>
+
+Sets the username to transmit. This is used by the server to lookup the
+password. See B<AuthFile> below. All security levels except B<None> require
+this setting.
+
+This feature is only available if the I<network> plugin was linked with
+I<libgcrypt>.
+
+=item B<Password> I<Password>
+
+Sets a password (shared secret) for this socket. All security levels except
+B<None> require this setting.
+
+This feature is only available if the I<network> plugin was linked with
+I<libgcrypt>.
+
+=back
+
+=item B<E<lt>Listen> I<Host> [I<Port>]B<E<gt>>
The B<Listen> statement sets the interfaces to bind to. When multiple
statements are found the daemon will bind to multiple interfaces.
The argument I<Host> may be a hostname, an IPv4 address or an IPv6 address. If
the argument is a multicast address the daemon will join that multicast group.
+The optional second argument specifies a port number or a service name. If not
+given, the default, B<25826>, is used.
-If no B<Listen> statement is found the server tries join both, the default IPv6
-multicast group and the default IPv4 multicast group. If no B<Server> statement
-is found the client will try to send data to the IPv6 multicast group first. If
-that fails the client will try the IPv4 multicast group.
+The following options are recognized within C<E<lt>ListenE<gt>> blocks:
-The default IPv6 multicast group is C<ff18::efc0:4a42>. The default IPv4
-multicast group is C<239.192.74.66>.
+=over 4
+
+=item B<SecurityLevel> B<Encrypt>|B<Sign>|B<None>
-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.
+Set the security you require for network communication. When the security level
+has been set to B<Encrypt>, only encrypted data will be accepted. The integrity
+of encrypted packets is ensured using I<SHA-1>. When set to B<Sign>, only
+signed and encrypted data is accepted. When set to B<None>, all data will be
+accepted. If an B<AuthFile> option was given (see below), encrypted data is
+decrypted if possible.
+
+This feature is only available if the I<network> plugin was linked with
+I<libgcrypt>.
+
+=item B<AuthFile> I<Filename>
+
+Sets a file in which usernames are mapped to passwords. These passwords are
+used to verify signatures and to decrypt encrypted network packets. If
+B<SecurityLevel> is set to B<None>, this is optional. If given, signed data is
+verified and encrypted packets are decrypted. Otherwise, signed data is
+accepted without checking the signature and encrypted data cannot be decrypted.
+For the other security levels this option is mandatory.
+
+The file format is very simple: Each line consists of a username followed by a
+colon and any number of spaces followed by the password. To demonstrate, an
+example file could look like this:
+
+ user0: foo
+ user1: bar
+
+Each time a packet is received, the modification time of the file is checked
+using L<stat(2)>. If the file has been changed, the contents is re-read. While
+the file is being read, it is locked using L<fcntl(2)>.
+
+=back
=item B<TimeToLive> I<1-255>
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
=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>
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.
=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)>,
=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)>.
=back
+=head2 Plugin C<teamspeak2>
+
+The C<teamspeak2 plugin> connects to the query port of a teamspeak2 server and
+polls interesting global and virtual server data. The plugin can query only one
+physical server but unlimited virtual servers. You can use the following
+options to configure it:
+
+=over 4
+
+=item B<Host> I<hostname/ip>
+
+The hostname or ip which identifies the physical server.
+Default: 127.0.0.1
+
+=item B<Port> I<port>
+
+The query port of the physical server. This needs to be a string.
+Default: "51234"
+
+=item B<Server> I<port>
+
+This option has to be added once for every virtual server the plugin should
+query. If you want to query the virtual server on port 8767 this is what the
+option would look like:
+
+ Server "8767"
+
+This option, although numeric, needs to be a string, i.E<nbsp>e. you B<must>
+use quotes around it! If no such statement is given only global information
+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
=back
-=head2 Plugin C<teamspeak2>
-
-The C<teamspeak2 plugin> connects to the query port of a teamspeak2 server and
-polls interesting global and virtual server data. The plugin can query only one
-physical server but unlimited virtual servers. You can use the following
-options to configure it:
-
-=over 4
-
-=item B<Host> I<hostname/ip>
-
-The hostname or ip which identifies the physical server.
-Default: 127.0.0.1
-
-=item B<Port> I<port>
-
-The query port of the physical server. This needs to be a string.
-Default: "51234"
-
-=item B<Server> I<port>
-
-This option has to be added once for every virtual server the plugin should
-query. If you want to query the virtual server on port 8767 this is what the
-option would look like:
-
- Server "8767"
-
-This option, although numeric, needs to be a string, i.E<nbsp>e. you B<must>
-use quotes around it! If no such statement is given only global information
-will be collected.
-
-=back
-
=head2 Plugin C<thermal>
=over 4
break;
}
- return (i);
+ return ((int) i);
}
int strjoin (char *dst, size_t dst_len,
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;
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;
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;
}
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++;
*
* 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
*/
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
(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
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
free (key);
free (value);
- DEBUG ("return (%i)", ret);
+ DEBUG ("cf_dispatch: return (%i)", ret);
return (ret);
} /* int cf_dispatch */
--- /dev/null
+/**
+ * collectd - src/conntrack.c
+ * Copyright (C) 2009 Tomasz Pala
+ *
+ * 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:
+ * Tomasz Pala <gotar at pld-linux.org>
+ * based on entropy.c by:
+ * Florian octo Forster <octo at verplant.org>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+
+#if !KERNEL_LINUX
+# error "No applicable input method."
+#endif
+
+#define CONNTRACK_FILE "/proc/sys/net/netfilter/nf_conntrack_count"
+
+static void conntrack_submit (double conntrack)
+{
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
+
+ values[0].gauge = conntrack;
+
+ vl.values = values;
+ vl.values_len = 1;
+ sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy (vl.plugin, "conntrack", sizeof (vl.plugin));
+ sstrncpy (vl.type, "conntrack", sizeof (vl.type));
+
+ plugin_dispatch_values (&vl);
+} /* static void conntrack_submit */
+
+static int conntrack_read (void)
+{
+ double conntrack;
+ FILE *fh;
+ char buffer[64];
+
+ fh = fopen (CONNTRACK_FILE, "r");
+ if (fh == NULL)
+ return (-1);
+
+ if (fgets (buffer, sizeof (buffer), fh) == NULL)
+ {
+ fclose (fh);
+ return (-1);
+ }
+ fclose (fh);
+
+ conntrack = atof (buffer);
+
+ if (conntrack > 0.0)
+ conntrack_submit (conntrack);
+
+ return (0);
+} /* static int conntrack_read */
+
+void module_register (void)
+{
+ plugin_register_read ("conntrack", conntrack_read);
+} /* void module_register */
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];
{
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 */
* Florian octo Forster <octo at verplant.org>
**/
+#define _BSD_SOURCE
+
#include "collectd.h"
#include "common.h"
#include "plugin.h"
* Peter Holik <peter at holik.at>
**/
+#define _BSD_SOURCE /* For setgroups */
+
#include "collectd.h"
#include "common.h"
#include "plugin.h"
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;
} /* for (pl) */
return (0);
-} /* int exec_notification */
+} /* }}} int exec_notification */
static int exec_shutdown (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 */
--- /dev/null
+/**
+ * collectd - src/fscache.c
+ * Copyright (C) 2009 Edward "Koko" Konetzko
+ *
+ * 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:
+ * Edward "Koko" Konetzko <konetzed at quixoticagony.com>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include <stdio.h> /* a header needed for FILE */
+#include <string.h> /* a header needed for scanf function */
+#include <stdlib.h> /* used for atoi */
+
+
+#if !KERNEL_LINUX
+# error "This module only supports the Linux implementation of fscache"
+#endif
+
+#define BUFSIZE 1024
+
+/*
+see /proc/fs/fscache/stats
+see Documentation/filesystems/caching/fscache.txt in linux kernel >= 2.6.30
+
+This shows counts of a number of events that can happen in FS-Cache:
+
+CLASS EVENT MEANING
+======= ======= =======================================================
+Cookies idx=N Number of index cookies allocated
+ dat=N Number of data storage cookies allocated
+ spc=N Number of special cookies allocated
+Objects alc=N Number of objects allocated
+ nal=N Number of object allocation failures
+ avl=N Number of objects that reached the available state
+ ded=N Number of objects that reached the dead state
+ChkAux non=N Number of objects that didn't have a coherency check
+ ok=N Number of objects that passed a coherency check
+ upd=N Number of objects that needed a coherency data update
+ obs=N Number of objects that were declared obsolete
+Pages mrk=N Number of pages marked as being cached
+ unc=N Number of uncache page requests seen
+Acquire n=N Number of acquire cookie requests seen
+ nul=N Number of acq reqs given a NULL parent
+ noc=N Number of acq reqs rejected due to no cache available
+ ok=N Number of acq reqs succeeded
+ nbf=N Number of acq reqs rejected due to error
+ oom=N Number of acq reqs failed on ENOMEM
+Lookups n=N Number of lookup calls made on cache backends
+ neg=N Number of negative lookups made
+ pos=N Number of positive lookups made
+ crt=N Number of objects created by lookup
+Updates n=N Number of update cookie requests seen
+ nul=N Number of upd reqs given a NULL parent
+ run=N Number of upd reqs granted CPU time
+Relinqs n=N Number of relinquish cookie requests seen
+ nul=N Number of rlq reqs given a NULL parent
+ wcr=N Number of rlq reqs waited on completion of creation
+AttrChg n=N Number of attribute changed requests seen
+ ok=N Number of attr changed requests queued
+ nbf=N Number of attr changed rejected -ENOBUFS
+ oom=N Number of attr changed failed -ENOMEM
+ run=N Number of attr changed ops given CPU time
+Allocs n=N Number of allocation requests seen
+ ok=N Number of successful alloc reqs
+ wt=N Number of alloc reqs that waited on lookup completion
+ nbf=N Number of alloc reqs rejected -ENOBUFS
+ ops=N Number of alloc reqs submitted
+ owt=N Number of alloc reqs waited for CPU time
+Retrvls n=N Number of retrieval (read) requests seen
+ ok=N Number of successful retr reqs
+ wt=N Number of retr reqs that waited on lookup completion
+ nod=N Number of retr reqs returned -ENODATA
+ nbf=N Number of retr reqs rejected -ENOBUFS
+ int=N Number of retr reqs aborted -ERESTARTSYS
+ oom=N Number of retr reqs failed -ENOMEM
+ ops=N Number of retr reqs submitted
+ owt=N Number of retr reqs waited for CPU time
+Stores n=N Number of storage (write) requests seen
+ ok=N Number of successful store reqs
+ agn=N Number of store reqs on a page already pending storage
+ nbf=N Number of store reqs rejected -ENOBUFS
+ oom=N Number of store reqs failed -ENOMEM
+ ops=N Number of store reqs submitted
+ run=N Number of store reqs granted CPU time
+Ops pend=N Number of times async ops added to pending queues
+ run=N Number of times async ops given CPU time
+ enq=N Number of times async ops queued for processing
+ dfr=N Number of async ops queued for deferred release
+ rel=N Number of async ops released
+ gc=N Number of deferred-release async ops garbage collected
+
+63 events to collect in 13 groups
+*/
+static void fscache_submit (const char *section, const char *name,
+ counter_t counter_value)
+{
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
+
+ vl.values = values;
+ vl.values_len = 1;
+
+ vl.values[0].counter = counter_value;
+
+ sstrncpy(vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy(vl.plugin, "fscache", sizeof (vl.plugin));
+ sstrncpy(vl.plugin_instance, section, sizeof (vl.plugin_instance));
+ sstrncpy(vl.type, "fscache_stat", sizeof(vl.type));
+ sstrncpy(vl.type_instance, name, sizeof(vl.type_instance));
+
+ plugin_dispatch_values (&vl);
+}
+
+static void fscache_read_stats_file (FILE *fh)
+{
+ char section[DATA_MAX_NAME_LEN];
+ size_t section_len;
+
+ char linebuffer[BUFSIZE];
+
+/*
+ * cat /proc/fs/fscache/stats
+ * FS-Cache statistics
+ * Cookies: idx=2 dat=0 spc=0
+ * Objects: alc=0 nal=0 avl=0 ded=0
+ * ChkAux : non=0 ok=0 upd=0 obs=0
+ * Pages : mrk=0 unc=0
+ * Acquire: n=2 nul=0 noc=0 ok=2 nbf=0 oom=0
+ * Lookups: n=0 neg=0 pos=0 crt=0
+ * Updates: n=0 nul=0 run=0
+ * Relinqs: n=0 nul=0 wcr=0
+ * AttrChg: n=0 ok=0 nbf=0 oom=0 run=0
+ * Allocs : n=0 ok=0 wt=0 nbf=0
+ * Allocs : ops=0 owt=0
+ * Retrvls: n=0 ok=0 wt=0 nod=0 nbf=0 int=0 oom=0
+ * Retrvls: ops=0 owt=0
+ * Stores : n=0 ok=0 agn=0 nbf=0 oom=0
+ * Stores : ops=0 run=0
+ * Ops : pend=0 run=0 enq=0
+ * Ops : dfr=0 rel=0 gc=0
+ */
+
+ /* Read file line by line */
+ while (fgets (linebuffer, sizeof (linebuffer), fh) != NULL)
+ {
+ char *lineptr;
+ char *fields[32];
+ int fields_num;
+ int i;
+
+ /* Find the colon and replace it with a null byte */
+ lineptr = strchr (linebuffer, ':');
+ if (lineptr == NULL)
+ continue;
+ *lineptr = 0;
+ lineptr++;
+
+ /* Copy and clean up the section name */
+ sstrncpy (section, linebuffer, sizeof (section));
+ section_len = strlen (section);
+ while ((section_len > 0) && isspace ((int) section[section_len - 1]))
+ {
+ section_len--;
+ section[section_len] = 0;
+ }
+ if (section_len <= 0)
+ continue;
+
+ fields_num = strsplit (lineptr, fields, STATIC_ARRAY_SIZE (fields));
+ if (fields_num <= 0)
+ continue;
+
+ for (i = 0; i < fields_num; i++)
+ {
+ char *field_name;
+ char *field_value_str;
+ char *endptr;
+ counter_t field_value_cnt;
+
+ field_name = fields[i];
+ assert (field_name != NULL);
+
+ field_value_str = strchr (field_name, '=');
+ if (field_value_str == NULL)
+ continue;
+ *field_value_str = 0;
+ field_value_str++;
+
+ errno = 0;
+ endptr = NULL;
+ field_value_cnt = (counter_t) strtoull (field_value_str,
+ &endptr, /* base = */ 10);
+ if ((errno != 0) || (endptr == field_value_str))
+ continue;
+
+ fscache_submit (section, field_name, field_value_cnt);
+ }
+ } /* while (fgets) */
+} /* void fscache_read_stats_file */
+
+static int fscache_read (void){
+ FILE *fh;
+ fh = fopen("/proc/fs/fscache/stats", "r");
+ if (fh != NULL){
+ fscache_read_stats_file(fh);
+ fclose(fh);
+
+ }else{
+ printf("cant open file\n");
+ return (-1);
+ }
+ return (0);
+}
+
+void module_register (void)
+{
+ plugin_register_read ("fscache", fscache_read);
+} /* void module_register */
+
+/* vim: set sw=4 sts=4 et : */
--- /dev/null
+/**
+ * collectd - src/gmond.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 "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 : */
* collectd - src/iptables.c
* Copyright (C) 2007 Sjoerd van der Berg
* Copyright (C) 2007 Florian octo Forster
+ * 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
* Authors:
* Sjoerd van der Berg <harekiet at users.sourceforge.net>
* Florian Forster <octo at verplant.org>
+ * Marco Chiappero <marco at absence.it>
**/
#include "collectd.h"
#include "plugin.h"
#include "configfile.h"
+#include <sys/socket.h>
+
#if OWN_LIBIPTC
# include "libiptc/libiptc.h"
+# include "libiptc/libip6tc.h"
#else
# include <libiptc/libiptc.h>
+# include <libiptc/libip6tc.h>
#endif
/*
static const char *config_keys[] =
{
"Chain",
- NULL
+ "Chain6"
};
-static int config_keys_num = 1;
+static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
/*
Each table/chain combo that will be queried goes into this list
*/
+
+enum protocol_version_e
+{
+ IPV4,
+ IPV6
+};
+typedef enum protocol_version_e protocol_version_t;
+
#ifndef XT_TABLE_MAXNAMELEN
# define XT_TABLE_MAXNAMELEN 32
#endif
typedef struct {
+ protocol_version_t ip_version;
char table[XT_TABLE_MAXNAMELEN];
char chain[XT_TABLE_MAXNAMELEN];
union
static int iptables_config (const char *key, const char *value)
{
+ /* int ip_value; */
+ protocol_version_t ip_version = 0;
+
if (strcasecmp (key, "Chain") == 0)
+ ip_version = IPV4;
+ else if (strcasecmp (key, "Chain6") == 0)
+ ip_version = IPV6;
+
+ if (( ip_version == IPV4 ) || ( ip_version == IPV6 ))
{
ip_chain_t temp, *final, **list;
char *table;
return (1);
}
+ /*
+ * Time to fill the temp element
+ * Examine value string, it should look like:
+ * Chain[6] <table> <chain> [<comment|num> [name]]
+ */
+
+ /* set IPv4 or IPv6 */
+ temp.ip_version = ip_version;
+
/* Chain <table> <chain> [<comment|num> [name]] */
fields_num = strsplit (value_copy, fields, 4);
if (fields_num < 2)
return (0);
} /* int iptables_config */
+static int submit6_match (const struct ip6t_entry_match *match,
+ const struct ip6t_entry *entry,
+ const ip_chain_t *chain,
+ int rule_num)
+{
+ int status;
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
+
+ /* Select the rules to collect */
+ if (chain->rule_type == RTYPE_NUM)
+ {
+ if (chain->rule.num != rule_num)
+ return (0);
+ }
+ else
+ {
+ if (strcmp (match->u.user.name, "comment") != 0)
+ return (0);
+ if ((chain->rule_type == RTYPE_COMMENT)
+ && (strcmp (chain->rule.comment, (char *) match->data) != 0))
+ return (0);
+ }
+
+ vl.values = values;
+ vl.values_len = 1;
+ sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy (vl.plugin, "ip6tables", sizeof (vl.plugin));
+
+ status = ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
+ "%s-%s", chain->table, chain->chain);
+ if ((status < 1) || ((unsigned int)status >= sizeof (vl.plugin_instance)))
+ return (0);
+
+ if (chain->name[0] != '\0')
+ {
+ sstrncpy (vl.type_instance, chain->name, sizeof (vl.type_instance));
+ }
+ else
+ {
+ if (chain->rule_type == RTYPE_NUM)
+ ssnprintf (vl.type_instance, sizeof (vl.type_instance),
+ "%i", chain->rule.num);
+ else
+ sstrncpy (vl.type_instance, (char *) match->data,
+ sizeof (vl.type_instance));
+ }
+
+ sstrncpy (vl.type, "ipt_bytes", sizeof (vl.type));
+ values[0].counter = (counter_t) entry->counters.bcnt;
+ plugin_dispatch_values (&vl);
+
+ sstrncpy (vl.type, "ipt_packets", sizeof (vl.type));
+ values[0].counter = (counter_t) entry->counters.pcnt;
+ plugin_dispatch_values (&vl);
+
+ return (0);
+} /* int submit_match */
+
+
/* This needs to return `int' for IPT_MATCH_ITERATE to work. */
static int submit_match (const struct ipt_entry_match *match,
const struct ipt_entry *entry,
plugin_dispatch_values (&vl);
return (0);
-} /* void submit_match */
+} /* int submit_match */
+
+
+/* ipv6 submit_chain */
+static void submit6_chain( ip6tc_handle_t *handle, ip_chain_t *chain )
+{
+ const struct ip6t_entry *entry;
+ int rule_num;
-static void submit_chain( iptc_handle_t *handle, ip_chain_t *chain ) {
+ /* Find first rule for chain and use the iterate macro */
+ entry = ip6tc_first_rule( chain->chain, handle );
+ if (entry == NULL)
+ {
+ DEBUG ("ip6tc_first_rule failed: %s", ip6tc_strerror (errno));
+ return;
+ }
+
+ rule_num = 1;
+ while (entry)
+ {
+ if (chain->rule_type == RTYPE_NUM)
+ {
+ submit6_match (NULL, entry, chain, rule_num);
+ }
+ else
+ {
+ IP6T_MATCH_ITERATE( entry, submit6_match, entry, chain, rule_num );
+ }
+
+ entry = ip6tc_next_rule( entry, handle );
+ rule_num++;
+ } /* while (entry) */
+}
+
+
+/* ipv4 submit_chain */
+static void submit_chain( iptc_handle_t *handle, ip_chain_t *chain )
+{
const struct ipt_entry *entry;
int rule_num;
{
int i;
int num_failures = 0;
+ ip_chain_t *chain;
/* Init the iptc handle structure and query the correct table */
for (i = 0; i < chain_num; i++)
{
- iptc_handle_t handle;
- ip_chain_t *chain;
-
chain = chain_list[i];
+
if (!chain)
{
DEBUG ("iptables plugin: chain == NULL");
continue;
}
- handle = iptc_init (chain->table);
- if (!handle)
- {
- ERROR ("iptables plugin: iptc_init (%s) failed: %s",
- chain->table, iptc_strerror (errno));
- num_failures++;
- continue;
- }
+ if ( chain->ip_version == IPV4 )
+ {
+ iptc_handle_t handle;
+ handle = iptc_init (chain->table);
+
+ if (!handle)
+ {
+ ERROR ("iptables plugin: iptc_init (%s) failed: %s",
+ chain->table, iptc_strerror (errno));
+ num_failures++;
+ continue;
+ }
+
+ submit_chain (&handle, chain);
+ iptc_free (&handle);
+ }
+ else if ( chain->ip_version == IPV6 )
+ {
+ ip6tc_handle_t handle;
+ handle = ip6tc_init (chain->table);
+
+ if (!handle)
+ {
+ ERROR ("iptables plugin: ip6tc_init (%s) failed: %s",
+ chain->table, ip6tc_strerror (errno));
+ num_failures++;
+ continue;
+ }
+
+ submit6_chain (&handle, chain);
+ ip6tc_free (&handle);
+ }
+ else num_failures++;
- submit_chain (&handle, chain);
- iptc_free (&handle);
} /* for (i = 0 .. chain_num) */
return ((num_failures < chain_num) ? 0 : -1);
--- /dev/null
+/**
+ * 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;
+
+ { /* Replace all dots ('.') with slashes ('/'). Dots are usually used
+ thorough the Java community, but (Sun's) `FindClass' and friends need
+ slashes. */
+ size_t i;
+ for (i = 0; class->name[i] != 0; i++)
+ if (class->name[i] == '.')
+ class->name[i] = '/';
+ }
+
+ 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 : */
# include "config.h"
#endif
-/* Set to C99 and POSIX code */
-#if COLLECT_STANDARDS
-# include "standards.h"
-#endif /* COLLECT_STANDARDS */
-
#if !defined(__GNUC__) || !__GNUC__
# define __attribute__(x) /**/
#endif
buf[0] = 0;
#if !HAVE_STRERROR_R
- snprintf (buf, buflen "Error #%i; strerror_r is not available.", errnum);
+ snprintf (buf, buflen, "Error #%i; strerror_r is not available.", errnum);
/* #endif !HAVE_STRERROR_R */
#elif STRERROR_R_CHAR_P
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;
}
/*
- * vim:shiftwidth=2:tabstop=8:softtabstop=2
+ * vim:shiftwidth=2:tabstop=8:softtabstop=2:fdm=marker
*/
/**
* 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
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);
/*
+++ /dev/null
- 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.
+++ /dev/null
-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.
+++ /dev/null
-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
+++ /dev/null
- 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>
-
+++ /dev/null
-/**
- * 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;
-}
+++ /dev/null
-/**
- * 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 */
* Florian octo Forster <octo at verplant.org>
**/
+#define _BSD_SOURCE
+
#include "collectd.h"
#include "common.h"
#include "plugin.h"
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;
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;
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 */
{
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 : */
--- /dev/null
+/**
+ * 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 libmemcached 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 : */
* Copyright (C) 2007 Antony Dovgal
* Copyright (C) 2007-2009 Florian Forster
* Copyright (C) 2009 Doug MacEachern
+ * Copyright (C) 2009 Franck Lombardi
*
* 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
* Antony Dovgal <tony at daylessday dot org>
* Florian octo Forster <octo at verplant.org>
* Doug MacEachern <dougm at hyperic.com>
+ * Franck Lombardi
**/
#include "collectd.h"
# include <poll.h>
# include <netdb.h>
# include <sys/socket.h>
+# include <sys/un.h>
# include <netinet/in.h>
# include <netinet/tcp.h>
static const char *config_keys[] =
{
+ "Socket",
"Host",
"Port"
};
static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
+static char *memcached_socket = NULL;
static char *memcached_host = NULL;
static char memcached_port[16];
int fd;
ssize_t status;
int buffer_fill;
+ int i = 0;
- const char *host;
- const char *port;
+ if (memcached_socket != NULL) {
+ struct sockaddr_un serv_addr;
- struct addrinfo ai_hints;
- struct addrinfo *ai_list, *ai_ptr;
- int ai_return, i = 0;
+ memset (&serv_addr, 0, sizeof (serv_addr));
+ serv_addr.sun_family = AF_UNIX;
+ sstrncpy (serv_addr.sun_path, memcached_socket,
+ sizeof (serv_addr.sun_path));
- 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 = AF_INET;
- ai_hints.ai_socktype = SOCK_STREAM;
- ai_hints.ai_protocol = 0;
+ /* create our socket descriptor */
+ fd = socket (AF_UNIX, SOCK_STREAM, 0);
+ if (fd < 0) {
+ char errbuf[1024];
+ ERROR ("memcached: unix socket: %s", sstrerror (errno, errbuf,
+ sizeof (errbuf)));
+ return -1;
+ }
- host = memcached_host;
- if (host == NULL) {
- host = MEMCACHED_DEF_HOST;
+ /* connect to the memcached daemon */
+ status = (ssize_t) connect (fd, (struct sockaddr *) &serv_addr,
+ sizeof (serv_addr));
+ if (status != 0) {
+ shutdown (fd, SHUT_RDWR);
+ close (fd);
+ fd = -1;
+ }
}
+ else { /* if (memcached_socket == NULL) */
+ const char *host;
+ const char *port;
- port = memcached_port;
- if (strlen (port) == 0) {
- port = MEMCACHED_DEF_PORT;
- }
+ struct addrinfo ai_hints;
+ struct addrinfo *ai_list, *ai_ptr;
+ int ai_return = 0;
- if ((ai_return = getaddrinfo (host, port, NULL, &ai_list)) != 0) {
- char errbuf[1024];
- ERROR ("memcached: getaddrinfo (%s, %s): %s",
- host, port,
- (ai_return == EAI_SYSTEM)
- ? sstrerror (errno, errbuf, sizeof (errbuf))
- : gai_strerror (ai_return));
- return -1;
- }
+ 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 = AF_INET;
+ ai_hints.ai_socktype = SOCK_STREAM;
+ ai_hints.ai_protocol = 0;
- fd = -1;
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
- /* create our socket descriptor */
- if ((fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol)) < 0) {
+ host = memcached_host;
+ if (host == NULL) {
+ host = MEMCACHED_DEF_HOST;
+ }
+
+ port = memcached_port;
+ if (strlen (port) == 0) {
+ port = MEMCACHED_DEF_PORT;
+ }
+
+ if ((ai_return = getaddrinfo (host, port, NULL, &ai_list)) != 0) {
char errbuf[1024];
- ERROR ("memcached: socket: %s", sstrerror (errno, errbuf, sizeof (errbuf)));
- continue;
+ ERROR ("memcached: getaddrinfo (%s, %s): %s",
+ host, port,
+ (ai_return == EAI_SYSTEM)
+ ? sstrerror (errno, errbuf, sizeof (errbuf))
+ : gai_strerror (ai_return));
+ return -1;
}
- /* connect to the memcached daemon */
- if (connect (fd, (struct sockaddr *) ai_ptr->ai_addr, ai_ptr->ai_addrlen)) {
- shutdown(fd, SHUT_RDWR);
- close(fd);
- fd = -1;
- continue;
+ fd = -1;
+ for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
+ /* create our socket descriptor */
+ fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
+ if (fd < 0) {
+ char errbuf[1024];
+ ERROR ("memcached: socket: %s", sstrerror (errno, errbuf, sizeof (errbuf)));
+ continue;
+ }
+
+ /* connect to the memcached daemon */
+ status = (ssize_t) connect (fd, (struct sockaddr *) ai_ptr->ai_addr, ai_ptr->ai_addrlen);
+ if (status != 0) {
+ shutdown (fd, SHUT_RDWR);
+ close (fd);
+ fd = -1;
+ continue;
+ }
+
+ /* A socket could be opened and connecting succeeded. We're
+ * done. */
+ break;
}
- /* A socket could be opened and connecting succeeded. We're
- * done. */
- break;
+ freeaddrinfo (ai_list);
}
- freeaddrinfo (ai_list);
-
if (fd < 0) {
ERROR ("memcached: Could not connect to daemon.");
return -1;
static int memcached_config (const char *key, const char *value) /* {{{ */
{
- if (strcasecmp (key, "Host") == 0) {
+ if (strcasecmp (key, "Socket") == 0) {
+ if (memcached_socket != NULL) {
+ free (memcached_socket);
+ }
+ memcached_socket = strdup (value);
+ } else if (strcasecmp (key, "Host") == 0) {
if (memcached_host != NULL) {
free (memcached_host);
}
#define FIELD_IS(cnst) \
(((sizeof(cnst) - 1) == name_len) && (strcmp (cnst, fields[1]) == 0))
- ptr = buf;
- saveptr = NULL;
- while ((line = strtok_r (ptr, "\n\r", &saveptr)) != NULL)
+ ptr = buf;
+ saveptr = NULL;
+ while ((line = strtok_r (ptr, "\n\r", &saveptr)) != NULL)
{
int name_len;
- ptr = NULL;
+ ptr = NULL;
fields_num = strsplit(line, fields, 3);
if (fields_num != 3)
{
rusage_syst = atoll(fields[2]);
}
-
+
/*
* Number of threads of this instance
*/
{
submit_gauge ("memcached_items", "current", atof (fields[2]));
}
-/*
- else if (FIELD_IS ("total_items"))
- {
- total_items = atoll(fields[2]);
- }
- */
/*
* Number of bytes used and available (total - used)
{
submit_gauge ("memcached_connections", "current", atof (fields[2]));
}
-/*
- else if (FIELD_IS("total_connections"))
- {
- total_connections = atoll(fields[2]);
- }
-*/
-
-/*
- * ``Number of connection structures allocated by the server''
- else if (FIELD_IS ("connection_structures"))
- {
- connection_structures = atof(fields[2]);
- }
- */
/*
* Commands
if (!isnan (bytes_used) && !isnan (bytes_total) && (bytes_used <= bytes_total))
submit_gauge2 ("df", "cache", bytes_used, bytes_total - bytes_used);
-
+
if ((rusage_user != 0) || (rusage_syst != 0))
submit_counter2 ("ps_cputime", NULL, rusage_user, rusage_syst);
if ((octets_rx != 0) || (octets_tx != 0))
submit_counter2 ("memcached_octets", NULL, octets_rx, octets_tx);
-
+
if (!isnan (gets) && !isnan (hits))
{
gauge_t rate = NAN;
* tab-width: 4
* c-basic-offset: 4
* End:
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
+ * vim600: sw=4 ts=4 fdm=marker noexpandtab
+ * vim<600: sw=4 ts=4 noexpandtab
*/
/**
* collectd - src/memory.c
* Copyright (C) 2005-2008 Florian octo Forster
+ * Copyright (C) 2009 Simon Kuhnle
*
* 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
*
* Authors:
* Florian octo Forster <octo at verplant.org>
+ * Simon Kuhnle <simon at blarzwurst.de>
**/
#include "collectd.h"
static kstat_t *ksp;
/* #endif HAVE_LIBKSTAT */
+#elif HAVE_SYSCTL
+static int pagesize;
+/* #endif HAVE_SYSCTL */
+
#elif HAVE_LIBSTATGRAB
/* no global variables */
/* endif HAVE_LIBSTATGRAB */
ksp = NULL;
return (-1);
}
-#endif /* HAVE_LIBKSTAT */
+/* #endif HAVE_LIBKSTAT */
+
+#elif HAVE_SYSCTL
+ pagesize = getpagesize ();
+ if (pagesize <= 0)
+ {
+ ERROR ("memory plugin: Invalid pagesize: %i", pagesize);
+ return (-1);
+ }
+/* #endif HAVE_SYSCTL */
+
+#elif HAVE_LIBSTATGRAB
+/* no init stuff */
+#endif /* HAVE_LIBSTATGRAB */
return (0);
} /* int memory_init */
memory_submit ("locked", mem_lock);
/* #endif HAVE_LIBKSTAT */
+#elif HAVE_SYSCTL
+ int mib[] = {CTL_VM, VM_METER};
+ struct vmtotal vmtotal;
+ size_t size;
+
+ memset (&vmtotal, 0, sizeof (vmtotal));
+ size = sizeof (vmtotal);
+
+ if (sysctl (mib, 2, &vmtotal, &size, NULL, 0) < 0) {
+ char errbuf[1024];
+ WARNING ("memory plugin: sysctl failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
+ assert (pagesize > 0);
+ memory_submit ("active", vmtotal.t_arm * pagesize);
+ memory_submit ("inactive", (vmtotal.t_rm - vmtotal.t_arm) * pagesize);
+ memory_submit ("free", vmtotal.t_free * pagesize);
+/* #endif HAVE_SYSCTL */
+
#elif HAVE_LIBSTATGRAB
sg_mem_stats *ios;
/**
* collectd - src/mysql.c
- * Copyright (C) 2006–2008 Florian octo Forster
+ * Copyright (C) 2006-2009 Florian octo Forster
* Copyright (C) 2008 Mirko Buffoni
+ * Copyright (C) 2009 Doug MacEachern
+ * Copyright (C) 2009 Sebastian tokkee Harl
+ * Copyright (C) 2009 Rodolphe Quiédeville
*
* 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
* 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>
+ * Rodolphe Quiédeville <rquiedeville at bearstech.com>
**/
#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!");
+ }
- if ((con = mysql_init (con)) == NULL)
+ /* Check that all necessary options have been given. */
+ while (status == 0)
{
- ERROR ("mysql_init failed: %s", mysql_error (con));
- state = 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];
+
+ 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)
+ {
+ 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;
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;
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)))
key = row[0];
val = atoll (row[1]);
- if (strncmp (key, "Com_", 4) == 0)
+ if (strncmp (key, "Com_",
+ strlen ("Com_")) == 0)
{
if (val == 0ULL)
continue;
/* Ignore `prepared statements' */
- if (strncmp (key, "Com_stmt_", 9) != 0)
- counter_submit ("mysql_commands", key + 4, val);
+ if (strncmp (key, "Com_stmt_", strlen ("Com_stmt_")) != 0)
+ counter_submit ("mysql_commands",
+ key + strlen ("Com_"),
+ val, db);
}
- else if (strncmp (key, "Handler_", 8) == 0)
+ else if (strncmp (key, "Handler_",
+ strlen ("Handler_")) == 0)
{
if (val == 0ULL)
continue;
- counter_submit ("mysql_handler", key + 8, val);
+ counter_submit ("mysql_handler",
+ key + strlen ("Handler_"),
+ val, db);
}
- else if (strncmp (key, "Qcache_", 7) == 0)
+ else if (strncmp (key, "Qcache_",
+ strlen ("Qcache_")) == 0)
{
if (strcmp (key, "Qcache_hits") == 0)
qcache_hits = val;
else if (strcmp (key, "Qcache_queries_in_cache") == 0)
qcache_queries_in_cache = (int) val;
}
- else if (strncmp (key, "Bytes_", 6) == 0)
+ else if (strncmp (key, "Bytes_",
+ strlen ("Bytes_")) == 0)
{
if (strcmp (key, "Bytes_received") == 0)
traffic_incoming += val;
else if (strcmp (key, "Bytes_sent") == 0)
traffic_outgoing += val;
}
- else if (strncmp (key, "Threads_", 8) == 0)
+ else if (strncmp (key, "Threads_",
+ strlen ("Threads_")) == 0)
{
if (strcmp (key, "Threads_running") == 0)
threads_running = (int) val;
else if (strcmp (key, "Threads_created") == 0)
threads_created = val;
}
+ else if (strncmp (key, "Table_locks_",
+ strlen ("Table_locks_")) == 0)
+ {
+ counter_submit ("mysql_locks",
+ key + strlen ("Table_locks_"),
+ val, db);
+ }
}
mysql_free_result (res); res = NULL;
|| (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 */
/**
* 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
* Florian octo Forster <octo at verplant.org>
**/
+#define _BSD_SOURCE /* For struct ip_mreq */
+
#include "collectd.h"
#include "plugin.h"
#include "common.h"
#include "configfile.h"
+#include "utils_fbhash.h"
#include "utils_avltree.h"
#include "network.h"
# include <poll.h>
#endif
+#if HAVE_LIBGCRYPT
+# 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:
+ *
+ * 42 bytes for the encryption header
+ * + 64 bytes for the username
+ * -----------
+ * = 106 bytes
+ */
+#define BUFF_SIG_SIZE 106
+
+/*
* Private data types
*/
-typedef struct sockent
+#define SECURITY_LEVEL_NONE 0
+#if HAVE_LIBGCRYPT
+# define SECURITY_LEVEL_SIGN 1
+# define SECURITY_LEVEL_ENCRYPT 2
+#endif
+struct sockent_client
{
- int fd;
+ int fd;
struct sockaddr_storage *addr;
socklen_t addrlen;
- struct sockent *next;
+#if HAVE_LIBGCRYPT
+ int security_level;
+ char *username;
+ char *password;
+ gcry_cipher_hd_t cypher;
+ unsigned char password_hash[32];
+#endif
+};
+
+struct sockent_server
+{
+ int *fd;
+ size_t fd_num;
+#if HAVE_LIBGCRYPT
+ int security_level;
+ char *auth_file;
+ fbhash_t *userdb;
+ gcry_cipher_hd_t cypher;
+#endif
+};
+
+typedef struct sockent
+{
+#define SOCKENT_TYPE_CLIENT 1
+#define SOCKENT_TYPE_SERVER 2
+ int type;
+
+ char *node;
+ char *service;
+
+ union
+ {
+ struct sockent_client client;
+ struct sockent_server server;
+ } data;
+
+ struct sockent *next;
} sockent_t;
/* 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
};
typedef struct part_values_s part_values_t;
+/* 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
+ * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-------------------------------+-------------------------------+
+ * ! Type ! Length !
+ * +-------------------------------+-------------------------------+
+ * ! Hash (Bits 0 - 31) !
+ * : : :
+ * ! Hash (Bits 224 - 255) !
+ * +---------------------------------------------------------------+
+ */
+/* Minimum size */
+#define PART_SIGNATURE_SHA256_SIZE 36
+struct part_signature_sha256_s
+{
+ part_header_t head;
+ unsigned char hash[32];
+ char *username;
+};
+typedef struct part_signature_sha256_s part_signature_sha256_t;
+
+/* 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
+ * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-------------------------------+-------------------------------+
+ * ! Type ! Length !
+ * +-------------------------------+-------------------------------+
+ * ! Original length ! Padding (0 - 15 bytes) !
+ * +-------------------------------+-------------------------------+
+ * ! Hash (Bits 0 - 31) !
+ * : : :
+ * ! Hash (Bits 128 - 159) !
+ * +---------------------------------------------------------------+
+ */
+/* Minimum size */
+#define PART_ENCRYPTION_AES256_SIZE 42
+struct part_encryption_aes256_s
+{
+ part_header_t head;
+ uint16_t username_length;
+ char *username;
+ unsigned char iv[16];
+ /* <encrypted> */
+ unsigned char hash[20];
+ /* <payload /> */
+ /* </encrypted> */
+};
+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;
/*
* 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;
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 size_t 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;
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 */
+#if HAVE_LIBGCRYPT
+static gcry_cipher_hd_t network_get_aes256_cypher (sockent_t *se, /* {{{ */
+ const void *iv, size_t iv_size, const char *username)
+{
+ gcry_error_t err;
+ gcry_cipher_hd_t *cyper_ptr;
+ unsigned char password_hash[32];
+
+ if (se->type == SOCKENT_TYPE_CLIENT)
+ {
+ cyper_ptr = &se->data.client.cypher;
+ memcpy (password_hash, se->data.client.password_hash,
+ sizeof (password_hash));
+ }
+ else
+ {
+ char *secret;
+
+ cyper_ptr = &se->data.server.cypher;
+
+ if (username == NULL)
+ return (NULL);
+
+ secret = fbh_get (se->data.server.userdb, username);
+ if (secret == NULL)
+ return (NULL);
+
+ gcry_md_hash_buffer (GCRY_MD_SHA256,
+ password_hash,
+ secret, strlen (secret));
+
+ sfree (secret);
+ }
+
+ if (*cyper_ptr == NULL)
+ {
+ err = gcry_cipher_open (cyper_ptr,
+ GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB, /* flags = */ 0);
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_cipher_open returned: %s",
+ gcry_strerror (err));
+ *cyper_ptr = NULL;
+ return (NULL);
+ }
+ }
+ else
+ {
+ gcry_cipher_reset (*cyper_ptr);
+ }
+ assert (*cyper_ptr != NULL);
+
+ err = gcry_cipher_setkey (*cyper_ptr,
+ password_hash, sizeof (password_hash));
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_cipher_setkey returned: %s",
+ gcry_strerror (err));
+ gcry_cipher_close (*cyper_ptr);
+ *cyper_ptr = NULL;
+ return (NULL);
+ }
+
+ err = gcry_cipher_setiv (*cyper_ptr, iv, iv_size);
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_cipher_setkey returned: %s",
+ gcry_strerror (err));
+ gcry_cipher_close (*cyper_ptr);
+ *cyper_ptr = NULL;
+ return (NULL);
+ }
+
+ return (*cyper_ptr);
+} /* }}} int network_get_aes256_cypher */
+#endif /* HAVE_LIBGCRYPT */
+
static int write_part_values (char **ret_buffer, int *ret_buffer_len,
const data_set_t *ds, const value_list_t *vl)
{
return (0);
} /* int write_part_string */
-static int parse_part_values (void **ret_buffer, int *ret_buffer_len,
+static int parse_part_values (void **ret_buffer, size_t *ret_buffer_len,
value_t **ret_values, int *ret_num_values)
{
char *buffer = *ret_buffer;
- int buffer_len = *ret_buffer_len;
+ size_t buffer_len = *ret_buffer_len;
uint16_t tmp16;
size_t exp_size;
uint8_t *pkg_types;
value_t *pkg_values;
- if (buffer_len < (15))
+ if (buffer_len < 15)
{
- DEBUG ("network plugin: packet is too short: buffer_len = %i",
- buffer_len);
+ NOTICE ("network plugin: packet is too short: "
+ "buffer_len = %zu", buffer_len);
return (-1);
}
exp_size = 3 * sizeof (uint16_t)
+ pkg_numval * (sizeof (uint8_t) + sizeof (value_t));
- if ((buffer_len < 0) || ((size_t) buffer_len < exp_size))
+ if ((buffer_len < 0) || (buffer_len < exp_size))
{
WARNING ("network plugin: parse_part_values: "
"Packet too short: "
- "Chunk of size %u expected, "
- "but buffer has only %i bytes left.",
- (unsigned int) exp_size, buffer_len);
+ "Chunk of size %zu expected, "
+ "but buffer has only %zu bytes left.",
+ exp_size, buffer_len);
return (-1);
}
return (0);
} /* int parse_part_values */
-static int parse_part_number (void **ret_buffer, int *ret_buffer_len,
+static int parse_part_number (void **ret_buffer, size_t *ret_buffer_len,
uint64_t *value)
{
char *buffer = *ret_buffer;
- int buffer_len = *ret_buffer_len;
+ size_t buffer_len = *ret_buffer_len;
uint16_t tmp16;
uint64_t tmp64;
{
WARNING ("network plugin: parse_part_number: "
"Packet too short: "
- "Chunk of size %u expected, "
- "but buffer has only %i bytes left.",
- (unsigned int) exp_size, buffer_len);
+ "Chunk of size %zu expected, "
+ "but buffer has only %zu bytes left.",
+ exp_size, buffer_len);
return (-1);
}
return (0);
} /* int parse_part_number */
-static int parse_part_string (void **ret_buffer, int *ret_buffer_len,
+static int parse_part_string (void **ret_buffer, size_t *ret_buffer_len,
char *output, int output_len)
{
char *buffer = *ret_buffer;
- int buffer_len = *ret_buffer_len;
+ size_t buffer_len = *ret_buffer_len;
uint16_t tmp16;
size_t header_size = 2 * sizeof (uint16_t);
uint16_t pkg_length;
uint16_t pkg_type;
- if ((buffer_len < 0) || ((size_t) buffer_len < header_size))
+ if ((buffer_len < 0) || (buffer_len < header_size))
{
WARNING ("network plugin: parse_part_string: "
"Packet too short: "
- "Chunk of at least size %u expected, "
- "but buffer has only %i bytes left.",
- (unsigned int) header_size, buffer_len);
+ "Chunk of at least size %zu expected, "
+ "but buffer has only %zu bytes left.",
+ header_size, buffer_len);
return (-1);
}
{
WARNING ("network plugin: parse_part_string: "
"Packet too big: "
- "Chunk of size %hu received, "
- "but buffer has only %i bytes left.",
+ "Chunk of size %"PRIu16" received, "
+ "but buffer has only %zu bytes left.",
pkg_length, buffer_len);
return (-1);
}
return (0);
} /* int parse_part_string */
-static int parse_packet (void *buffer, int buffer_len)
+/* Forward declaration: parse_part_sign_sha256 and parse_part_encr_aes256 call
+ * parse_packet and vice versa. */
+#define PP_SIGNED 0x01
+#define PP_ENCRYPTED 0x02
+static int parse_packet (sockent_t *se,
+ void *buffer, size_t buffer_size, int flags);
+
+#define BUFFER_READ(p,s) do { \
+ memcpy ((p), buffer + buffer_offset, (s)); \
+ buffer_offset += (s); \
+} while (0)
+
+#if HAVE_LIBGCRYPT
+static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
+ void **ret_buffer, size_t *ret_buffer_len, int flags)
+{
+ char *buffer;
+ size_t buffer_len;
+ size_t buffer_offset;
+
+ size_t username_len;
+ char *secret;
+
+ part_signature_sha256_t pss;
+ uint16_t pss_head_length;
+ char hash[sizeof (pss.hash)];
+
+ gcry_md_hd_t hd;
+ gcry_error_t err;
+ unsigned char *hash_ptr;
+
+ buffer = *ret_buffer;
+ buffer_len = *ret_buffer_len;
+ buffer_offset = 0;
+
+ if (se->data.server.userdb == NULL)
+ {
+ NOTICE ("network plugin: Received signed network packet but can't verify "
+ "it because no user DB has been configured. Will accept it.");
+ return (0);
+ }
+
+ /* Check if the buffer has enough data for this structure. */
+ if (buffer_len <= PART_SIGNATURE_SHA256_SIZE)
+ return (-ENOMEM);
+
+ /* Read type and length header */
+ BUFFER_READ (&pss.head.type, sizeof (pss.head.type));
+ BUFFER_READ (&pss.head.length, sizeof (pss.head.length));
+ pss_head_length = ntohs (pss.head.length);
+
+ /* Check if the `pss_head_length' is within bounds. */
+ if ((pss_head_length <= PART_SIGNATURE_SHA256_SIZE)
+ || (pss_head_length > buffer_len))
+ {
+ ERROR ("network plugin: HMAC-SHA-256 with invalid length received.");
+ return (-1);
+ }
+
+ /* Copy the hash. */
+ BUFFER_READ (pss.hash, sizeof (pss.hash));
+
+ /* Calculate username length (without null byte) and allocate memory */
+ username_len = pss_head_length - PART_SIGNATURE_SHA256_SIZE;
+ pss.username = malloc (username_len + 1);
+ if (pss.username == NULL)
+ return (-ENOMEM);
+
+ /* Read the username */
+ BUFFER_READ (pss.username, username_len);
+ pss.username[username_len] = 0;
+
+ assert (buffer_offset == pss_head_length);
+
+ /* Query the password */
+ secret = fbh_get (se->data.server.userdb, pss.username);
+ if (secret == NULL)
+ {
+ ERROR ("network plugin: Unknown user: %s", pss.username);
+ sfree (pss.username);
+ return (-ENOENT);
+ }
+
+ /* Create a hash device and check the HMAC */
+ hd = NULL;
+ err = gcry_md_open (&hd, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
+ if (err != 0)
+ {
+ ERROR ("network plugin: Creating HMAC-SHA-256 object failed: %s",
+ gcry_strerror (err));
+ sfree (secret);
+ sfree (pss.username);
+ return (-1);
+ }
+
+ err = gcry_md_setkey (hd, secret, strlen (secret));
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_md_setkey failed: %s", gcry_strerror (err));
+ gcry_md_close (hd);
+ return (-1);
+ }
+
+ gcry_md_write (hd,
+ buffer + PART_SIGNATURE_SHA256_SIZE,
+ buffer_len - PART_SIGNATURE_SHA256_SIZE);
+ hash_ptr = gcry_md_read (hd, GCRY_MD_SHA256);
+ if (hash_ptr == NULL)
+ {
+ ERROR ("network plugin: gcry_md_read failed.");
+ gcry_md_close (hd);
+ sfree (secret);
+ sfree (pss.username);
+ return (-1);
+ }
+ memcpy (hash, hash_ptr, sizeof (hash));
+
+ /* Clean up */
+ gcry_md_close (hd);
+ hd = NULL;
+
+ sfree (secret);
+ sfree (pss.username);
+
+ if (memcmp (pss.hash, hash, sizeof (pss.hash)) != 0)
+ {
+ WARNING ("network plugin: Verifying HMAC-SHA-256 signature failed: "
+ "Hash mismatch.");
+ }
+ else
+ {
+ parse_packet (se, buffer + buffer_offset, buffer_len - buffer_offset,
+ flags | PP_SIGNED);
+ }
+
+ *ret_buffer = buffer + buffer_len;
+ *ret_buffer_len = 0;
+
+ return (0);
+} /* }}} int parse_part_sign_sha256 */
+/* #endif HAVE_LIBGCRYPT */
+
+#else /* if !HAVE_LIBGCRYPT */
+static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
+ void **ret_buffer, size_t *ret_buffer_size, int flags)
+{
+ static int warning_has_been_printed = 0;
+
+ char *buffer;
+ size_t buffer_size;
+ size_t buffer_offset;
+ uint16_t part_len;
+
+ part_signature_sha256_t pss;
+
+ buffer = *ret_buffer;
+ buffer_size = *ret_buffer_size;
+ buffer_offset = 0;
+
+ if (buffer_size <= PART_SIGNATURE_SHA256_SIZE)
+ return (-ENOMEM);
+
+ BUFFER_READ (&pss.head.type, sizeof (pss.head.type));
+ BUFFER_READ (&pss.head.length, sizeof (pss.head.length));
+ part_len = ntohs (pss.head.length);
+
+ if ((part_len <= PART_SIGNATURE_SHA256_SIZE)
+ || (part_len > buffer_size))
+ return (-EINVAL);
+
+ if (warning_has_been_printed == 0)
+ {
+ WARNING ("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.");
+ warning_has_been_printed = 1;
+ }
+
+ parse_packet (se, buffer + part_len, buffer_size - part_len, flags);
+
+ *ret_buffer = buffer + buffer_size;
+ *ret_buffer_size = 0;
+
+ return (0);
+} /* }}} int parse_part_sign_sha256 */
+#endif /* !HAVE_LIBGCRYPT */
+
+#if HAVE_LIBGCRYPT
+static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
+ void **ret_buffer, size_t *ret_buffer_len,
+ int flags)
+{
+ char *buffer = *ret_buffer;
+ size_t buffer_len = *ret_buffer_len;
+ size_t payload_len;
+ size_t part_size;
+ size_t buffer_offset;
+ uint16_t username_len;
+ part_encryption_aes256_t pea;
+ unsigned char hash[sizeof (pea.hash)];
+
+ gcry_cipher_hd_t cypher;
+ gcry_error_t err;
+
+ /* Make sure at least the header if available. */
+ if (buffer_len <= PART_ENCRYPTION_AES256_SIZE)
+ {
+ NOTICE ("network plugin: parse_part_encr_aes256: "
+ "Discarding short packet.");
+ return (-1);
+ }
+
+ buffer_offset = 0;
+
+ /* Copy the unencrypted information into `pea'. */
+ BUFFER_READ (&pea.head.type, sizeof (pea.head.type));
+ BUFFER_READ (&pea.head.length, sizeof (pea.head.length));
+
+ /* Check the `part size'. */
+ part_size = ntohs (pea.head.length);
+ if ((part_size <= PART_ENCRYPTION_AES256_SIZE)
+ || (part_size > buffer_len))
+ {
+ NOTICE ("network plugin: parse_part_encr_aes256: "
+ "Discarding part with invalid size.");
+ return (-1);
+ }
+
+ /* Read the username */
+ BUFFER_READ (&username_len, sizeof (username_len));
+ username_len = ntohs (username_len);
+
+ if ((username_len <= 0)
+ || (username_len > (part_size - (PART_ENCRYPTION_AES256_SIZE + 1))))
+ {
+ NOTICE ("network plugin: parse_part_encr_aes256: "
+ "Discarding part with invalid username length.");
+ return (-1);
+ }
+
+ assert (username_len > 0);
+ pea.username = malloc (username_len + 1);
+ if (pea.username == NULL)
+ return (-ENOMEM);
+ BUFFER_READ (pea.username, username_len);
+ pea.username[username_len] = 0;
+
+ /* Last but not least, the initialization vector */
+ BUFFER_READ (pea.iv, sizeof (pea.iv));
+
+ /* Make sure we are at the right position */
+ assert (buffer_offset == (username_len +
+ PART_ENCRYPTION_AES256_SIZE - sizeof (pea.hash)));
+
+ cypher = network_get_aes256_cypher (se, pea.iv, sizeof (pea.iv),
+ pea.username);
+ if (cypher == NULL)
+ return (-1);
+
+ payload_len = part_size - (PART_ENCRYPTION_AES256_SIZE + username_len);
+ assert (payload_len > 0);
+
+ /* Decrypt the packet in-place */
+ err = gcry_cipher_decrypt (cypher,
+ buffer + buffer_offset,
+ part_size - buffer_offset,
+ /* in = */ NULL, /* in len = */ 0);
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_cipher_decrypt returned: %s",
+ gcry_strerror (err));
+ return (-1);
+ }
+
+ /* Read the hash */
+ BUFFER_READ (pea.hash, sizeof (pea.hash));
+
+ /* Make sure we're at the right position - again */
+ assert (buffer_offset == (username_len + PART_ENCRYPTION_AES256_SIZE));
+ assert (buffer_offset == (part_size - payload_len));
+
+ /* Check hash sum */
+ memset (hash, 0, sizeof (hash));
+ gcry_md_hash_buffer (GCRY_MD_SHA1, hash,
+ buffer + buffer_offset, payload_len);
+ if (memcmp (hash, pea.hash, sizeof (hash)) != 0)
+ {
+ ERROR ("network plugin: Decryption failed: Checksum mismatch.");
+ return (-1);
+ }
+
+ parse_packet (se, buffer + buffer_offset, payload_len,
+ flags | PP_ENCRYPTED);
+
+ /* Update return values */
+ *ret_buffer = buffer + part_size;
+ *ret_buffer_len = buffer_len - part_size;
+
+ return (0);
+} /* }}} int parse_part_encr_aes256 */
+/* #endif HAVE_LIBGCRYPT */
+
+#else /* if !HAVE_LIBGCRYPT */
+static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
+ void **ret_buffer, size_t *ret_buffer_size, int flags)
+{
+ static int warning_has_been_printed = 0;
+
+ char *buffer;
+ size_t buffer_size;
+ size_t buffer_offset;
+
+ part_header_t ph;
+ size_t ph_length;
+
+ buffer = *ret_buffer;
+ buffer_size = *ret_buffer_size;
+ buffer_offset = 0;
+
+ /* parse_packet assures this minimum size. */
+ assert (buffer_size >= (sizeof (ph.type) + sizeof (ph.length)));
+
+ BUFFER_READ (&ph.type, sizeof (ph.type));
+ BUFFER_READ (&ph.length, sizeof (ph.length));
+ ph_length = ntohs (ph.length);
+
+ if ((ph_length <= PART_ENCRYPTION_AES256_SIZE)
+ || (ph_length > buffer_size))
+ {
+ ERROR ("network plugin: AES-256 encrypted part "
+ "with invalid length received.");
+ return (-1);
+ }
+
+ if (warning_has_been_printed == 0)
+ {
+ WARNING ("network plugin: Received encrypted packet, but the network "
+ "plugin was not linked with libgcrypt, so I cannot "
+ "decrypt it. The part will be discarded.");
+ warning_has_been_printed = 1;
+ }
+
+ *ret_buffer += ph_length;
+ *ret_buffer_size -= ph_length;
+
+ return (0);
+} /* }}} int parse_part_encr_aes256 */
+#endif /* !HAVE_LIBGCRYPT */
+
+#undef BUFFER_READ
+
+static int parse_packet (sockent_t *se, /* {{{ */
+ void *buffer, size_t buffer_size, int flags)
{
int status;
value_list_t vl = VALUE_LIST_INIT;
notification_t n;
- DEBUG ("network plugin: parse_packet: buffer = %p; buffer_len = %i;",
- buffer, buffer_len);
+#if HAVE_LIBGCRYPT
+ int packet_was_signed = (flags & PP_SIGNED);
+ int packet_was_encrypted = (flags & PP_ENCRYPTED);
+ int printed_ignore_warning = 0;
+#endif /* HAVE_LIBGCRYPT */
+
memset (&vl, '\0', sizeof (vl));
memset (&n, '\0', sizeof (n));
status = 0;
- while ((status == 0) && (0 < buffer_len)
- && ((unsigned int) buffer_len > sizeof (part_header_t)))
+ while ((status == 0) && (0 < buffer_size)
+ && ((unsigned int) buffer_size > sizeof (part_header_t)))
{
uint16_t pkg_length;
uint16_t pkg_type;
pkg_length = ntohs (pkg_length);
pkg_type = ntohs (pkg_type);
- if (pkg_length > buffer_len)
+ if (pkg_length > buffer_size)
break;
/* Ensure that this loop terminates eventually */
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_size, flags);
+ if (status != 0)
+ {
+ ERROR ("network plugin: Decrypting AES256 "
+ "part failed "
+ "with status %i.", status);
+ break;
+ }
+ }
+#if HAVE_LIBGCRYPT
+ else if ((se->data.server.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_LIBGCRYPT */
+ else if (pkg_type == TYPE_SIGN_SHA256)
+ {
+ status = parse_part_sign_sha256 (se,
+ &buffer, &buffer_size, flags);
+ if (status != 0)
+ {
+ ERROR ("network plugin: Verifying HMAC-SHA-256 "
+ "signature failed "
+ "with status %i.", status);
+ break;
+ }
+ }
+#if HAVE_LIBGCRYPT
+ else if ((se->data.server.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_LIBGCRYPT */
+ else if (pkg_type == TYPE_VALUES)
{
- status = parse_part_values (&buffer, &buffer_len,
+ status = parse_part_values (&buffer, &buffer_size,
&vl.values, &vl.values_len);
if (status != 0)
else if (pkg_type == TYPE_TIME)
{
uint64_t tmp = 0;
- status = parse_part_number (&buffer, &buffer_len,
+ status = parse_part_number (&buffer, &buffer_size,
&tmp);
if (status == 0)
{
else if (pkg_type == TYPE_INTERVAL)
{
uint64_t tmp = 0;
- status = parse_part_number (&buffer, &buffer_len,
+ status = parse_part_number (&buffer, &buffer_size,
&tmp);
if (status == 0)
vl.interval = (int) tmp;
}
else if (pkg_type == TYPE_HOST)
{
- status = parse_part_string (&buffer, &buffer_len,
+ status = parse_part_string (&buffer, &buffer_size,
vl.host, sizeof (vl.host));
if (status == 0)
sstrncpy (n.host, vl.host, sizeof (n.host));
}
else if (pkg_type == TYPE_PLUGIN)
{
- status = parse_part_string (&buffer, &buffer_len,
+ status = parse_part_string (&buffer, &buffer_size,
vl.plugin, sizeof (vl.plugin));
if (status == 0)
sstrncpy (n.plugin, vl.plugin,
}
else if (pkg_type == TYPE_PLUGIN_INSTANCE)
{
- status = parse_part_string (&buffer, &buffer_len,
+ status = parse_part_string (&buffer, &buffer_size,
vl.plugin_instance,
sizeof (vl.plugin_instance));
if (status == 0)
}
else if (pkg_type == TYPE_TYPE)
{
- status = parse_part_string (&buffer, &buffer_len,
+ status = parse_part_string (&buffer, &buffer_size,
vl.type, sizeof (vl.type));
if (status == 0)
sstrncpy (n.type, vl.type, sizeof (n.type));
}
else if (pkg_type == TYPE_TYPE_INSTANCE)
{
- status = parse_part_string (&buffer, &buffer_len,
+ status = parse_part_string (&buffer, &buffer_size,
vl.type_instance,
sizeof (vl.type_instance));
if (status == 0)
}
else if (pkg_type == TYPE_MESSAGE)
{
- status = parse_part_string (&buffer, &buffer_len,
+ status = parse_part_string (&buffer, &buffer_size,
n.message, sizeof (n.message));
if (status != 0)
else if (pkg_type == TYPE_SEVERITY)
{
uint64_t tmp = 0;
- status = parse_part_number (&buffer, &buffer_len,
+ status = parse_part_number (&buffer, &buffer_size,
&tmp);
if (status == 0)
n.severity = (int) tmp;
" type: 0x%04hx", pkg_type);
buffer = ((char *) buffer) + pkg_length;
}
- } /* while (buffer_len > sizeof (part_header_t)) */
+ } /* while (buffer_size > sizeof (part_header_t)) */
return (status);
-} /* int parse_packet */
+} /* }}} int parse_packet */
-static void free_sockent (sockent_t *se)
+static void free_sockent_client (struct sockent_client *sec) /* {{{ */
{
- sockent_t *next;
- while (se != NULL)
- {
- next = se->next;
- free (se->addr);
- free (se);
- se = next;
- }
-} /* void free_sockent */
+ if (sec->fd >= 0)
+ {
+ close (sec->fd);
+ sec->fd = -1;
+ }
+ sfree (sec->addr);
+#if HAVE_LIBGCRYPT
+ sfree (sec->username);
+ sfree (sec->password);
+ if (sec->cypher != NULL)
+ gcry_cipher_close (sec->cypher);
+#endif
+} /* }}} void free_sockent_client */
+
+static void free_sockent_server (struct sockent_server *ses) /* {{{ */
+{
+ size_t i;
+
+ for (i = 0; i < ses->fd_num; i++)
+ {
+ if (ses->fd[i] >= 0)
+ {
+ close (ses->fd[i]);
+ ses->fd[i] = -1;
+ }
+ }
+
+ sfree (ses->fd);
+#if HAVE_LIBGCRYPT
+ sfree (ses->auth_file);
+ fbh_destroy (ses->userdb);
+ if (ses->cypher != NULL)
+ gcry_cipher_close (ses->cypher);
+#endif
+} /* }}} void free_sockent_server */
+
+static void sockent_destroy (sockent_t *se) /* {{{ */
+{
+ sockent_t *next;
+
+ DEBUG ("network plugin: sockent_destroy (se = %p);", (void *) se);
+
+ while (se != NULL)
+ {
+ next = se->next;
+
+ sfree (se->node);
+ sfree (se->service);
+
+ if (se->type == SOCKENT_TYPE_CLIENT)
+ free_sockent_client (&se->data.client);
+ else
+ free_sockent_server (&se->data.server);
+
+ sfree (se);
+ se = next;
+ }
+} /* }}} void sockent_destroy */
/*
* int network_set_ttl
DEBUG ("network plugin: network_set_ttl: network_config_ttl = %i;",
network_config_ttl);
+ assert (se->type == SOCKENT_TYPE_CLIENT);
+
if ((network_config_ttl < 1) || (network_config_ttl > 255))
return (-1);
else
optname = IP_TTL;
- if (setsockopt (se->fd, IPPROTO_IP, optname,
+ if (setsockopt (se->data.client.fd, IPPROTO_IP, optname,
&network_config_ttl,
sizeof (network_config_ttl)) == -1)
{
else
optname = IPV6_UNICAST_HOPS;
- if (setsockopt (se->fd, IPPROTO_IPV6, optname,
+ if (setsockopt (se->data.client.fd, IPPROTO_IPV6, optname,
&network_config_ttl,
sizeof (network_config_ttl)) == -1)
{
return (0);
} /* int network_set_ttl */
-static int network_bind_socket (const sockent_t *se, const struct addrinfo *ai)
+static int network_bind_socket (int fd, const struct addrinfo *ai)
{
int loop = 0;
int yes = 1;
/* allow multiple sockets to use the same PORT number */
- if (setsockopt(se->fd, SOL_SOCKET, SO_REUSEADDR,
+ if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR,
&yes, sizeof(yes)) == -1) {
char errbuf[1024];
ERROR ("setsockopt: %s",
return (-1);
}
- DEBUG ("fd = %i; calling `bind'", se->fd);
+ DEBUG ("fd = %i; calling `bind'", fd);
- if (bind (se->fd, ai->ai_addr, ai->ai_addrlen) == -1)
+ if (bind (fd, ai->ai_addr, ai->ai_addrlen) == -1)
{
char errbuf[1024];
ERROR ("bind: %s",
{
struct ip_mreq mreq;
- DEBUG ("fd = %i; IPv4 multicast address found", se->fd);
+ DEBUG ("fd = %i; IPv4 multicast address found", fd);
mreq.imr_multiaddr.s_addr = addr->sin_addr.s_addr;
mreq.imr_interface.s_addr = htonl (INADDR_ANY);
- if (setsockopt (se->fd, IPPROTO_IP, IP_MULTICAST_LOOP,
+ if (setsockopt (fd, IPPROTO_IP, IP_MULTICAST_LOOP,
&loop, sizeof (loop)) == -1)
{
char errbuf[1024];
return (-1);
}
- if (setsockopt (se->fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+ if (setsockopt (fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
&mreq, sizeof (mreq)) == -1)
{
char errbuf[1024];
{
struct ipv6_mreq mreq;
- DEBUG ("fd = %i; IPv6 multicast address found", se->fd);
+ DEBUG ("fd = %i; IPv6 multicast address found", fd);
memcpy (&mreq.ipv6mr_multiaddr,
&addr->sin6_addr,
* group on more than one interface.*/
mreq.ipv6mr_interface = 0;
- if (setsockopt (se->fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
+ if (setsockopt (fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
&loop, sizeof (loop)) == -1)
{
char errbuf[1024];
return (-1);
}
- if (setsockopt (se->fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
+ if (setsockopt (fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
&mreq, sizeof (mreq)) == -1)
{
char errbuf[1024];
return (0);
} /* int network_bind_socket */
-static sockent_t *network_create_socket (const char *node,
- const char *service,
- int listen)
+/* Initialize a sockent structure. `type' must be either `SOCKENT_TYPE_CLIENT'
+ * or `SOCKENT_TYPE_SERVER' */
+static int sockent_init (sockent_t *se, int type) /* {{{ */
{
- struct addrinfo ai_hints;
- struct addrinfo *ai_list, *ai_ptr;
- int ai_return;
+ if (se == NULL)
+ return (-1);
- sockent_t *se_head = NULL;
- sockent_t *se_tail = NULL;
+ memset (se, 0, sizeof (*se));
- DEBUG ("node = %s, service = %s", node, service);
+ se->type = SOCKENT_TYPE_CLIENT;
+ se->node = NULL;
+ se->service = NULL;
+ se->next = NULL;
- memset (&ai_hints, '\0', sizeof (ai_hints));
- ai_hints.ai_flags = 0;
-#ifdef AI_PASSIVE
- ai_hints.ai_flags |= AI_PASSIVE;
+ if (type == SOCKENT_TYPE_SERVER)
+ {
+ se->type = SOCKENT_TYPE_SERVER;
+ se->data.server.fd = NULL;
+#if HAVE_LIBGCRYPT
+ se->data.server.security_level = SECURITY_LEVEL_NONE;
+ se->data.server.auth_file = NULL;
+ se->data.server.userdb = NULL;
+ se->data.server.cypher = NULL;
#endif
-#ifdef AI_ADDRCONFIG
- ai_hints.ai_flags |= AI_ADDRCONFIG;
+ }
+ else
+ {
+ se->data.client.fd = -1;
+ se->data.client.addr = NULL;
+#if HAVE_LIBGCRYPT
+ se->data.client.security_level = SECURITY_LEVEL_NONE;
+ se->data.client.username = NULL;
+ se->data.client.password = NULL;
+ se->data.client.cypher = NULL;
#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 ("getaddrinfo (%s, %s): %s",
- (node == NULL) ? "(null)" : node,
- (service == NULL) ? "(null)" : service,
- (ai_return == EAI_SYSTEM)
- ? sstrerror (errno, errbuf, sizeof (errbuf))
- : gai_strerror (ai_return));
- return (NULL);
- }
-
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
- {
- sockent_t *se;
-
- if ((se = (sockent_t *) malloc (sizeof (sockent_t))) == NULL)
- {
- char errbuf[1024];
- ERROR ("malloc: %s",
- sstrerror (errno, errbuf,
- sizeof (errbuf)));
- continue;
- }
-
- if ((se->addr = (struct sockaddr_storage *) malloc (sizeof (struct sockaddr_storage))) == NULL)
- {
- char errbuf[1024];
- ERROR ("malloc: %s",
- sstrerror (errno, errbuf,
- sizeof (errbuf)));
- free (se);
- continue;
- }
+ return (0);
+} /* }}} int sockent_init */
- assert (sizeof (struct sockaddr_storage) >= ai_ptr->ai_addrlen);
- memset (se->addr, '\0', sizeof (struct sockaddr_storage));
- memcpy (se->addr, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
- se->addrlen = ai_ptr->ai_addrlen;
+/* Open the file descriptors for a initialized sockent structure. */
+static int sockent_open (sockent_t *se) /* {{{ */
+{
+ struct addrinfo ai_hints;
+ struct addrinfo *ai_list, *ai_ptr;
+ int ai_return;
- se->fd = socket (ai_ptr->ai_family,
- ai_ptr->ai_socktype,
- ai_ptr->ai_protocol);
- se->next = NULL;
+ const char *node;
+ const char *service;
- if (se->fd == -1)
- {
- char errbuf[1024];
- ERROR ("socket: %s",
- sstrerror (errno, errbuf,
- sizeof (errbuf)));
- free (se->addr);
- free (se);
- continue;
- }
+ if (se == NULL)
+ return (-1);
- if (listen != 0)
+ /* Set up the security structures. */
+#if HAVE_LIBGCRYPT /* {{{ */
+ if (se->type == SOCKENT_TYPE_CLIENT)
+ {
+ if (se->data.client.security_level > SECURITY_LEVEL_NONE)
{
- if (network_bind_socket (se, ai_ptr) != 0)
+ if ((se->data.client.username == NULL)
+ || (se->data.client.password == NULL))
{
- close (se->fd);
- free (se->addr);
- free (se);
- continue;
+ ERROR ("network plugin: Client socket with "
+ "security requested, but no "
+ "credentials are configured.");
+ return (-1);
}
+ gcry_md_hash_buffer (GCRY_MD_SHA256,
+ se->data.client.password_hash,
+ se->data.client.password,
+ strlen (se->data.client.password));
}
- else /* listen == 0 */
+ }
+ else /* (se->type == SOCKENT_TYPE_SERVER) */
+ {
+ if (se->data.server.security_level > SECURITY_LEVEL_NONE)
{
- network_set_ttl (se, ai_ptr);
+ if (se->data.server.auth_file == NULL)
+ {
+ ERROR ("network plugin: Server socket with "
+ "security requested, but no "
+ "password file is configured.");
+ return (-1);
+ }
}
-
- if (se_tail == NULL)
+ if (se->data.server.auth_file != NULL)
{
- se_head = se;
- se_tail = se;
- }
- else
- {
- se_tail->next = se;
- se_tail = se;
+ se->data.server.userdb = fbh_create (se->data.server.auth_file);
+ if (se->data.server.userdb == NULL)
+ {
+ ERROR ("network plugin: Reading password file "
+ "`%s' failed.",
+ se->data.server.auth_file);
+ if (se->data.server.security_level > SECURITY_LEVEL_NONE)
+ return (-1);
+ }
}
-
- /* We don't open more than one write-socket per node/service pair.. */
- if (listen == 0)
- break;
}
+#endif /* }}} HAVE_LIBGCRYPT */
- freeaddrinfo (ai_list);
+ node = se->node;
+ service = se->service;
- return (se_head);
-} /* sockent_t *network_create_socket */
+ if (service == NULL)
+ service = NET_DEFAULT_PORT;
-static sockent_t *network_create_default_socket (int listen)
-{
- 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);
+ DEBUG ("network plugin: sockent_open: node = %s; service = %s;",
+ node, service);
- /* Don't send to the same machine in IPv6 and IPv4 if both are available. */
- if ((listen == 0) && (se_ptr != NULL))
- return (se_ptr);
+ 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;
- if (se_ptr != NULL)
+ ai_return = getaddrinfo (node, service, &ai_hints, &ai_list);
+ if (ai_return != 0)
{
- se_head = se_ptr;
- se_tail = se_ptr;
- while (se_tail->next != NULL)
- se_tail = se_tail->next;
+ ERROR ("network plugin: getaddrinfo (%s, %s) failed: %s",
+ (se->node == NULL) ? "(null)" : se->node,
+ (se->service == NULL) ? "(null)" : se->service,
+ gai_strerror (ai_return));
+ return (-1);
}
- se_ptr = network_create_socket (NET_DEFAULT_V4_ADDR, NET_DEFAULT_PORT, listen);
+ for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ {
+ int status;
- if (se_tail == NULL)
- return (se_ptr);
+ if (se->type == SOCKENT_TYPE_SERVER) /* {{{ */
+ {
+ int *tmp;
- se_tail->next = se_ptr;
- return (se_head);
-} /* sockent_t *network_create_default_socket */
+ tmp = realloc (se->data.server.fd,
+ sizeof (*tmp) * (se->data.server.fd_num + 1));
+ if (tmp == NULL)
+ {
+ ERROR ("network plugin: realloc failed.");
+ continue;
+ }
+ se->data.server.fd = tmp;
+ tmp = se->data.server.fd + se->data.server.fd_num;
-static int network_add_listen_socket (const char *node, const char *service)
-{
- sockent_t *se;
- sockent_t *se_ptr;
- int se_num = 0;
+ *tmp = socket (ai_ptr->ai_family, ai_ptr->ai_socktype,
+ ai_ptr->ai_protocol);
+ if (*tmp < 0)
+ {
+ char errbuf[1024];
+ ERROR ("network plugin: socket(2) failed: %s",
+ sstrerror (errno, errbuf,
+ sizeof (errbuf)));
+ continue;
+ }
- if (service == NULL)
- service = NET_DEFAULT_PORT;
+ status = network_bind_socket (*tmp, ai_ptr);
+ if (status != 0)
+ {
+ close (*tmp);
+ *tmp = -1;
+ continue;
+ }
- if (node == NULL)
- se = network_create_default_socket (1 /* listen == true */);
- else
- se = network_create_socket (node, service, 1 /* listen == true */);
+ se->data.server.fd_num++;
+ continue;
+ } /* }}} if (se->type == SOCKENT_TYPE_SERVER) */
+ else /* if (se->type == SOCKENT_TYPE_CLIENT) {{{ */
+ {
+ se->data.client.fd = socket (ai_ptr->ai_family,
+ ai_ptr->ai_socktype,
+ ai_ptr->ai_protocol);
+ if (se->data.client.fd < 0)
+ {
+ char errbuf[1024];
+ ERROR ("network plugin: socket(2) failed: %s",
+ sstrerror (errno, errbuf,
+ sizeof (errbuf)));
+ continue;
+ }
- if (se == NULL)
- return (-1);
+ se->data.client.addr = malloc (sizeof (*se->data.client.addr));
+ if (se->data.client.addr == NULL)
+ {
+ ERROR ("network plugin: malloc failed.");
+ close (se->data.client.fd);
+ se->data.client.fd = -1;
+ continue;
+ }
- for (se_ptr = se; se_ptr != NULL; se_ptr = se_ptr->next)
- se_num++;
+ memset (se->data.client.addr, 0, sizeof (*se->data.client.addr));
+ assert (sizeof (*se->data.client.addr) >= ai_ptr->ai_addrlen);
+ memcpy (se->data.client.addr, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
+ se->data.client.addrlen = ai_ptr->ai_addrlen;
- listen_sockets = (struct pollfd *) realloc (listen_sockets,
- (listen_sockets_num + se_num)
- * sizeof (struct pollfd));
+ network_set_ttl (se, ai_ptr);
+
+ /* We don't open more than one write-socket per
+ * node/service pair.. */
+ break;
+ } /* }}} if (se->type == SOCKENT_TYPE_CLIENT) */
+ } /* for (ai_list) */
- for (se_ptr = se; se_ptr != NULL; se_ptr = se_ptr->next)
+ freeaddrinfo (ai_list);
+
+ /* Check if all went well. */
+ if (se->type == SOCKENT_TYPE_SERVER)
+ {
+ if (se->data.server.fd_num <= 0)
+ return (-1);
+ }
+ else /* if (se->type == SOCKENT_TYPE_CLIENT) */
{
- 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_num++;
- } /* for (se) */
+ if (se->data.client.fd < 0)
+ return (-1);
+ }
- free_sockent (se);
return (0);
-} /* int network_add_listen_socket */
+} /* }}} int sockent_open */
-static int network_add_sending_socket (const char *node, const char *service)
+/* Add a sockent to the global list of sockets */
+static int sockent_add (sockent_t *se) /* {{{ */
{
- sockent_t *se;
- sockent_t *se_ptr;
-
- if (service == NULL)
- service = NET_DEFAULT_PORT;
-
- if (node == NULL)
- se = network_create_default_socket (0 /* listen == false */);
- else
- se = network_create_socket (node, service, 0 /* listen == false */);
+ sockent_t *last_ptr;
if (se == NULL)
return (-1);
- if (sending_sockets == NULL)
+ if (se->type == SOCKENT_TYPE_SERVER)
{
- sending_sockets = se;
- return (0);
+ struct pollfd *tmp;
+ size_t i;
+
+ tmp = realloc (listen_sockets_pollfd,
+ sizeof (*tmp) * (listen_sockets_num
+ + se->data.server.fd_num));
+ if (tmp == NULL)
+ {
+ ERROR ("network plugin: realloc failed.");
+ return (-1);
+ }
+ listen_sockets_pollfd = tmp;
+ tmp = listen_sockets_pollfd + listen_sockets_num;
+
+ for (i = 0; i < se->data.server.fd_num; i++)
+ {
+ memset (tmp + i, 0, sizeof (*tmp));
+ tmp[i].fd = se->data.server.fd[i];
+ tmp[i].events = POLLIN | POLLPRI;
+ tmp[i].revents = 0;
+ }
+
+ listen_sockets_num += se->data.server.fd_num;
+
+ if (listen_sockets == NULL)
+ {
+ listen_sockets = se;
+ return (0);
+ }
+ last_ptr = listen_sockets;
+ }
+ else /* if (se->type == SOCKENT_TYPE_CLIENT) */
+ {
+ if (sending_sockets == NULL)
+ {
+ sending_sockets = se;
+ return (0);
+ }
+ last_ptr = sending_sockets;
}
- for (se_ptr = sending_sockets; se_ptr->next != NULL; se_ptr = se_ptr->next)
- /* seek end */;
+ while (last_ptr->next != NULL)
+ last_ptr = last_ptr->next;
+ last_ptr->next = se;
- se_ptr->next = se;
return (0);
-} /* int network_get_listen_socket */
+} /* }}} int sockent_add */
-static void *dispatch_thread (void __attribute__((unused)) *arg)
+static void *dispatch_thread (void __attribute__((unused)) *arg) /* {{{ */
{
while (42)
{
receive_list_entry_t *ent;
+ sockent_t *se;
/* Lock and wait for more data to come in */
pthread_mutex_lock (&receive_list_lock);
if (ent == NULL)
break;
- parse_packet (ent->data, ent->data_len);
+ /* Look for the correct `sockent_t' */
+ se = listen_sockets;
+ while (se != NULL)
+ {
+ size_t i;
+
+ for (i = 0; i < se->data.server.fd_num; i++)
+ if (se->data.server.fd[i] == ent->fd)
+ break;
+ if (i < se->data.server.fd_num)
+ break;
+
+ se = se->next;
+ }
+
+ if (se == NULL)
+ {
+ ERROR ("network plugin: Got packet from FD %i, but can't "
+ "find an appropriate socket entry.",
+ ent->fd);
+ sfree (ent);
+ continue;
+ }
+
+ parse_packet (se, ent->data, ent->data_len, /* flags = */ 0);
sfree (ent);
} /* while (42) */
return (NULL);
-} /* void *receive_thread */
+} /* }}} void *dispatch_thread */
-static int network_receive (void)
+static int network_receive (void) /* {{{ */
{
char buffer[BUFF_SIZE];
int buffer_len;
receive_list_entry_t *private_list_head;
receive_list_entry_t *private_list_tail;
- if (listen_sockets_num == 0)
- network_add_listen_socket (NULL, NULL);
-
- if (listen_sockets_num == 0)
- {
- ERROR ("network: Failed to open a listening socket.");
- return (-1);
- }
+ assert (listen_sockets_num > 0);
private_list_head = NULL;
private_list_tail = NULL;
while (listen_loop == 0)
{
- status = poll (listen_sockets, listen_sockets_num, -1);
+ status = poll (listen_sockets_pollfd, listen_sockets_num, -1);
if (status <= 0)
{
{
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)
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)
{
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
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. */
}
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->data.client.fd, buffer, buffer_size,
+ /* flags = */ 0,
+ (struct sockaddr *) se->data.client.addr,
+ se->data.client.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_LIBGCRYPT
+#define BUFFER_ADD(p,s) do { \
+ memcpy (buffer + buffer_offset, (p), (s)); \
+ buffer_offset += (s); \
+} while (0)
+
+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[BUFF_SIG_SIZE + in_buffer_size];
+ size_t buffer_offset;
+ size_t username_len;
+
+ gcry_md_hd_t hd;
+ gcry_error_t err;
+ unsigned char *hash;
+
+ hd = NULL;
+ err = gcry_md_open (&hd, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
+ if (err != 0)
+ {
+ ERROR ("network plugin: Creating HMAC object failed: %s",
+ gcry_strerror (err));
+ return;
+ }
+
+ err = gcry_md_setkey (hd, se->data.client.password,
+ strlen (se->data.client.password));
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_md_setkey failed: %s",
+ gcry_strerror (err));
+ gcry_md_close (hd);
+ return;
+ }
+
+ username_len = strlen (se->data.client.username);
+ if (username_len > (BUFF_SIG_SIZE - PART_SIGNATURE_SHA256_SIZE))
+ {
+ ERROR ("network plugin: Username too long: %s",
+ se->data.client.username);
+ return;
+ }
+
+ memcpy (buffer + PART_SIGNATURE_SHA256_SIZE,
+ se->data.client.username, username_len);
+ memcpy (buffer + PART_SIGNATURE_SHA256_SIZE + username_len,
+ in_buffer, in_buffer_size);
+
+ /* Initialize the `ps' structure. */
+ memset (&ps, 0, sizeof (ps));
+ ps.head.type = htons (TYPE_SIGN_SHA256);
+ ps.head.length = htons (PART_SIGNATURE_SHA256_SIZE + username_len);
+
+ /* Calculate the hash value. */
+ gcry_md_write (hd, buffer + PART_SIGNATURE_SHA256_SIZE,
+ username_len + in_buffer_size);
+ hash = gcry_md_read (hd, GCRY_MD_SHA256);
+ if (hash == NULL)
+ {
+ ERROR ("network plugin: gcry_md_read failed.");
+ gcry_md_close (hd);
+ return;
+ }
+ memcpy (ps.hash, hash, sizeof (ps.hash));
+
+ /* Add the header */
+ buffer_offset = 0;
-static int add_to_buffer (char *buffer, int buffer_size,
+ BUFFER_ADD (&ps.head.type, sizeof (ps.head.type));
+ BUFFER_ADD (&ps.head.length, sizeof (ps.head.length));
+ BUFFER_ADD (ps.hash, sizeof (ps.hash));
+
+ assert (buffer_offset == PART_SIGNATURE_SHA256_SIZE);
+
+ gcry_md_close (hd);
+ hd = NULL;
+
+ buffer_offset = PART_SIGNATURE_SHA256_SIZE + username_len + in_buffer_size;
+ networt_send_buffer_plain (se, buffer, buffer_offset);
+} /* }}} void networt_send_buffer_signed */
+
+static void networt_send_buffer_encrypted (sockent_t *se, /* {{{ */
+ const char *in_buffer, size_t in_buffer_size)
+{
+ part_encryption_aes256_t pea;
+ char buffer[BUFF_SIG_SIZE + in_buffer_size];
+ size_t buffer_size;
+ size_t buffer_offset;
+ size_t header_size;
+ size_t username_len;
+ gcry_error_t err;
+ gcry_cipher_hd_t cypher;
+
+ /* Initialize the header fields */
+ memset (&pea, 0, sizeof (pea));
+ pea.head.type = htons (TYPE_ENCR_AES256);
+
+ pea.username = se->data.client.username;
+
+ username_len = strlen (pea.username);
+ if ((PART_ENCRYPTION_AES256_SIZE + username_len) > BUFF_SIG_SIZE)
+ {
+ ERROR ("network plugin: Username too long: %s", pea.username);
+ return;
+ }
+
+ buffer_size = PART_ENCRYPTION_AES256_SIZE + username_len + in_buffer_size;
+ header_size = PART_ENCRYPTION_AES256_SIZE + username_len
+ - sizeof (pea.hash);
+
+ assert (buffer_size <= sizeof (buffer));
+ DEBUG ("network plugin: networt_send_buffer_encrypted: "
+ "buffer_size = %zu;", buffer_size);
+
+ pea.head.length = htons ((uint16_t) (PART_ENCRYPTION_AES256_SIZE
+ + username_len + in_buffer_size));
+ pea.username_length = htons ((uint16_t) username_len);
+
+ /* Chose a random initialization vector. */
+ gcry_randomize ((void *) &pea.iv, sizeof (pea.iv), GCRY_STRONG_RANDOM);
+
+ /* Create hash of the payload */
+ gcry_md_hash_buffer (GCRY_MD_SHA1, pea.hash, in_buffer, in_buffer_size);
+
+ /* Initialize the buffer */
+ buffer_offset = 0;
+ memset (buffer, 0, sizeof (buffer));
+
+
+ BUFFER_ADD (&pea.head.type, sizeof (pea.head.type));
+ BUFFER_ADD (&pea.head.length, sizeof (pea.head.length));
+ BUFFER_ADD (&pea.username_length, sizeof (pea.username_length));
+ BUFFER_ADD (pea.username, username_len);
+ BUFFER_ADD (pea.iv, sizeof (pea.iv));
+ assert (buffer_offset == header_size);
+ BUFFER_ADD (pea.hash, sizeof (pea.hash));
+ BUFFER_ADD (in_buffer, in_buffer_size);
+
+ assert (buffer_offset == buffer_size);
+
+ cypher = network_get_aes256_cypher (se, pea.iv, sizeof (pea.iv),
+ se->data.client.password);
+ if (cypher == NULL)
+ return;
+
+ /* Encrypt the buffer in-place */
+ err = gcry_cipher_encrypt (cypher,
+ buffer + header_size,
+ buffer_size - header_size,
+ /* in = */ NULL, /* in len = */ 0);
+ 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 */
+#undef BUFFER_ADD
+#endif /* HAVE_LIBGCRYPT */
+
+static void network_send_buffer (char *buffer, size_t buffer_len) /* {{{ */
+{
+ sockent_t *se;
+
+ DEBUG ("network plugin: network_send_buffer: buffer_len = %zu", buffer_len);
+
+ for (se = sending_sockets; se != NULL; se = se->next)
+ {
+#if HAVE_LIBGCRYPT
+ if (se->data.client.security_level == SECURITY_LEVEL_ENCRYPT)
+ networt_send_buffer_encrypted (se, buffer, buffer_len);
+ else if (se->data.client.security_level == SECURITY_LEVEL_SIGN)
+ networt_send_buffer_signed (se, buffer, buffer_len);
+ else /* if (se->data.client.security_level == SECURITY_LEVEL_NONE) */
+#endif /* HAVE_LIBGCRYPT */
+ 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)
{
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;
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)
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);
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);
-
- 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];
+ return (0);
+} /* }}} int network_config_set_boolean */
- if (strcasecmp ("Listen", key) == 0)
- network_add_listen_socket (node, service);
- else
- network_add_sending_socket (node, service);
+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);
+ }
- 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 */
+ tmp = (int) ci->values[0].value.number;
+ if ((tmp > 0) && (tmp <= 255))
+ network_config_ttl = tmp;
+
+ return (0);
+} /* }}} int network_config_set_ttl */
+
+#if HAVE_LIBGCRYPT
+static int network_config_set_string (const oconfig_item_t *ci, /* {{{ */
+ char **ret_string)
+{
+ char *tmp;
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("network plugin: The `%s' config option needs exactly "
+ "one string argument.", ci->key);
+ return (-1);
+ }
+
+ tmp = strdup (ci->values[0].value.string);
+ if (tmp == NULL)
+ return (-1);
-static int network_notification (const notification_t *n)
+ sfree (*ret_string);
+ *ret_string = tmp;
+
+ return (0);
+} /* }}} int network_config_set_string */
+#endif /* HAVE_LIBGCRYPT */
+
+#if HAVE_LIBGCRYPT
+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_LIBGCRYPT */
+
+static int network_config_add_listen (const oconfig_item_t *ci) /* {{{ */
+{
+ sockent_t *se;
+ int status;
+ 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);
+ }
+
+ se = malloc (sizeof (*se));
+ if (se == NULL)
+ {
+ ERROR ("network plugin: malloc failed.");
+ return (-1);
+ }
+ sockent_init (se, SOCKENT_TYPE_SERVER);
+
+ se->node = strdup (ci->values[0].value.string);
+ if (ci->values_num >= 2)
+ se->service = strdup (ci->values[1].value.string);
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+#if HAVE_LIBGCRYPT
+ if (strcasecmp ("AuthFile", child->key) == 0)
+ network_config_set_string (child, &se->data.server.auth_file);
+ else if (strcasecmp ("SecurityLevel", child->key) == 0)
+ network_config_set_security_level (child,
+ &se->data.server.security_level);
+ else
+#endif /* HAVE_LIBGCRYPT */
+ {
+ WARNING ("network plugin: Option `%s' is not allowed here.",
+ child->key);
+ }
+ }
+
+#if HAVE_LIBGCRYPT
+ if ((se->data.server.security_level > SECURITY_LEVEL_NONE)
+ && (se->data.server.auth_file == NULL))
+ {
+ ERROR ("network plugin: A security level higher than `none' was "
+ "requested, but no AuthFile option was given. Cowardly refusing to "
+ "open this socket!");
+ sockent_destroy (se);
+ return (-1);
+ }
+#endif /* HAVE_LIBGCRYPT */
+
+ status = sockent_open (se);
+ if (status != 0)
+ {
+ ERROR ("network plugin: network_config_add_listen: sockent_open failed.");
+ sockent_destroy (se);
+ return (-1);
+ }
+
+ status = sockent_add (se);
+ if (status != 0)
+ {
+ ERROR ("network plugin: network_config_add_listen: sockent_add failed.");
+ sockent_destroy (se);
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int network_config_add_listen */
+
+static int network_config_add_server (const oconfig_item_t *ci) /* {{{ */
+{
+ sockent_t *se;
+ int status;
+ 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);
+ }
+
+ se = malloc (sizeof (*se));
+ if (se == NULL)
+ {
+ ERROR ("network plugin: malloc failed.");
+ return (-1);
+ }
+ sockent_init (se, SOCKENT_TYPE_CLIENT);
+
+ se->node = strdup (ci->values[0].value.string);
+ if (ci->values_num >= 2)
+ se->service = strdup (ci->values[1].value.string);
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+#if HAVE_LIBGCRYPT
+ if (strcasecmp ("Username", child->key) == 0)
+ network_config_set_string (child, &se->data.client.username);
+ else if (strcasecmp ("Password", child->key) == 0)
+ network_config_set_string (child, &se->data.client.password);
+ else if (strcasecmp ("SecurityLevel", child->key) == 0)
+ network_config_set_security_level (child,
+ &se->data.client.security_level);
+ else
+#endif /* HAVE_LIBGCRYPT */
+ {
+ WARNING ("network plugin: Option `%s' is not allowed here.",
+ child->key);
+ }
+ }
+
+#if HAVE_LIBGCRYPT
+ if ((se->data.client.security_level > SECURITY_LEVEL_NONE)
+ && ((se->data.client.username == NULL)
+ || (se->data.client.password == NULL)))
+ {
+ ERROR ("network plugin: A security level higher than `none' was "
+ "requested, but no Username or Password option was given. "
+ "Cowardly refusing to open this socket!");
+ sockent_destroy (se);
+ return (-1);
+ }
+#endif /* HAVE_LIBGCRYPT */
+
+ status = sockent_open (se);
+ if (status != 0)
+ {
+ ERROR ("network plugin: network_config_add_server: sockent_open failed.");
+ sockent_destroy (se);
+ return (-1);
+ }
+
+ status = sockent_add (se);
+ if (status != 0)
+ {
+ ERROR ("network plugin: network_config_add_server: sockent_add failed.");
+ sockent_destroy (se);
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int network_config_add_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);
+ }
+
+ 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)
+ network_config_add_listen (child);
+ else if (strcasecmp ("Server", child->key) == 0)
+ network_config_add_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;
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;
+ }
+
+ sockent_destroy (listen_sockets);
if (send_buffer_fill > 0)
flush_buffer ();
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);
/* 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,
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,
sstrerror (errno, errbuf,
sizeof (errbuf)));
}
+ else
+ {
+ receive_thread_running = 1;
+ }
}
+
return (0);
} /* int network_init */
* 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);
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 : */
#define TYPE_MESSAGE 0x0100
#define TYPE_SEVERITY 0x0101
+#define TYPE_SIGN_SHA256 0x0200
+#define TYPE_ENCR_AES256 0x0210
+
#endif /* NETWORK_H */
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;
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 */
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;
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 : */
* Florian octo Forster <octo at verplant.org>
**/
+#define _BSD_SOURCE /* For NI_MAXHOST */
+
#include "collectd.h"
#include "common.h"
#include "plugin.h"
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);
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)
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 */
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);
}
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;
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;
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;
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;
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;
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) */
/**
* collectd - src/ping.c
- * Copyright (C) 2005-2007 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, ¶m_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, ¶m_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 : */
#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;
* 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;
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;
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);
}
}
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
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;
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;
}
}
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);
{
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
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)
{
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)
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)
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)
void plugin_init_all (void)
{
const char *chain_name;
- int (*callback) (void);
llentry_t *le;
int status;
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
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)
}
/* 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);
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;
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
}
else /* plugin != NULL */
{
+ callback_func_t *cf;
+ plugin_write_cb callback;
+
le = llist_head (list_write);
while (le != NULL)
{
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);
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)
le = llist_head (list_flush);
while (le != NULL)
{
+ callback_func_t *cf;
+ plugin_flush_cb callback;
+
if ((plugin != NULL)
&& (strcmp (plugin, le->key) != 0))
{
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;
}
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
(*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)
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; "
int plugin_dispatch_notification (const notification_t *notif)
{
- int (*callback) (const notification_t *);
llentry_t *le;
/* Possible TODO: Add flap detection here */
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;
}
{
char msg[1024];
va_list ap;
-
- void (*callback) (int, const char *);
llentry_t *le;
if (list_log == NULL)
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;
}
return (0);
} /* int plugin_notification_meta_free */
+
+/* vim: set sw=8 ts=8 noet fdm=marker : */
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
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);
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;
--- /dev/null
+/**
+ * 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 : */
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];
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 */
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;
/* 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++)
{
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];
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);
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 */
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;",
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);
}
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;
/*
* 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. */
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.");
hd->sess_handle = NULL;
hd->interval = 0;
- hd->next_update = 0;
- hd->state = STATE_IDLE;
for (i = 0; i < ci->children_num; i++)
{
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);
/* }}} 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;
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,
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);
(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;
{
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 */
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;
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) */
--- /dev/null
+/**
+ * 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 : */
--- /dev/null
+/**
+ * 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 : */
charge value:GAUGE:0:U
compression_ratio value:GAUGE:0:2
connections value:COUNTER:0:U
+conntrack entropy:GAUGE:0:4294967295
counter value:COUNTER:U:U
cpufreq value:GAUGE:0:U
cpu value:COUNTER:0:4294967295
multimeter value:GAUGE:U:U
mysql_commands value:COUNTER:0:U
mysql_handler value:COUNTER:0:U
+mysql_locks 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
nfs_procedure value:COUNTER:0:4294967295
+fscache_stat value:COUNTER:0:4294967295
nginx_connections value:GAUGE:0:U
nginx_requests value:COUNTER:0:134217728
operations value:COUNTER:0:4294967295
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
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
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)>,
--- /dev/null
+/**
+ * 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 STAT_FILE "/proc/stat"
+/* Using /proc filesystem to retrieve the boot time, Linux only. */
+/* #endif KERNEL_LINUX */
+
+#elif HAVE_LIBKSTAT
+/* Using kstats chain to retrieve the boot time on Solaris / OpenSolaris systems */
+/* #endif HAVE_LIBKSTAT */
+
+#elif HAVE_SYS_SYSCTL_H
+# include <sys/sysctl.h>
+/* Using sysctl interface to retrieve the boot time on *BSD / Darwin / OS X systems */
+/* #endif HAVE_SYS_SYSCTL_H */
+
+#else
+# error "No applicable input method."
+#endif
+
+/*
+ * Global variables
+ */
+/* boottime always used, no OS distinction */
+static time_t boottime;
+
+#if HAVE_LIBKSTAT
+extern kstat_ctl_t *kc;
+#endif /* #endif HAVE_LIBKSTAT */
+
+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);
+}
+
+static int uptime_init (void) /* {{{ */
+{
+ /*
+ * On most unix systems the uptime is calculated by looking at the boot
+ * time (stored in unix time, since epoch) and the current one. We are
+ * going to do the same, reading the boot time value while executing
+ * the uptime_init function (there is no need to read, every time the
+ * plugin_read is called, a value that won't change). 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 KERNEL_LINUX
+ unsigned long starttime;
+ char buffer[1024];
+ int ret;
+ FILE *fh;
+
+ ret = 0;
+
+ fh = fopen (STAT_FILE, "r");
+
+ if (fh == NULL)
+ {
+ char errbuf[1024];
+ ERROR ("uptime plugin: Cannot open "STAT_FILE": %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
+ while (fgets (buffer, 1024, fh) != NULL)
+ {
+ /* look for the btime string and read the value */
+ ret = sscanf (buffer, "btime %lu", &starttime);
+ /* avoid further loops if btime has been found and read
+ * correctly (hopefully) */
+ if (ret == 1)
+ break;
+ }
+
+ fclose (fh);
+
+ /* loop done, check if no value has been found/read */
+ if (ret != 1)
+ {
+ ERROR ("uptime plugin: No value read from "STAT_FILE"");
+ return (-1);
+ }
+
+ boottime = (time_t) starttime;
+
+ if (boottime == 0)
+ {
+ ERROR ("uptime plugin: btime read from "STAT_FILE", "
+ "but `boottime' is zero!");
+ return (-1);
+ }
+/* #endif KERNEL_LINUX */
+
+#elif HAVE_LIBKSTAT
+ kstat_t *ksp;
+ kstat_named_t *knp;
+
+ ksp = NULL;
+ knp = NULL;
+
+ /* kstats chain already opened by update_kstat (using *kc), 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;
+
+ if (boottime == 0)
+ {
+ ERROR ("uptime plugin: kstat_data_lookup returned success, "
+ "but `boottime' is zero!");
+ return (-1);
+ }
+/* #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;
+
+ boottv_len = sizeof (boottv);
+ memset (&boottv, 0, boottv_len);
+
+ 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);
+} /* }}} int uptime_init */
+
+static int uptime_read (void)
+{
+ gauge_t uptime;
+ time_t elapsed;
+
+ /* calculate the ammount of time elapsed since boot, AKA uptime */
+ elapsed = time (NULL) - boottime;
+
+ uptime = (gauge_t) elapsed;
+
+ uptime_submit (uptime);
+
+ return (0);
+}
+
+void module_register (void)
+{
+ plugin_register_init ("uptime", uptime_init);
+ plugin_register_read ("uptime", uptime_read);
+} /* void module_register */
/**
* 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
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;
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) */
{
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);
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)
{
}
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. */
{
value_list_t vl = VALUE_LIST_INIT;
value_t value;
- char *endptr;
+ char *value_str;
assert (r->legacy_mode == 1);
assert (r->ds != NULL);
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));
/*
* 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;
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);
}
}
plugin_dispatch_values (&vl);
sfree (vl.values);
+ return (0);
} /* }}} void udb_result_submit */
static void udb_result_finish_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, /* {{{ */
* Florian octo Forster <octo at verplant.org>
*/
+#define _BSD_SOURCE
+
#include "collectd.h"
#include "plugin.h"
#include "common.h"
--- /dev/null
+/**
+ * collectd - src/utils_fbhash.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 "plugin.h"
+
+#include <pthread.h>
+
+#include "utils_fbhash.h"
+#include "utils_avltree.h"
+
+struct fbhash_s
+{
+ char *filename;
+ time_t mtime;
+
+ pthread_mutex_t lock;
+ c_avl_tree_t *tree;
+};
+
+/*
+ * Private functions
+ */
+static void fbh_free_tree (c_avl_tree_t *tree) /* {{{ */
+{
+ int status;
+
+ if (tree == NULL)
+ return;
+
+ while (42)
+ {
+ char *key = NULL;
+ char *value = NULL;
+
+ status = c_avl_pick (tree, (void *) &key, (void *) &value);
+ if (status != 0)
+ break;
+
+ free (key);
+ free (value);
+ }
+
+ c_avl_destroy (tree);
+} /* }}} void fbh_free_tree */
+
+static int fbh_read_file (fbhash_t *h) /* {{{ */
+{
+ FILE *fh;
+ char buffer[4096];
+ struct flock fl;
+ c_avl_tree_t *tree;
+ int status;
+
+ fh = fopen (h->filename, "r");
+ if (fh == NULL)
+ return (-1);
+
+ memset (&fl, 0, sizeof (fl));
+ fl.l_type = F_RDLCK;
+ fl.l_whence = SEEK_SET;
+ fl.l_start = 0;
+ fl.l_len = 0; /* == entire file */
+ /* TODO: Lock file? -> fcntl */
+
+ status = fcntl (fileno (fh), F_SETLK, &fl);
+ if (status != 0)
+ {
+ fclose (fh);
+ return (-1);
+ }
+
+ tree = c_avl_create ((void *) strcmp);
+ if (tree == NULL)
+ {
+ fclose (fh);
+ return (-1);
+ }
+
+ /* Read `fh' into `tree' */
+ while (fgets (buffer, sizeof (buffer), fh) != NULL) /* {{{ */
+ {
+ size_t len;
+ char *key;
+ char *value;
+
+ char *key_copy;
+ char *value_copy;
+
+ buffer[sizeof (buffer) - 1] = 0;
+ len = strlen (buffer);
+
+ /* Remove trailing newline characters. */
+ while ((len > 0)
+ && ((buffer[len - 1] == '\n') || (buffer[len - 1] == '\r')))
+ {
+ len--;
+ buffer[len] = 0;
+ }
+
+ /* Seek first non-space character */
+ key = buffer;
+ while ((*key != 0) && isspace ((int) *key))
+ key++;
+
+ /* Skip empty lines and comments */
+ if ((key[0] == 0) || (key[0] == '#'))
+ continue;
+
+ /* Seek first colon */
+ value = strchr (key, ':');
+ if (value == NULL)
+ continue;
+
+ /* Null-terminate `key'. */
+ *value = 0;
+ value++;
+
+ /* Skip leading whitespace */
+ while ((*value != 0) && isspace ((int) *value))
+ value++;
+
+ /* Skip lines without value */
+ if (value[0] == 0)
+ continue;
+
+ key_copy = strdup (key);
+ value_copy = strdup (value);
+
+ if ((key_copy == NULL) || (value_copy == NULL))
+ {
+ free (key_copy);
+ free (value_copy);
+ continue;
+ }
+
+ status = c_avl_insert (tree, key_copy, value_copy);
+ if (status != 0)
+ {
+ free (key_copy);
+ free (value_copy);
+ continue;
+ }
+
+ DEBUG ("utils_fbhash: fbh_read_file: key = %s; value = %s;",
+ key, value);
+ } /* }}} while (fgets) */
+
+ fclose (fh);
+
+ fbh_free_tree (h->tree);
+ h->tree = tree;
+
+ return (0);
+} /* }}} int fbh_read_file */
+
+static int fbh_check_file (fbhash_t *h) /* {{{ */
+{
+ struct stat statbuf;
+ int status;
+
+ memset (&statbuf, 0, sizeof (statbuf));
+
+ status = stat (h->filename, &statbuf);
+ if (status != 0)
+ return (-1);
+
+ if (h->mtime >= statbuf.st_mtime)
+ return (0);
+
+ status = fbh_read_file (h);
+ if (status == 0)
+ h->mtime = statbuf.st_mtime;
+
+ return (status);
+} /* }}} int fbh_check_file */
+
+/*
+ * Public functions
+ */
+fbhash_t *fbh_create (const char *file) /* {{{ */
+{
+ fbhash_t *h;
+ int status;
+
+ if (file == NULL)
+ return (NULL);
+
+ h = malloc (sizeof (*h));
+ if (h == NULL)
+ return (NULL);
+ memset (h, 0, sizeof (*h));
+
+ h->filename = strdup (file);
+ if (h->filename == NULL)
+ {
+ free (h);
+ return (NULL);
+ }
+
+ h->mtime = 0;
+ pthread_mutex_init (&h->lock, /* attr = */ NULL);
+
+ status = fbh_check_file (h);
+ if (status != 0)
+ {
+ fbh_destroy (h);
+ return (NULL);
+ }
+
+ return (h);
+} /* }}} fbhash_t *fbh_create */
+
+void fbh_destroy (fbhash_t *h) /* {{{ */
+{
+ if (h == NULL)
+ return;
+
+ free (h->filename);
+ fbh_free_tree (h->tree);
+} /* }}} void fbh_destroy */
+
+char *fbh_get (fbhash_t *h, const char *key) /* {{{ */
+{
+ char *value;
+ char *value_copy;
+ int status;
+
+ if ((h == NULL) || (key == NULL))
+ return (NULL);
+
+ value = NULL;
+ value_copy = NULL;
+
+ pthread_mutex_lock (&h->lock);
+
+ /* TODO: Checking this everytime may be a bit much..? */
+ fbh_check_file (h);
+
+ status = c_avl_get (h->tree, key, (void *) &value);
+ if (status == 0)
+ {
+ assert (value != NULL);
+ value_copy = strdup (value);
+ }
+
+ pthread_mutex_unlock (&h->lock);
+
+ return (value_copy);
+} /* }}} char *fbh_get */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
--- /dev/null
+/**
+ * collectd - src/utils_fbhash.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; 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>
+ **/
+
+#ifndef UTILS_FBHASH_H
+#define UTILS_FBHASH_H 1
+
+/*
+ * File-backed hash
+ *
+ * This module reads a file of the form
+ * key: value
+ * into a hash, which can then be queried. The file is given to `fbh_create',
+ * the hash is queried using `fbh_get'. If the file is changed during runtime,
+ * it will automatically be re-read.
+ */
+
+struct fbhash_s;
+typedef struct fbhash_s fbhash_t;
+
+fbhash_t *fbh_create (const char *file);
+void fbh_destroy (fbhash_t *h);
+
+/* Returns the value as a newly allocated `char *'. It's the caller's
+ * responsibility to free this memory. */
+char *fbh_get (fbhash_t *h, const char *key);
+
+#endif /* UTILS_FBHASH_H */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
--- /dev/null
+/**
+ * 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 : */
--- /dev/null
+/**
+ * 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 : */
*
* DESCRIPTION
* Returns the pointer passed to `match_create_callback' or a pointer to the
- * `cu_match_value_t' structure allocated by `match_create_callback'.
+ * `cu_match_value_t' structure allocated by `match_create_simple'.
*/
void *match_get_user_data (cu_match_t *obj);
#!/bin/sh
-DEFAULT_VERSION="4.6.3.git"
+DEFAULT_VERSION="4.7.1.git"
VERSION="$( git describe 2> /dev/null | sed -e 's/^collectd-//' )"
projects / collectd.git / commitdiff