src/utils_db_query.c: Fix use-after-free.
[collectd.git] / src / table.c
1 /**
2  * collectd - src/table.c
3  * Copyright (C) 2009  Sebastian Harl
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; only version 2 of the License is applicable.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
17  *
18  * Authors:
19  *   Sebastian Harl <sh at tokkee.org>
20  **/
21
22 /*
23  * This module provides generic means to parse and dispatch tabular data.
24  */
25
26 #include "collectd.h"
27 #include "common.h"
28
29 #include "configfile.h"
30 #include "plugin.h"
31
32 #define log_err(...) ERROR ("table plugin: " __VA_ARGS__)
33 #define log_warn(...) WARNING ("table plugin: " __VA_ARGS__)
34
35 /*
36  * private data types
37  */
38
39 typedef struct {
40         char  *type;
41         char  *instance_prefix;
42         int   *instances;
43         size_t instances_num;
44         int   *values;
45         size_t values_num;
46
47         const data_set_t *ds;
48 } tbl_result_t;
49
50 typedef struct {
51         char *file;
52         char *sep;
53         char *instance;
54
55         tbl_result_t *results;
56         size_t        results_num;
57
58         size_t max_colnum;
59 } tbl_t;
60
61 static void tbl_result_setup (tbl_result_t *res)
62 {
63         res->type            = NULL;
64
65         res->instance_prefix = NULL;
66         res->instances       = NULL;
67         res->instances_num   = 0;
68
69         res->values          = NULL;
70         res->values_num      = 0;
71
72         res->ds              = NULL;
73 } /* tbl_result_setup */
74
75 static void tbl_result_clear (tbl_result_t *res)
76 {
77         sfree (res->type);
78
79         sfree (res->instance_prefix);
80         sfree (res->instances);
81         res->instances_num = 0;
82
83         sfree (res->values);
84         res->values_num = 0;
85
86         res->ds = NULL;
87 } /* tbl_result_clear */
88
89 static void tbl_setup (tbl_t *tbl, char *file)
90 {
91         tbl->file        = sstrdup (file);
92         tbl->sep         = NULL;
93         tbl->instance    = NULL;
94
95         tbl->results     = NULL;
96         tbl->results_num = 0;
97
98         tbl->max_colnum  = 0;
99 } /* tbl_setup */
100
101 static void tbl_clear (tbl_t *tbl)
102 {
103         size_t i;
104
105         sfree (tbl->file);
106         sfree (tbl->sep);
107         sfree (tbl->instance);
108
109         for (i = 0; i < tbl->results_num; ++i)
110                 tbl_result_clear (tbl->results + i);
111         sfree (tbl->results);
112         tbl->results_num = 0;
113
114         tbl->max_colnum  = 0;
115 } /* tbl_clear */
116
117 static tbl_t *tables;
118 static size_t tables_num;
119
120 /*
121  * configuration handling
122  */
123
124 static int tbl_config_set_s (char *name, char **var, oconfig_item_t *ci)
125 {
126         if ((1 != ci->values_num)
127                         || (OCONFIG_TYPE_STRING != ci->values[0].type)) {
128                 log_err ("\"%s\" expects a single string argument.", name);
129                 return 1;
130         }
131
132         sfree (*var);
133         *var = sstrdup (ci->values[0].value.string);
134         return 0;
135 } /* tbl_config_set_separator */
136
137 static int tbl_config_append_array_i (char *name, int **var, size_t *len,
138                 oconfig_item_t *ci)
139 {
140         int *tmp;
141
142         size_t i;
143
144         if (1 > ci->values_num) {
145                 log_err ("\"%s\" expects at least one argument.", name);
146                 return 1;
147         }
148
149         for (i = 0; i < ci->values_num; ++i) {
150                 if (OCONFIG_TYPE_NUMBER != ci->values[i].type) {
151                         log_err ("\"%s\" expects numerical arguments only.", name);
152                         return 1;
153                 }
154         }
155
156         *len += ci->values_num;
157         tmp = (int *)realloc (*var, *len * sizeof (**var));
158         if (NULL == tmp) {
159                 char errbuf[1024];
160                 log_err ("realloc failed: %s.",
161                                 sstrerror (errno, errbuf, sizeof (errbuf)));
162                 return -1;
163         }
164
165         *var = tmp;
166
167         for (i = *len - ci->values_num; i < *len; ++i)
168                 (*var)[i] = (int)ci->values[i].value.number;
169         return 0;
170 } /* tbl_config_append_array_s */
171
172 static int tbl_config_result (tbl_t *tbl, oconfig_item_t *ci)
173 {
174         tbl_result_t *res;
175
176         int status = 0;
177         size_t i;
178
179         if (0 != ci->values_num) {
180                 log_err ("<Result> does not expect any arguments.");
181                 return 1;
182         }
183
184         res = (tbl_result_t *)realloc (tbl->results,
185                         (tbl->results_num + 1) * sizeof (*tbl->results));
186         if (NULL == tbl) {
187                 char errbuf[1024];
188                 log_err ("realloc failed: %s.",
189                                 sstrerror (errno, errbuf, sizeof (errbuf)));
190                 return -1;
191         }
192
193         tbl->results = res;
194         ++tbl->results_num;
195
196         res = tbl->results + tbl->results_num - 1;
197         tbl_result_setup (res);
198
199         for (i = 0; i < ci->children_num; ++i) {
200                 oconfig_item_t *c = ci->children + i;
201
202                 if (0 == strcasecmp (c->key, "Type"))
203                         tbl_config_set_s (c->key, &res->type, c);
204                 else if (0 == strcasecmp (c->key, "InstancePrefix"))
205                         tbl_config_set_s (c->key, &res->instance_prefix, c);
206                 else if (0 == strcasecmp (c->key, "InstancesFrom"))
207                         tbl_config_append_array_i (c->key,
208                                         &res->instances, &res->instances_num, c);
209                 else if (0 == strcasecmp (c->key, "ValuesFrom"))
210                         tbl_config_append_array_i (c->key,
211                                         &res->values, &res->values_num, c);
212                 else
213                         log_warn ("Ignoring unknown config key \"%s\" "
214                                         " in <Result>.", c->key);
215         }
216
217         if (NULL == res->type) {
218                 log_err ("No \"Type\" option specified for <Result> "
219                                 "in table \"%s\".", tbl->file);
220                 status = 1;
221         }
222
223         if (NULL == res->values) {
224                 log_err ("No \"ValuesFrom\" option specified for <Result> "
225                                 "in table \"%s\".", tbl->file);
226                 status = 1;
227         }
228
229         if (0 != status) {
230                 tbl_result_clear (res);
231                 --tbl->results_num;
232                 return status;
233         }
234         return 0;
235 } /* tbl_config_result */
236
237 static int tbl_config_table (oconfig_item_t *ci)
238 {
239         tbl_t *tbl;
240
241         int status = 0;
242         size_t i;
243
244         if ((1 != ci->values_num)
245                         || (OCONFIG_TYPE_STRING != ci->values[0].type)) {
246                 log_err ("<Table> expects a single string argument.");
247                 return 1;
248         }
249
250         tbl = (tbl_t *)realloc (tables, (tables_num + 1) * sizeof (*tables));
251         if (NULL == tbl) {
252                 char errbuf[1024];
253                 log_err ("realloc failed: %s.",
254                                 sstrerror (errno, errbuf, sizeof (errbuf)));
255                 return -1;
256         }
257
258         tables = tbl;
259         ++tables_num;
260
261         tbl = tables + tables_num - 1;
262         tbl_setup (tbl, ci->values[0].value.string);
263
264         for (i = 0; i < ci->children_num; ++i) {
265                 oconfig_item_t *c = ci->children + i;
266
267                 if (0 == strcasecmp (c->key, "Separator"))
268                         tbl_config_set_s (c->key, &tbl->sep, c);
269                 else if (0 == strcasecmp (c->key, "Instance"))
270                         tbl_config_set_s (c->key, &tbl->instance, c);
271                 else if (0 == strcasecmp (c->key, "Result"))
272                         tbl_config_result (tbl, c);
273                 else
274                         log_warn ("Ignoring unknown config key \"%s\" "
275                                         "in <Table %s>.", c->key, tbl->file);
276         }
277
278         if (NULL == tbl->sep) {
279                 log_err ("Table \"%s\" does not specify any separator.", tbl->file);
280                 status = 1;
281         }
282         strunescape (tbl->sep, strlen (tbl->sep) + 1);
283
284         if (NULL == tbl->instance) {
285                 tbl->instance = sstrdup (tbl->file);
286                 replace_special (tbl->instance, strlen (tbl->instance));
287         }
288
289         if (NULL == tbl->results) {
290                 log_err ("Table \"%s\" does not specify any (valid) results.",
291                                 tbl->file);
292                 status = 1;
293         }
294
295         if (0 != status) {
296                 tbl_clear (tbl);
297                 --tables_num;
298                 return status;
299         }
300
301         for (i = 0; i < tbl->results_num; ++i) {
302                 tbl_result_t *res = tbl->results + i;
303                 size_t j;
304
305                 for (j = 0; j < res->instances_num; ++j)
306                         if (res->instances[j] > tbl->max_colnum)
307                                 tbl->max_colnum = res->instances[j];
308
309                 for (j = 0; j < res->values_num; ++j)
310                         if (res->values[j] > tbl->max_colnum)
311                                 tbl->max_colnum = res->values[j];
312         }
313         return 0;
314 } /* tbl_config_table */
315
316 static int tbl_config (oconfig_item_t *ci)
317 {
318         size_t i;
319
320         for (i = 0; i < ci->children_num; ++i) {
321                 oconfig_item_t *c = ci->children + i;
322
323                 if (0 == strcasecmp (c->key, "Table"))
324                         tbl_config_table (c);
325                 else
326                         log_warn ("Ignoring unknown config key \"%s\".", c->key);
327         }
328         return 0;
329 } /* tbl_config */
330
331 /*
332  * result handling
333  */
334
335 static int tbl_prepare (tbl_t *tbl)
336 {
337         size_t i;
338
339         for (i = 0; i < tbl->results_num; ++i) {
340                 tbl_result_t *res = tbl->results + i;
341
342                 res->ds = plugin_get_ds (res->type);
343                 if (NULL == res->ds) {
344                         log_err ("Unknown type \"%s\". See types.db(5) for details.",
345                                         res->type);
346                         return -1;
347                 }
348
349                 if (res->values_num != (size_t)res->ds->ds_num) {
350                         log_err ("Invalid type \"%s\". Expected %zu data source%s, "
351                                         "got %i.", res->type, res->values_num,
352                                         (1 == res->values_num) ? "" : "s",
353                                         res->ds->ds_num);
354                         return -1;
355                 }
356         }
357         return 0;
358 } /* tbl_prepare */
359
360 static int tbl_finish (tbl_t *tbl)
361 {
362         size_t i;
363
364         for (i = 0; i < tbl->results_num; ++i)
365                 tbl->results[i].ds = NULL;
366         return 0;
367 } /* tbl_finish */
368
369 static int tbl_result_dispatch (tbl_t *tbl, tbl_result_t *res,
370                 char **fields, size_t fields_num)
371 {
372         value_list_t vl = VALUE_LIST_INIT;
373         value_t values[res->values_num];
374
375         size_t i;
376
377         assert (NULL != res->ds);
378         assert (res->values_num == res->ds->ds_num);
379
380         for (i = 0; i < res->values_num; ++i) {
381                 char *value;
382
383                 assert (res->values[i] < fields_num);
384                 value = fields[res->values[i]];
385
386                 if (0 != parse_value (value, &values[i], res->ds->ds[i].type))
387                         return -1;
388         }
389
390         vl.values     = values;
391         vl.values_len = STATIC_ARRAY_SIZE (values);
392
393         sstrncpy (vl.host, hostname_g, sizeof (vl.host));
394         sstrncpy (vl.plugin, "table", sizeof (vl.plugin));
395         sstrncpy (vl.plugin_instance, tbl->instance, sizeof (vl.plugin_instance));
396         sstrncpy (vl.type, res->type, sizeof (vl.type));
397
398         if (0 == res->instances_num) {
399                 if (NULL != res->instance_prefix)
400                         sstrncpy (vl.type_instance, res->instance_prefix,
401                                         sizeof (vl.type_instance));
402         }
403         else {
404                 char *instances[res->instances_num];
405                 char  instances_str[DATA_MAX_NAME_LEN];
406
407                 for (i = 0; i < res->instances_num; ++i) {
408                         assert (res->instances[i] < fields_num);
409                         instances[i] = fields[res->instances[i]];
410                 }
411
412                 strjoin (instances_str, sizeof (instances_str),
413                                 instances, STATIC_ARRAY_SIZE (instances), "-");
414                 instances_str[sizeof (instances_str) - 1] = '\0';
415
416                 vl.type_instance[sizeof (vl.type_instance) - 1] = '\0';
417                 if (NULL == res->instance_prefix)
418                         strncpy (vl.type_instance, instances_str,
419                                         sizeof (vl.type_instance));
420                 else
421                         snprintf (vl.type_instance, sizeof (vl.type_instance),
422                                         "%s-%s", res->instance_prefix, instances_str);
423
424                 if ('\0' != vl.type_instance[sizeof (vl.type_instance) - 1]) {
425                         vl.type_instance[sizeof (vl.type_instance) - 1] = '\0';
426                         log_warn ("Truncated type instance: %s.", vl.type_instance);
427                 }
428         }
429
430         plugin_dispatch_values (&vl);
431         return 0;
432 } /* tbl_result_dispatch */
433
434 static int tbl_parse_line (tbl_t *tbl, char *line, size_t len)
435 {
436         char *fields[tbl->max_colnum + 1];
437         char *ptr, *saveptr;
438
439         size_t i;
440
441         i = 0;
442         ptr = line;
443         saveptr = NULL;
444         while (NULL != (fields[i] = strtok_r (ptr, tbl->sep, &saveptr))) {
445                 ptr = NULL;
446                 ++i;
447
448                 if (i > tbl->max_colnum)
449                         break;
450         }
451
452         if (i <= tbl->max_colnum) {
453                 log_err ("Not enough columns in line "
454                                 "(expected at least %zu, got %zu).",
455                                 tbl->max_colnum + 1, i);
456                 return -1;
457         }
458
459         for (i = 0; i < tbl->results_num; ++i)
460                 if (0 != tbl_result_dispatch (tbl, tbl->results + i,
461                                         fields, STATIC_ARRAY_SIZE (fields))) {
462                         log_err ("Failed to dispatch result.");
463                         continue;
464                 }
465         return 0;
466 } /* tbl_parse_line */
467
468 static int tbl_read_table (tbl_t *tbl)
469 {
470         FILE *fh;
471         char  buf[4096];
472
473         fh = fopen (tbl->file, "r");
474         if (NULL == fh) {
475                 char errbuf[1024];
476                 log_err ("Failed to open file \"%s\": %s.", tbl->file,
477                                 sstrerror (errno, errbuf, sizeof (errbuf)));
478                 return -1;
479         }
480
481         buf[sizeof (buf) - 1] = '\0';
482         while (NULL != fgets (buf, sizeof (buf), fh)) {
483                 if ('\0' != buf[sizeof (buf) - 1]) {
484                         buf[sizeof (buf) - 1] = '\0';
485                         log_err ("Table %s: Truncated line: %s", tbl->file, buf);
486                 }
487
488                 if (0 != tbl_parse_line (tbl, buf, sizeof (buf))) {
489                         log_err ("Table %s: Failed to parse line: %s", tbl->file, buf);
490                         continue;
491                 }
492         }
493
494         if (0 != ferror (fh)) {
495                 char errbuf[1024];
496                 log_err ("Failed to read from file \"%s\": %s.", tbl->file,
497                                 sstrerror (errno, errbuf, sizeof (errbuf)));
498                 fclose (fh);
499                 return -1;
500         }
501
502         fclose (fh);
503         return 0;
504 } /* tbl_read_table */
505
506 /*
507  * collectd callbacks
508  */
509
510 static int tbl_read (void)
511 {
512         int status = -1;
513         size_t i;
514
515         if (0 == tables_num)
516                 return 0;
517
518         for (i = 0; i < tables_num; ++i) {
519                 tbl_t *tbl = tables + i;
520
521                 if (0 != tbl_prepare (tbl)) {
522                         log_err ("Failed to prepare and parse table \"%s\".", tbl->file);
523                         continue;
524                 }
525
526                 if (0 == tbl_read_table (tbl))
527                         status = 0;
528
529                 tbl_finish (tbl);
530         }
531         return status;
532 } /* tbl_read */
533
534 static int tbl_shutdown (void)
535 {
536         size_t i;
537
538         for (i = 0; i < tables_num; ++i)
539                 tbl_clear (&tables[i]);
540         sfree (tables);
541         return 0;
542 } /* tbl_shutdown */
543
544 static int tbl_init (void)
545 {
546         if (0 == tables_num)
547                 return 0;
548
549         plugin_register_read ("table", tbl_read);
550         plugin_register_shutdown ("table", tbl_shutdown);
551         return 0;
552 } /* tbl_init */
553
554 void module_register (void)
555 {
556         plugin_register_complex_config ("table", tbl_config);
557         plugin_register_init ("table", tbl_init);
558 } /* module_register */
559
560 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */