processes plugin: collect per-process open files count on Linux
[collectd.git] / src / utils_cmds.c
1 /**
2  * collectd - src/utils_cmds.c
3  * Copyright (C) 2008       Florian Forster
4  * Copyright (C) 2016       Sebastian 'tokkee' Harl
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22  * DEALINGS IN THE SOFTWARE.
23  *
24  * Authors:
25  *   Florian octo Forster <octo at collectd.org>
26  *   Sebastian 'tokkee' Harl <sh at tokkee.org>
27  **/
28
29 #include "daemon/common.h"
30 #include "utils_cmd_flush.h"
31 #include "utils_cmd_getval.h"
32 #include "utils_cmd_listval.h"
33 #include "utils_cmd_putval.h"
34 #include "utils_cmds.h"
35 #include "utils_parse_option.h"
36
37 #include <stdbool.h>
38 #include <string.h>
39
40 static cmd_options_t default_options = {
41     /* identifier_default_host = */ NULL,
42 };
43
44 /*
45  * private helper functions
46  */
47
48 static cmd_status_t cmd_split(char *buffer, size_t *ret_len, char ***ret_fields,
49                               cmd_error_handler_t *err) {
50   char *field;
51   bool in_field, in_quotes;
52
53   size_t estimate, len;
54   char **fields;
55
56   estimate = 0;
57   in_field = false;
58   for (char *string = buffer; *string != '\0'; ++string) {
59     /* Make a quick worst-case estimate of the number of fields by
60      * counting spaces and ignoring quotation marks. */
61     if (!isspace((int)*string)) {
62       if (!in_field) {
63         estimate++;
64         in_field = true;
65       }
66     } else {
67       in_field = false;
68     }
69   }
70
71   /* fields will be NULL-terminated */
72   fields = malloc((estimate + 1) * sizeof(*fields));
73   if (fields == NULL) {
74     cmd_error(CMD_ERROR, err, "malloc failed.");
75     return (CMD_ERROR);
76   }
77
78 #define END_FIELD()                                                            \
79   do {                                                                         \
80     *field = '\0';                                                             \
81     field = NULL;                                                              \
82     in_field = false;                                                          \
83   } while (0)
84 #define NEW_FIELD()                                                            \
85   do {                                                                         \
86     field = string;                                                            \
87     in_field = true;                                                           \
88     assert(len < estimate);                                                    \
89     fields[len] = field;                                                       \
90     field++;                                                                   \
91     len++;                                                                     \
92   } while (0)
93
94   len = 0;
95   field = NULL;
96   in_field = false;
97   in_quotes = false;
98   for (char *string = buffer; *string != '\0'; string++) {
99     if (isspace((int)string[0])) {
100       if (!in_quotes) {
101         if (in_field)
102           END_FIELD();
103
104         /* skip space */
105         continue;
106       }
107     } else if (string[0] == '"') {
108       /* Note: Two consecutive quoted fields not separated by space are
109        * treated as different fields. This is the collectd 5.x behavior
110        * around splitting fields. */
111
112       if (in_quotes) {
113         /* end of quoted field */
114         if (!in_field) /* empty quoted string */
115           NEW_FIELD();
116         END_FIELD();
117         in_quotes = false;
118         continue;
119       }
120
121       in_quotes = true;
122       /* if (! in_field): add new field on next iteration
123        * else: quoted string following an unquoted string (one field)
124        * in either case: skip quotation mark */
125       continue;
126     } else if ((string[0] == '\\') && in_quotes) {
127       /* Outside of quotes, a backslash is a regular character (mostly
128        * for backward compatibility). */
129
130       if (string[1] == '\0') {
131         free(fields);
132         cmd_error(CMD_PARSE_ERROR, err, "Backslash at end of string.");
133         return (CMD_PARSE_ERROR);
134       }
135
136       /* un-escape the next character; skip backslash */
137       string++;
138     }
139
140     if (!in_field)
141       NEW_FIELD();
142     else {
143       *field = string[0];
144       field++;
145     }
146   }
147
148   if (in_quotes) {
149     free(fields);
150     cmd_error(CMD_PARSE_ERROR, err, "Unterminated quoted string.");
151     return (CMD_PARSE_ERROR);
152   }
153
154 #undef NEW_FIELD
155 #undef END_FIELD
156
157   fields[len] = NULL;
158   if (ret_len != NULL)
159     *ret_len = len;
160   if (ret_fields != NULL)
161     *ret_fields = fields;
162   else
163     free(fields);
164   return (CMD_OK);
165 } /* int cmd_split */
166
167 /*
168  * public API
169  */
170
171 void cmd_error(cmd_status_t status, cmd_error_handler_t *err,
172                const char *format, ...) {
173   va_list ap;
174
175   if ((err == NULL) || (err->cb == NULL))
176     return;
177
178   va_start(ap, format);
179   err->cb(err->ud, status, format, ap);
180   va_end(ap);
181 } /* void cmd_error */
182
183 cmd_status_t cmd_parsev(size_t argc, char **argv, cmd_t *ret_cmd,
184                         const cmd_options_t *opts, cmd_error_handler_t *err) {
185   char *command = NULL;
186   cmd_status_t status;
187
188   if ((argc < 1) || (argv == NULL) || (ret_cmd == NULL)) {
189     errno = EINVAL;
190     cmd_error(CMD_ERROR, err, "Missing command.");
191     return CMD_ERROR;
192   }
193
194   if (opts == NULL)
195     opts = &default_options;
196
197   memset(ret_cmd, 0, sizeof(*ret_cmd));
198   command = argv[0];
199   if (strcasecmp("FLUSH", command) == 0) {
200     ret_cmd->type = CMD_FLUSH;
201     status =
202         cmd_parse_flush(argc - 1, argv + 1, &ret_cmd->cmd.flush, opts, err);
203   } else if (strcasecmp("GETVAL", command) == 0) {
204     ret_cmd->type = CMD_GETVAL;
205     status =
206         cmd_parse_getval(argc - 1, argv + 1, &ret_cmd->cmd.getval, opts, err);
207   } else if (strcasecmp("LISTVAL", command) == 0) {
208     ret_cmd->type = CMD_LISTVAL;
209     status =
210         cmd_parse_listval(argc - 1, argv + 1, &ret_cmd->cmd.listval, opts, err);
211   } else if (strcasecmp("PUTVAL", command) == 0) {
212     ret_cmd->type = CMD_PUTVAL;
213     status =
214         cmd_parse_putval(argc - 1, argv + 1, &ret_cmd->cmd.putval, opts, err);
215   } else {
216     ret_cmd->type = CMD_UNKNOWN;
217     cmd_error(CMD_UNKNOWN_COMMAND, err, "Unknown command `%s'.", command);
218     return (CMD_UNKNOWN_COMMAND);
219   }
220
221   if (status != CMD_OK)
222     ret_cmd->type = CMD_UNKNOWN;
223   return (status);
224 } /* cmd_status_t cmd_parsev */
225
226 cmd_status_t cmd_parse(char *buffer, cmd_t *ret_cmd, const cmd_options_t *opts,
227                        cmd_error_handler_t *err) {
228   char **fields = NULL;
229   size_t fields_num = 0;
230   cmd_status_t status;
231
232   if ((status = cmd_split(buffer, &fields_num, &fields, err)) != CMD_OK)
233     return status;
234
235   status = cmd_parsev(fields_num, fields, ret_cmd, opts, err);
236   free(fields);
237   return (status);
238 } /* cmd_status_t cmd_parse */
239
240 void cmd_destroy(cmd_t *cmd) {
241   if (cmd == NULL)
242     return;
243
244   switch (cmd->type) {
245   case CMD_UNKNOWN:
246     /* nothing to do */
247     break;
248   case CMD_FLUSH:
249     cmd_destroy_flush(&cmd->cmd.flush);
250     break;
251   case CMD_GETVAL:
252     cmd_destroy_getval(&cmd->cmd.getval);
253     break;
254   case CMD_LISTVAL:
255     cmd_destroy_listval(&cmd->cmd.listval);
256     break;
257   case CMD_PUTVAL:
258     cmd_destroy_putval(&cmd->cmd.putval);
259     break;
260   }
261 } /* void cmd_destroy */
262
263 cmd_status_t cmd_parse_option(char *field, char **ret_key, char **ret_value,
264                               cmd_error_handler_t *err) {
265   char *key, *value;
266
267   if (field == NULL) {
268     errno = EINVAL;
269     cmd_error(CMD_ERROR, err, "Invalid argument to cmd_parse_option.");
270     return (CMD_ERROR);
271   }
272   key = value = field;
273
274   /* Look for the equal sign. */
275   while (isalnum((int)value[0]) || (value[0] == '_') || (value[0] == ':'))
276     value++;
277   if ((value[0] != '=') || (value == key)) {
278     /* Whether this is a fatal error is up to the caller. */
279     return (CMD_NO_OPTION);
280   }
281   *value = '\0';
282   value++;
283
284   if (ret_key != NULL)
285     *ret_key = key;
286   if (ret_value != NULL)
287     *ret_value = value;
288
289   return (CMD_OK);
290 } /* cmd_status_t cmd_parse_option */
291
292 void cmd_error_fh(void *ud, cmd_status_t status, const char *format,
293                   va_list ap) {
294   FILE *fh = ud;
295   int code = -1;
296   char buf[1024];
297
298   if (status == CMD_OK)
299     code = 0;
300
301   vsnprintf(buf, sizeof(buf), format, ap);
302   buf[sizeof(buf) - 1] = '\0';
303   if (fprintf(fh, "%i %s\n", code, buf) < 0) {
304     char errbuf[1024];
305     WARNING("utils_cmds: failed to write to file-handle #%i: %s", fileno(fh),
306             sstrerror(errno, errbuf, sizeof(errbuf)));
307     return;
308   }
309
310   fflush(fh);
311 } /* void cmd_error_fh */