1 /**
2 * collectd - src/filecount.c
3 * Copyright (C) 2008 Alessandro Iurlano
4 * Copyright (C) 2008 Florian octo Forster
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; only version 2 of the License is applicable.
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 * Alessandro Iurlano <alessandro.iurlano at gmail.com>
21 * Florian octo Forster <octo at collectd.org>
22 **/
24 #include "collectd.h"
26 #include "common.h"
27 #include "plugin.h"
29 #include <dirent.h>
30 #include <fcntl.h>
31 #include <fnmatch.h>
32 #include <sys/stat.h>
33 #include <sys/types.h>
35 #define FC_RECURSIVE 1
36 #define FC_HIDDEN 2
37 #define FC_REGULAR 4
39 struct fc_directory_conf_s {
40 char *path;
41 char *plugin_name;
42 char *instance;
43 char *files_size_type;
44 char *files_num_type;
45 char *type_instance;
47 int options;
49 /* Data counters */
50 uint64_t files_num;
51 uint64_t files_size;
53 /* Selectors */
54 char *name;
55 int64_t mtime;
56 int64_t size;
58 /* Helper for the recursive functions */
59 time_t now;
60 };
61 typedef struct fc_directory_conf_s fc_directory_conf_t;
63 static fc_directory_conf_t **directories = NULL;
64 static size_t directories_num = 0;
66 void fc_free_dir(fc_directory_conf_t *dir) {
67 sfree(dir->path);
68 sfree(dir->plugin_name);
69 sfree(dir->instance);
70 sfree(dir->files_size_type);
71 sfree(dir->files_num_type);
72 sfree(dir->type_instance);
73 sfree(dir->name);
75 sfree(dir);
76 } /* void fc_free_dir */
78 static void fc_submit_dir(const fc_directory_conf_t *dir) {
79 value_list_t vl = VALUE_LIST_INIT;
81 sstrncpy(vl.plugin, dir->plugin_name, sizeof(vl.plugin));
82 if (dir->instance != NULL)
83 sstrncpy(vl.plugin_instance, dir->instance, sizeof(vl.plugin_instance));
84 if (dir->type_instance != NULL)
85 sstrncpy(vl.type_instance, dir->type_instance, sizeof(vl.type_instance));
87 vl.values_len = 1;
89 if (dir->files_num_type != NULL) {
90 vl.values = &(value_t){.gauge = (gauge_t)dir->files_num};
91 sstrncpy(vl.type, dir->files_num_type, sizeof(vl.type));
92 plugin_dispatch_values(&vl);
93 }
95 if (dir->files_size_type != NULL) {
96 vl.values = &(value_t){.gauge = (gauge_t)dir->files_size};
97 sstrncpy(vl.type, dir->files_size_type, sizeof(vl.type));
98 plugin_dispatch_values(&vl);
99 }
100 } /* void fc_submit_dir */
102 /*
103 * Config:
104 * <Plugin filecount>
105 * <Directory /path/to/dir>
106 * Plugin "foo"
107 * Instance "foobar"
108 * Name "*.conf"
109 * MTime -3600
110 * Size "+10M"
111 * Recursive true
112 * IncludeHidden false
113 * FilesSizeType "bytes"
114 * FilesCountType "files"
115 * TypeInstance "instance"
116 * </Directory>
117 * </Plugin>
118 *
119 * Collect:
120 * - Number of files
121 * - Total size
122 */
124 static int fc_config_set_instance(fc_directory_conf_t *dir, const char *str) {
125 char buffer[1024];
126 char *ptr;
128 sstrncpy(buffer, str, sizeof(buffer));
129 for (ptr = buffer; *ptr != 0; ptr++)
130 if (*ptr == '/')
131 *ptr = '_';
133 for (ptr = buffer; *ptr == '_'; ptr++)
134 /* do nothing */;
136 char *copy = strdup(ptr);
137 if (copy == NULL)
138 return -1;
140 sfree(dir->instance);
141 dir->instance = copy;
143 return 0;
144 } /* int fc_config_set_instance */
146 static int fc_config_add_dir_instance(fc_directory_conf_t *dir,
147 oconfig_item_t *ci) {
148 if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
149 WARNING("filecount plugin: The `Instance' config option needs exactly "
150 "one string argument.");
151 return -1;
152 }
154 return fc_config_set_instance(dir, ci->values[0].value.string);
155 } /* int fc_config_add_dir_instance */
157 static int fc_config_add_dir_name(fc_directory_conf_t *dir,
158 oconfig_item_t *ci) {
159 if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
160 WARNING("filecount plugin: The `Name' config option needs exactly one "
161 "string argument.");
162 return -1;
163 }
165 char *temp = strdup(ci->values[0].value.string);
166 if (temp == NULL) {
167 ERROR("filecount plugin: strdup failed.");
168 return -1;
169 }
171 sfree(dir->name);
172 dir->name = temp;
174 return 0;
175 } /* int fc_config_add_dir_name */
177 static int fc_config_add_dir_mtime(fc_directory_conf_t *dir,
178 oconfig_item_t *ci) {
179 if ((ci->values_num != 1) || ((ci->values[0].type != OCONFIG_TYPE_STRING) &&
180 (ci->values[0].type != OCONFIG_TYPE_NUMBER))) {
181 WARNING("filecount plugin: The `MTime' config option needs exactly one "
182 "string or numeric argument.");
183 return -1;
184 }
186 if (ci->values[0].type == OCONFIG_TYPE_NUMBER) {
187 dir->mtime = (int64_t)ci->values[0].value.number;
188 return 0;
189 }
191 errno = 0;
192 char *endptr = NULL;
193 double temp = strtod(ci->values[0].value.string, &endptr);
194 if ((errno != 0) || (endptr == NULL) ||
195 (endptr == ci->values[0].value.string)) {
196 WARNING("filecount plugin: Converting `%s' to a number failed.",
197 ci->values[0].value.string);
198 return -1;
199 }
201 switch (*endptr) {
202 case 0:
203 case 's':
204 case 'S':
205 break;
207 case 'm':
208 case 'M':
209 temp *= 60;
210 break;
212 case 'h':
213 case 'H':
214 temp *= 3600;
215 break;
217 case 'd':
218 case 'D':
219 temp *= 86400;
220 break;
222 case 'w':
223 case 'W':
224 temp *= 7 * 86400;
225 break;
227 case 'y':
228 case 'Y':
229 temp *= 31557600; /* == 365.25 * 86400 */
230 break;
232 default:
233 WARNING("filecount plugin: Invalid suffix for `MTime': `%c'", *endptr);
234 return -1;
235 } /* switch (*endptr) */
237 dir->mtime = (int64_t)temp;
239 return 0;
240 } /* int fc_config_add_dir_mtime */
242 static int fc_config_add_dir_size(fc_directory_conf_t *dir,
243 oconfig_item_t *ci) {
244 if ((ci->values_num != 1) || ((ci->values[0].type != OCONFIG_TYPE_STRING) &&
245 (ci->values[0].type != OCONFIG_TYPE_NUMBER))) {
246 WARNING("filecount plugin: The `Size' config option needs exactly one "
247 "string or numeric argument.");
248 return -1;
249 }
251 if (ci->values[0].type == OCONFIG_TYPE_NUMBER) {
252 dir->size = (int64_t)ci->values[0].value.number;
253 return 0;
254 }
256 errno = 0;
257 char *endptr = NULL;
258 double temp = strtod(ci->values[0].value.string, &endptr);
259 if ((errno != 0) || (endptr == NULL) ||
260 (endptr == ci->values[0].value.string)) {
261 WARNING("filecount plugin: Converting `%s' to a number failed.",
262 ci->values[0].value.string);
263 return -1;
264 }
266 switch (*endptr) {
267 case 0:
268 case 'b':
269 case 'B':
270 break;
272 case 'k':
273 case 'K':
274 temp *= 1000.0;
275 break;
277 case 'm':
278 case 'M':
279 temp *= 1000.0 * 1000.0;
280 break;
282 case 'g':
283 case 'G':
284 temp *= 1000.0 * 1000.0 * 1000.0;
285 break;
287 case 't':
288 case 'T':
289 temp *= 1000.0 * 1000.0 * 1000.0 * 1000.0;
290 break;
292 case 'p':
293 case 'P':
294 temp *= 1000.0 * 1000.0 * 1000.0 * 1000.0 * 1000.0;
295 break;
297 default:
298 WARNING("filecount plugin: Invalid suffix for `Size': `%c'", *endptr);
299 return -1;
300 } /* switch (*endptr) */
302 dir->size = (int64_t)temp;
304 return 0;
305 } /* int fc_config_add_dir_size */
307 static int fc_config_add_dir_option(fc_directory_conf_t *dir,
308 oconfig_item_t *ci, int bit) {
309 if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) {
310 WARNING("filecount plugin: The `Recursive' config options needs exactly "
311 "one boolean argument.");
312 return -1;
313 }
315 if (ci->values[0].value.boolean)
316 dir->options |= bit;
317 else
318 dir->options &= ~bit;
320 return 0;
321 } /* int fc_config_add_dir_option */
323 static int fc_config_add_dir(oconfig_item_t *ci) {
324 if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
325 WARNING("filecount plugin: `Directory' needs exactly one string "
326 "argument.");
327 return -1;
328 }
330 /* Initialize `dir' */
331 fc_directory_conf_t *dir = calloc(1, sizeof(*dir));
332 if (dir == NULL) {
333 ERROR("filecount plugin: calloc failed.");
334 return -1;
335 }
337 dir->path = strdup(ci->values[0].value.string);
338 if (dir->path == NULL) {
339 ERROR("filecount plugin: strdup failed.");
340 fc_free_dir(dir);
341 return -1;
342 }
344 dir->options = FC_RECURSIVE | FC_REGULAR;
346 dir->name = NULL;
347 dir->plugin_name = strdup("filecount");
348 dir->instance = NULL;
349 dir->type_instance = NULL;
350 dir->mtime = 0;
351 dir->size = 0;
353 dir->files_size_type = strdup("bytes");
354 dir->files_num_type = strdup("files");
356 if (dir->plugin_name == NULL || dir->files_size_type == NULL ||
357 dir->files_num_type == NULL) {
358 ERROR("filecount plugin: strdup failed.");
359 fc_free_dir(dir);
360 return -1;
361 }
363 int status = 0;
364 for (int i = 0; i < ci->children_num; i++) {
365 oconfig_item_t *option = ci->children + i;
367 if (strcasecmp("Plugin", option->key) == 0)
368 status = cf_util_get_string(option, &dir->plugin_name);
369 else if (strcasecmp("Instance", option->key) == 0)
370 status = fc_config_add_dir_instance(dir, option);
371 else if (strcasecmp("Name", option->key) == 0)
372 status = fc_config_add_dir_name(dir, option);
373 else if (strcasecmp("MTime", option->key) == 0)
374 status = fc_config_add_dir_mtime(dir, option);
375 else if (strcasecmp("Size", option->key) == 0)
376 status = fc_config_add_dir_size(dir, option);
377 else if (strcasecmp("Recursive", option->key) == 0)
378 status = fc_config_add_dir_option(dir, option, FC_RECURSIVE);
379 else if (strcasecmp("IncludeHidden", option->key) == 0)
380 status = fc_config_add_dir_option(dir, option, FC_HIDDEN);
381 else if (strcasecmp("RegularOnly", option->key) == 0)
382 status = fc_config_add_dir_option(dir, option, FC_REGULAR);
383 else if (strcasecmp("FilesSizeType", option->key) == 0)
384 status = cf_util_get_string(option, &dir->files_size_type);
385 else if (strcasecmp("FilesCountType", option->key) == 0)
386 status = cf_util_get_string(option, &dir->files_num_type);
387 else if (strcasecmp("TypeInstance", option->key) == 0)
388 status = cf_util_get_string(option, &dir->type_instance);
389 else {
390 WARNING("filecount plugin: fc_config_add_dir: "
391 "Option `%s' not allowed here.",
392 option->key);
393 status = -1;
394 }
396 if (status != 0)
397 break;
398 } /* for (ci->children) */
400 if (status != 0) {
401 fc_free_dir(dir);
402 return -1;
403 }
405 /* Set default plugin instance */
406 if (dir->instance == NULL) {
407 fc_config_set_instance(dir, dir->path);
408 if (dir->instance == NULL || strlen(dir->instance) == 0) {
409 ERROR("filecount plugin: failed to build plugin instance name.");
410 fc_free_dir(dir);
411 return -1;
412 }
413 }
415 /* Handle disabled types */
416 if (strlen(dir->instance) == 0)
417 sfree(dir->instance);
419 if (strlen(dir->files_size_type) == 0)
420 sfree(dir->files_size_type);
422 if (strlen(dir->files_num_type) == 0)
423 sfree(dir->files_num_type);
425 if (dir->files_size_type == NULL && dir->files_num_type == NULL) {
426 WARNING("filecount plugin: Both `FilesSizeType' and `FilesCountType ' "
427 "are disabled for '%s'. There's no types to report.",
428 dir->path);
429 fc_free_dir(dir);
430 return -1;
431 }
433 /* Ready to add it to list */
434 fc_directory_conf_t **temp =
435 realloc(directories, sizeof(*directories) * (directories_num + 1));
436 if (temp == NULL) {
437 ERROR("filecount plugin: realloc failed.");
438 fc_free_dir(dir);
439 return -1;
440 }
442 directories = temp;
443 directories[directories_num] = dir;
444 directories_num++;
446 return 0;
447 } /* int fc_config_add_dir */
449 static int fc_config(oconfig_item_t *ci) {
450 for (int i = 0; i < ci->children_num; i++) {
451 oconfig_item_t *child = ci->children + i;
452 if (strcasecmp("Directory", child->key) == 0)
453 fc_config_add_dir(child);
454 else {
455 WARNING("filecount plugin: Ignoring unknown config option `%s'.",
456 child->key);
457 }
458 } /* for (ci->children) */
460 return 0;
461 } /* int fc_config */
463 static int fc_init(void) {
464 if (directories_num < 1) {
465 WARNING("filecount plugin: No directories have been configured.");
466 return -1;
467 }
469 return 0;
470 } /* int fc_init */
472 static int fc_read_dir_callback(const char *dirname, const char *filename,
473 void *user_data) {
474 fc_directory_conf_t *dir = user_data;
475 char abs_path[PATH_MAX];
476 struct stat statbuf;
478 if (dir == NULL)
479 return -1;
481 snprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, filename);
483 int status = lstat(abs_path, &statbuf);
484 if (status != 0) {
485 ERROR("filecount plugin: stat (%s) failed.", abs_path);
486 return -1;
487 }
489 if (S_ISDIR(statbuf.st_mode) && (dir->options & FC_RECURSIVE)) {
490 status = walk_directory(
491 abs_path, fc_read_dir_callback, dir,
492 /* include hidden = */ (dir->options & FC_HIDDEN) ? 1 : 0);
493 return status;
494 } else if ((dir->options & FC_REGULAR) && !S_ISREG(statbuf.st_mode)) {
495 return 0;
496 }
498 if (dir->name != NULL) {
499 status = fnmatch(dir->name, filename, /* flags = */ 0);
500 if (status != 0)
501 return 0;
502 }
504 if (!S_ISREG(statbuf.st_mode)) {
505 dir->files_num++;
506 return 0;
507 }
509 if (dir->mtime != 0) {
510 time_t mtime = dir->now;
512 if (dir->mtime < 0)
513 mtime += dir->mtime;
514 else
515 mtime -= dir->mtime;
517 DEBUG("filecount plugin: Only collecting files that were touched %s %u.",
518 (dir->mtime < 0) ? "after" : "before", (unsigned int)mtime);
520 if (((dir->mtime < 0) && (statbuf.st_mtime < mtime)) ||
521 ((dir->mtime > 0) && (statbuf.st_mtime > mtime)))
522 return 0;
523 }
525 if (dir->size != 0) {
526 off_t size;
528 if (dir->size < 0)
529 size = (off_t)((-1) * dir->size);
530 else
531 size = (off_t)dir->size;
533 if (((dir->size < 0) && (statbuf.st_size > size)) ||
534 ((dir->size > 0) && (statbuf.st_size < size)))
535 return 0;
536 }
538 dir->files_num++;
539 dir->files_size += (uint64_t)statbuf.st_size;
541 return 0;
542 } /* int fc_read_dir_callback */
544 static int fc_read_dir(fc_directory_conf_t *dir) {
545 dir->files_num = 0;
546 dir->files_size = 0;
548 if (dir->mtime != 0)
549 dir->now = time(NULL);
551 int status =
552 walk_directory(dir->path, fc_read_dir_callback, dir,
553 /* include hidden */ (dir->options & FC_HIDDEN) ? 1 : 0);
554 if (status != 0) {
555 WARNING("filecount plugin: walk_directory (%s) failed.", dir->path);
556 return -1;
557 }
559 fc_submit_dir(dir);
561 return 0;
562 } /* int fc_read_dir */
564 static int fc_read(void) {
565 for (size_t i = 0; i < directories_num; i++)
566 fc_read_dir(directories[i]);
568 return 0;
569 } /* int fc_read */
571 void module_register(void) {
572 plugin_register_complex_config("filecount", fc_config);
573 plugin_register_init("filecount", fc_init);
574 plugin_register_read("filecount", fc_read);
575 } /* void module_register */