cbdb9426373a4c0acffc5f914580aae9a63a14d1
1 /**
2 * collectd - src/plugin.c
3 * Copyright (C) 2005 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 struct plugin *next;
38 } plugin_t;
40 static plugin_t *first_plugin = NULL;
42 #ifdef HAVE_LIBRRD
43 extern int operating_mode;
44 #endif
46 static char *plugindir = NULL;
48 char *plugin_get_dir (void)
49 {
50 if (plugindir == NULL)
51 return (PLUGINDIR);
52 else
53 return (plugindir);
54 }
56 void plugin_set_dir (const char *dir)
57 {
58 if (plugindir != NULL)
59 free (plugindir);
61 if (dir == NULL)
62 plugindir = NULL;
63 else if ((plugindir = strdup (dir)) == NULL)
64 syslog (LOG_ERR, "strdup: %s", strerror (errno));
65 }
67 /*
68 * Returns the number of plugins registered
69 */
70 int plugin_count (void)
71 {
72 int i;
73 plugin_t *p;
75 for (i = 0, p = first_plugin; p != NULL; p = p->next)
76 i++;
78 return (i);
79 }
81 /*
82 * Returns the plugins with the type `type' or NULL if it's not found.
83 */
84 plugin_t *plugin_search (const char *type)
85 {
86 plugin_t *ret;
88 if (type == NULL)
89 return (NULL);
91 for (ret = first_plugin; ret != NULL; ret = ret->next)
92 if (strcmp (ret->type, type) == 0)
93 break;
95 return (ret);
96 }
98 /*
99 * Returns true if the plugin is loaded (i.e. `exists') and false otherwise.
100 * This is used in `configfile.c' to skip sections that are not needed..
101 */
102 int plugin_exists (char *type)
103 {
104 if (plugin_search (type) == NULL)
105 return (0);
106 else
107 return (1);
108 }
110 /*
111 * (Try to) load the shared object `file'. Won't complain if it isn't a shared
112 * object, but it will bitch about a shared object not having a
113 * ``module_register'' symbol..
114 */
115 int plugin_load_file (char *file)
116 {
117 lt_dlhandle dlh;
118 void (*reg_handle) (void);
120 DBG ("file = %s", file);
122 lt_dlinit ();
123 lt_dlerror (); /* clear errors */
125 if ((dlh = lt_dlopen (file)) == NULL)
126 {
127 const char *error = lt_dlerror ();
129 syslog (LOG_ERR, "lt_dlopen failed: %s", error);
130 DBG ("lt_dlopen failed: %s", error);
131 return (1);
132 }
134 if ((reg_handle = lt_dlsym (dlh, "module_register")) == NULL)
135 {
136 syslog (LOG_WARNING, "Couldn't find symbol ``module_register'' in ``%s'': %s\n",
137 file, lt_dlerror ());
138 lt_dlclose (dlh);
139 return (-1);
140 }
142 (*reg_handle) ();
144 return (0);
145 }
147 #define BUFSIZE 512
148 int plugin_load (const char *type)
149 {
150 DIR *dh;
151 char *dir;
152 char filename[BUFSIZE];
153 char typename[BUFSIZE];
154 int typename_len;
155 int ret;
156 struct stat statbuf;
157 struct dirent *de;
159 DBG ("type = %s", type);
161 dir = plugin_get_dir ();
162 ret = 1;
164 /* don't load twice */
165 if (plugin_search (type) != NULL)
166 return (0);
168 /* `cpu' should not match `cpufreq'. To solve this we add `.so' to the
169 * type when matching the filename */
170 if (snprintf (typename, BUFSIZE, "%s.so", type) >= BUFSIZE)
171 {
172 syslog (LOG_WARNING, "snprintf: truncated: `%s.so'", type);
173 return (-1);
174 }
175 typename_len = strlen (typename);
177 if ((dh = opendir (dir)) == NULL)
178 {
179 syslog (LOG_ERR, "opendir (%s): %s", dir, strerror (errno));
180 return (-1);
181 }
183 while ((de = readdir (dh)) != NULL)
184 {
185 if (strncasecmp (de->d_name, typename, typename_len))
186 continue;
188 if (snprintf (filename, BUFSIZE, "%s/%s", dir, de->d_name) >= BUFSIZE)
189 {
190 syslog (LOG_WARNING, "snprintf: truncated: `%s/%s'", dir, de->d_name);
191 continue;
192 }
194 if (lstat (filename, &statbuf) == -1)
195 {
196 syslog (LOG_WARNING, "stat %s: %s", filename, strerror (errno));
197 continue;
198 }
199 else if (!S_ISREG (statbuf.st_mode))
200 {
201 /* don't follow symlinks */
202 continue;
203 }
205 if (plugin_load_file (filename) == 0)
206 {
207 /* success */
208 ret = 0;
209 break;
210 }
211 }
213 closedir (dh);
215 return (ret);
216 }
218 /*
219 * (Try to) load all plugins in `dir'. Returns the number of loaded plugins..
220 */
221 int plugin_load_all (char *dir)
222 {
223 DIR *dh;
224 struct dirent *de;
225 char filename[BUFSIZE];
226 struct stat statbuf;
228 if (dir == NULL)
229 dir = plugin_get_dir ();
230 else
231 plugin_set_dir (dir);
233 if ((dh = opendir (dir)) == NULL)
234 {
235 syslog (LOG_ERR, "opendir (%s): %s", dir, strerror (errno));
236 return (0);
237 }
239 while ((de = readdir (dh)) != NULL)
240 {
241 if (snprintf (filename, BUFSIZE, "%s/%s", dir, de->d_name) >= BUFSIZE)
242 {
243 syslog (LOG_WARNING, "snprintf: truncated: %s/%s", dir, de->d_name);
244 continue;
245 }
247 if (lstat (filename, &statbuf) == -1)
248 {
249 syslog (LOG_WARNING, "stat %s: %s", filename, strerror (errno));
250 continue;
251 }
252 else if (!S_ISREG (statbuf.st_mode))
253 {
254 continue;
255 }
257 plugin_load_file (filename);
258 }
260 closedir (dh);
262 return (plugin_count ());
263 }
264 #undef BUFSIZE
266 /*
267 * Call `init' on all plugins (if given)
268 */
269 void plugin_init_all (void)
270 {
271 plugin_t *p;
273 for (p = first_plugin; p != NULL; p = p->next)
274 if (p->init != NULL)
275 (*p->init) ();
276 }
278 /*
279 * Call `read' on all plugins (if given)
280 */
281 void plugin_read_all (void)
282 {
283 plugin_t *p;
285 for (p = first_plugin; p != NULL; p = p->next)
286 if (p->read != NULL)
287 (*p->read) ();
288 }
290 /*
291 * Add plugin to the linked list of registered plugins.
292 */
293 void plugin_register (char *type,
294 void (*init) (void),
295 void (*read) (void),
296 void (*write) (char *, char *, char *))
297 {
298 plugin_t *p;
300 if (plugin_search (type) != NULL)
301 return;
303 #ifdef HAVE_LIBRRD
304 if ((operating_mode == MODE_LOCAL) || (operating_mode == MODE_CLIENT))
305 #endif
306 if ((init != NULL) && (read == NULL))
307 syslog (LOG_NOTICE, "Plugin `%s' doesn't provide a read function.", type);
309 if ((p = (plugin_t *) malloc (sizeof (plugin_t))) == NULL)
310 return;
312 if ((p->type = strdup (type)) == NULL)
313 {
314 free (p);
315 return;
316 }
318 p->init = init;
319 p->read = read;
320 p->write = write;
322 p->next = first_plugin;
323 first_plugin = p;
324 }
326 /*
327 * Send received data back to the plugin/module which will append DS
328 * definitions and pass it on to ``rrd_update_file''.
329 */
330 #ifdef HAVE_LIBRRD
331 void plugin_write (char *host, char *type, char *inst, char *val)
332 {
333 plugin_t *p;
335 if ((p = plugin_search (type)) == NULL)
336 return;
338 if (p->write == NULL)
339 return;
341 (*p->write) (host, inst, val);
342 }
343 #endif /* HAVE_LIBRRD */
345 /*
346 * Receive data from the plugin/module and get it somehow to ``plugin_write'':
347 * Either using ``network_send'' (when in network/client mode) or call it
348 * directly (in local mode).
349 */
350 void plugin_submit (char *type, char *inst, char *val)
351 {
352 #ifdef HAVE_LIBRRD
353 if (operating_mode == MODE_LOCAL)
354 plugin_write (NULL, type, inst, val);
355 else if (operating_mode == MODE_CLIENT)
356 network_send (type, inst, val);
357 else /* operating_mode == MODE_SERVER */
358 syslog (LOG_ERR, "WTF is the server doing in ``plugin_submit''?!?\n");
359 #else
360 network_send (type, inst, val);
361 #endif
362 }