1 /**
2 * collectd - src/plugin.c
3 * Copyright (C) 2005,2006 Florian octo Forster
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 * Authors:
20 * Florian octo Forster <octo at verplant.org>
21 **/
23 #include "collectd.h"
25 #include <ltdl.h>
27 #include "plugin.h"
28 #include "network.h"
29 #include "utils_debug.h"
31 typedef struct plugin
32 {
33 char *type;
34 void (*init) (void);
35 void (*read) (void);
36 void (*write) (char *host, char *inst, char *val);
37 void (*shutdown) (void);
38 struct plugin *next;
39 } plugin_t;
41 static plugin_t *first_plugin = NULL;
43 extern int operating_mode;
45 static char *plugindir = NULL;
47 char *plugin_get_dir (void)
48 {
49 if (plugindir == NULL)
50 return (PLUGINDIR);
51 else
52 return (plugindir);
53 }
55 void plugin_set_dir (const char *dir)
56 {
57 if (plugindir != NULL)
58 free (plugindir);
60 if (dir == NULL)
61 plugindir = NULL;
62 else if ((plugindir = strdup (dir)) == NULL)
63 syslog (LOG_ERR, "strdup: %s", strerror (errno));
64 }
66 /*
67 * Returns the number of plugins registered
68 */
69 int plugin_count (void)
70 {
71 int i;
72 plugin_t *p;
74 for (i = 0, p = first_plugin; p != NULL; p = p->next)
75 i++;
77 return (i);
78 }
80 /*
81 * Returns the plugins with the type `type' or NULL if it's not found.
82 */
83 plugin_t *plugin_search (const char *type)
84 {
85 plugin_t *ret;
87 if (type == NULL)
88 return (NULL);
90 for (ret = first_plugin; ret != NULL; ret = ret->next)
91 if (strcmp (ret->type, type) == 0)
92 break;
94 return (ret);
95 }
97 /*
98 * Returns true if the plugin is loaded (i.e. `exists') and false otherwise.
99 * This is used in `configfile.c' to skip sections that are not needed..
100 */
101 int plugin_exists (char *type)
102 {
103 if (plugin_search (type) == NULL)
104 return (0);
105 else
106 return (1);
107 }
109 /*
110 * (Try to) load the shared object `file'. Won't complain if it isn't a shared
111 * object, but it will bitch about a shared object not having a
112 * ``module_register'' symbol..
113 */
114 int plugin_load_file (char *file)
115 {
116 lt_dlhandle dlh;
117 void (*reg_handle) (void);
119 DBG ("file = %s", file);
121 lt_dlinit ();
122 lt_dlerror (); /* clear errors */
124 if ((dlh = lt_dlopen (file)) == NULL)
125 {
126 const char *error = lt_dlerror ();
128 syslog (LOG_ERR, "lt_dlopen failed: %s", error);
129 DBG ("lt_dlopen failed: %s", error);
130 return (1);
131 }
133 if ((reg_handle = (void (*) (void)) lt_dlsym (dlh, "module_register")) == NULL)
134 {
135 syslog (LOG_WARNING, "Couldn't find symbol ``module_register'' in ``%s'': %s\n",
136 file, lt_dlerror ());
137 lt_dlclose (dlh);
138 return (-1);
139 }
141 (*reg_handle) ();
143 return (0);
144 }
146 #define BUFSIZE 512
147 int plugin_load (const char *type)
148 {
149 DIR *dh;
150 char *dir;
151 char filename[BUFSIZE];
152 char typename[BUFSIZE];
153 int typename_len;
154 int ret;
155 struct stat statbuf;
156 struct dirent *de;
158 DBG ("type = %s", type);
160 dir = plugin_get_dir ();
161 ret = 1;
163 /* don't load twice */
164 if (plugin_search (type) != NULL)
165 return (0);
167 /* `cpu' should not match `cpufreq'. To solve this we add `.so' to the
168 * type when matching the filename */
169 if (snprintf (typename, BUFSIZE, "%s.so", type) >= BUFSIZE)
170 {
171 syslog (LOG_WARNING, "snprintf: truncated: `%s.so'", type);
172 return (-1);
173 }
174 typename_len = strlen (typename);
176 if ((dh = opendir (dir)) == NULL)
177 {
178 syslog (LOG_ERR, "opendir (%s): %s", dir, strerror (errno));
179 return (-1);
180 }
182 while ((de = readdir (dh)) != NULL)
183 {
184 if (strncasecmp (de->d_name, typename, typename_len))
185 continue;
187 if (snprintf (filename, BUFSIZE, "%s/%s", dir, de->d_name) >= BUFSIZE)
188 {
189 syslog (LOG_WARNING, "snprintf: truncated: `%s/%s'", dir, de->d_name);
190 continue;
191 }
193 if (lstat (filename, &statbuf) == -1)
194 {
195 syslog (LOG_WARNING, "stat %s: %s", filename, strerror (errno));
196 continue;
197 }
198 else if (!S_ISREG (statbuf.st_mode))
199 {
200 /* don't follow symlinks */
201 continue;
202 }
204 if (plugin_load_file (filename) == 0)
205 {
206 /* success */
207 ret = 0;
208 break;
209 }
210 }
212 closedir (dh);
214 return (ret);
215 }
217 /*
218 * (Try to) load all plugins in `dir'. Returns the number of loaded plugins..
219 */
220 int plugin_load_all (char *dir)
221 {
222 DIR *dh;
223 struct dirent *de;
224 char filename[BUFSIZE];
225 struct stat statbuf;
227 if (dir == NULL)
228 dir = plugin_get_dir ();
229 else
230 plugin_set_dir (dir);
232 if ((dh = opendir (dir)) == NULL)
233 {
234 syslog (LOG_ERR, "opendir (%s): %s", dir, strerror (errno));
235 return (0);
236 }
238 while ((de = readdir (dh)) != NULL)
239 {
240 if (snprintf (filename, BUFSIZE, "%s/%s", dir, de->d_name) >= BUFSIZE)
241 {
242 syslog (LOG_WARNING, "snprintf: truncated: %s/%s", dir, de->d_name);
243 continue;
244 }
246 if (lstat (filename, &statbuf) == -1)
247 {
248 syslog (LOG_WARNING, "stat %s: %s", filename, strerror (errno));
249 continue;
250 }
251 else if (!S_ISREG (statbuf.st_mode))
252 {
253 continue;
254 }
256 plugin_load_file (filename);
257 }
259 closedir (dh);
261 return (plugin_count ());
262 }
263 #undef BUFSIZE
265 /*
266 * Call `init' on all plugins (if given)
267 */
268 void plugin_init_all (void)
269 {
270 plugin_t *p;
272 for (p = first_plugin; p != NULL; p = p->next)
273 if (p->init != NULL)
274 (*p->init) ();
275 }
277 /*
278 * Call `read' on all plugins (if given)
279 */
280 void plugin_read_all (const int *loop)
281 {
282 plugin_t *p;
284 for (p = first_plugin; (*loop == 0) && (p != NULL); p = p->next)
285 if (p->read != NULL)
286 (*p->read) ();
287 }
289 /*
290 * Call `shutdown' on all plugins (if given)
291 */
292 void plugin_shutdown_all (void)
293 {
294 plugin_t *p;
296 for (p = first_plugin; NULL != p; p = p->next)
297 if (NULL != p->shutdown)
298 (*p->shutdown) ();
299 return;
300 }
302 /*
303 * Add plugin to the linked list of registered plugins.
304 */
305 void plugin_register (char *type,
306 void (*init) (void),
307 void (*read) (void),
308 void (*write) (char *, char *, char *))
309 {
310 plugin_t *p;
312 if (plugin_search (type) != NULL)
313 return;
315 #ifdef HAVE_LIBRRD
316 if (operating_mode != MODE_SERVER)
317 #endif
318 if ((init != NULL) && (read == NULL))
319 syslog (LOG_NOTICE, "Plugin `%s' doesn't provide a read function.", type);
321 if ((p = (plugin_t *) malloc (sizeof (plugin_t))) == NULL)
322 return;
324 if ((p->type = strdup (type)) == NULL)
325 {
326 free (p);
327 return;
328 }
330 p->init = init;
331 p->read = read;
332 p->write = write;
334 p->shutdown = NULL;
336 p->next = first_plugin;
337 first_plugin = p;
338 }
340 /*
341 * Register the shutdown function (optional).
342 */
343 int plugin_register_shutdown (char *type, void (*shutdown) (void))
344 {
345 plugin_t *p = plugin_search (type);
347 if (NULL == p)
348 return -1;
350 p->shutdown = shutdown;
351 return 0;
352 }
354 /*
355 * Send received data back to the plugin/module which will append DS
356 * definitions and pass it on to ``rrd_update_file''.
357 */
358 void plugin_write (char *host, char *type, char *inst, char *val)
359 {
360 plugin_t *p;
362 if ((p = plugin_search (type)) == NULL)
363 return;
365 if (p->write == NULL)
366 return;
368 (*p->write) (host, inst, val);
369 }
371 /*
372 * Receive data from the plugin/module and get it somehow to ``plugin_write'':
373 * Either using ``network_send'' (when in network/client mode) or call it
374 * directly (in local mode).
375 */
376 void plugin_submit (char *type, char *inst, char *val)
377 {
378 if (operating_mode == MODE_CLIENT)
379 network_send (type, inst, val);
380 else
381 plugin_write (NULL, type, inst, val);
382 }
384 void plugin_complain (int level, complain_t *c, const char *format, ...)
385 {
386 char message[512];
387 va_list ap;
388 int step;
390 if (c->delay > 0)
391 {
392 c->delay--;
393 return;
394 }
396 step = atoi (COLLECTD_STEP);
397 assert (step > 0);
399 if (c->interval < step)
400 c->interval = step;
401 else
402 c->interval *= 2;
404 if (c->interval > 86400)
405 c->interval = 86400;
407 c->delay = c->interval / step;
409 va_start (ap, format);
410 vsnprintf (message, 512, format, ap);
411 message[511] = '\0';
412 va_end (ap);
414 syslog (level, message);
415 }
417 void plugin_relief (int level, complain_t *c, const char *format, ...)
418 {
419 char message[512];
420 va_list ap;
422 if (c->interval == 0)
423 return;
425 c->interval = 0;
427 va_start (ap, format);
428 vsnprintf (message, 512, format, ap);
429 message[511] = '\0';
430 va_end (ap);
432 syslog (level, message);
433 }