69e0cd423d2f32b37fdcaed6705eab1bc9c58b69
[collectd.git] / src / utils_format_json.c
1 /**
2  * collectd - src/utils_format_json.c
3  * Copyright (C) 2009  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; 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  *   Florian octo Forster <octo at verplant.org>
20  **/
21
22 #include "collectd.h"
23 #include "plugin.h"
24 #include "common.h"
25
26 #include "utils_cache.h"
27 #include "utils_format_json.h"
28
29 static int escape_string (char *buffer, size_t buffer_size, /* {{{ */
30     const char *string)
31 {
32   size_t src_pos;
33   size_t dst_pos;
34
35   if ((buffer == NULL) || (string == NULL))
36     return (-EINVAL);
37
38   if (buffer_size < 3)
39     return (-ENOMEM);
40
41   dst_pos = 0;
42
43 #define BUFFER_ADD(c) do { \
44   if (dst_pos >= (buffer_size - 1)) { \
45     buffer[buffer_size - 1] = 0; \
46     return (-ENOMEM); \
47   } \
48   buffer[dst_pos] = (c); \
49   dst_pos++; \
50 } while (0)
51
52   /* Escape special characters */
53   BUFFER_ADD ('"');
54   for (src_pos = 0; string[src_pos] != 0; src_pos++)
55   {
56     if ((string[src_pos] == '"')
57         || (string[src_pos] == '\\'))
58     {
59       BUFFER_ADD ('\\');
60       BUFFER_ADD (string[src_pos]);
61     }
62     else if (string[src_pos] <= 0x001F)
63       BUFFER_ADD ('?');
64     else
65       BUFFER_ADD (string[src_pos]);
66   } /* for */
67   BUFFER_ADD ('"');
68   buffer[dst_pos] = 0;
69
70 #undef BUFFER_ADD
71
72   return (0);
73 } /* }}} int buffer_add_string */
74
75 static int values_to_json (char *buffer, size_t buffer_size, /* {{{ */
76                 const data_set_t *ds, const value_list_t *vl, int store_rates)
77 {
78   size_t offset = 0;
79   int i;
80   gauge_t *rates = NULL;
81
82   memset (buffer, 0, buffer_size);
83
84 #define BUFFER_ADD(...) do { \
85   int status; \
86   status = ssnprintf (buffer + offset, buffer_size - offset, \
87       __VA_ARGS__); \
88   if (status < 1) \
89   { \
90     sfree(rates); \
91     return (-1); \
92   } \
93   else if (((size_t) status) >= (buffer_size - offset)) \
94   { \
95     sfree(rates); \
96     return (-ENOMEM); \
97   } \
98   else \
99     offset += ((size_t) status); \
100 } while (0)
101
102   BUFFER_ADD ("[");
103   for (i = 0; i < ds->ds_num; i++)
104   {
105     if (i > 0)
106       BUFFER_ADD (",");
107
108     if (ds->ds[i].type == DS_TYPE_GAUGE)
109     {
110       if(isfinite (vl->values[i].gauge))
111         BUFFER_ADD ("%g", vl->values[i].gauge);
112       else
113         BUFFER_ADD ("null");
114     }
115     else if (store_rates)
116     {
117       if (rates == NULL)
118         rates = uc_get_rate (ds, vl);
119       if (rates == NULL)
120       {
121         WARNING ("utils_format_json: uc_get_rate failed.");
122         sfree(rates);
123         return (-1);
124       }
125
126       if(isfinite (rates[i]))
127         BUFFER_ADD ("%g", rates[i]);
128       else
129         BUFFER_ADD ("null");
130     }
131     else if (ds->ds[i].type == DS_TYPE_COUNTER)
132       BUFFER_ADD ("%llu", vl->values[i].counter);
133     else if (ds->ds[i].type == DS_TYPE_DERIVE)
134       BUFFER_ADD ("%"PRIi64, vl->values[i].derive);
135     else if (ds->ds[i].type == DS_TYPE_ABSOLUTE)
136       BUFFER_ADD ("%"PRIu64, vl->values[i].absolute);
137     else
138     {
139       ERROR ("format_json: Unknown data source type: %i",
140           ds->ds[i].type);
141       sfree (rates);
142       return (-1);
143     }
144   } /* for ds->ds_num */
145   BUFFER_ADD ("]");
146
147 #undef BUFFER_ADD
148
149   DEBUG ("format_json: values_to_json: buffer = %s;", buffer);
150   sfree(rates);
151   return (0);
152 } /* }}} int values_to_json */
153
154 static int value_list_to_json (char *buffer, size_t buffer_size, /* {{{ */
155                 const data_set_t *ds, const value_list_t *vl, int store_rates)
156 {
157   char temp[512];
158   size_t offset = 0;
159   int status;
160
161   memset (buffer, 0, buffer_size);
162
163 #define BUFFER_ADD(...) do { \
164   status = ssnprintf (buffer + offset, buffer_size - offset, \
165       __VA_ARGS__); \
166   if (status < 1) \
167     return (-1); \
168   else if (((size_t) status) >= (buffer_size - offset)) \
169     return (-ENOMEM); \
170   else \
171     offset += ((size_t) status); \
172 } while (0)
173
174   /* All value lists have a leading comma. The first one will be replaced with
175    * a square bracket in `format_json_finalize'. */
176   BUFFER_ADD (",{");
177
178   status = values_to_json (temp, sizeof (temp), ds, vl, store_rates);
179   if (status != 0)
180     return (status);
181   BUFFER_ADD ("\"values\":%s", temp);
182
183   BUFFER_ADD (",\"time\":%lu", (unsigned long) vl->time);
184   BUFFER_ADD (",\"interval\":%i", vl->interval);
185
186 #define BUFFER_ADD_KEYVAL(key, value) do { \
187   status = escape_string (temp, sizeof (temp), (value)); \
188   if (status != 0) \
189     return (status); \
190   BUFFER_ADD (",\"%s\":%s", (key), temp); \
191 } while (0)
192
193   BUFFER_ADD_KEYVAL ("host", vl->host);
194   BUFFER_ADD_KEYVAL ("plugin", vl->plugin);
195   BUFFER_ADD_KEYVAL ("plugin_instance", vl->plugin_instance);
196   BUFFER_ADD_KEYVAL ("type", vl->type);
197   BUFFER_ADD_KEYVAL ("type_instance", vl->type_instance);
198
199   BUFFER_ADD ("}");
200
201 #undef BUFFER_ADD_KEYVAL
202 #undef BUFFER_ADD
203
204   DEBUG ("format_json: value_list_to_json: buffer = %s;", buffer);
205
206   return (0);
207 } /* }}} int value_list_to_json */
208
209 static int format_json_value_list_nocheck (char *buffer, /* {{{ */
210     size_t *ret_buffer_fill, size_t *ret_buffer_free,
211     const data_set_t *ds, const value_list_t *vl,
212     int store_rates, size_t temp_size)
213 {
214   char temp[temp_size];
215   int status;
216
217   status = value_list_to_json (temp, sizeof (temp), ds, vl, store_rates);
218   if (status != 0)
219     return (status);
220   temp_size = strlen (temp);
221
222   memcpy (buffer + (*ret_buffer_fill), temp, temp_size + 1);
223   (*ret_buffer_fill) += temp_size;
224   (*ret_buffer_free) -= temp_size;
225
226   return (0);
227 } /* }}} int format_json_value_list_nocheck */
228
229 int format_json_initialize (char *buffer, /* {{{ */
230     size_t *ret_buffer_fill, size_t *ret_buffer_free)
231 {
232   size_t buffer_fill;
233   size_t buffer_free;
234
235   if ((buffer == NULL) || (ret_buffer_fill == NULL) || (ret_buffer_free == NULL))
236     return (-EINVAL);
237
238   buffer_fill = *ret_buffer_fill;
239   buffer_free = *ret_buffer_free;
240
241   buffer_free = buffer_fill + buffer_free;
242   buffer_fill = 0;
243
244   if (buffer_free < 3)
245     return (-ENOMEM);
246
247   memset (buffer, 0, buffer_free);
248   *ret_buffer_fill = buffer_fill;
249   *ret_buffer_free = buffer_free;
250
251   return (0);
252 } /* }}} int format_json_initialize */
253
254 int format_json_finalize (char *buffer, /* {{{ */
255     size_t *ret_buffer_fill, size_t *ret_buffer_free)
256 {
257   size_t pos;
258
259   if ((buffer == NULL) || (ret_buffer_fill == NULL) || (ret_buffer_free == NULL))
260     return (-EINVAL);
261
262   if (*ret_buffer_free < 2)
263     return (-ENOMEM);
264
265   /* Replace the leading comma added in `value_list_to_json' with a square
266    * bracket. */
267   if (buffer[0] != ',')
268     return (-EINVAL);
269   buffer[0] = '[';
270
271   pos = *ret_buffer_fill;
272   buffer[pos] = ']';
273   buffer[pos+1] = 0;
274
275   (*ret_buffer_fill)++;
276   (*ret_buffer_free)--;
277
278   return (0);
279 } /* }}} int format_json_finalize */
280
281 int format_json_value_list (char *buffer, /* {{{ */
282     size_t *ret_buffer_fill, size_t *ret_buffer_free,
283     const data_set_t *ds, const value_list_t *vl, int store_rates)
284 {
285   if ((buffer == NULL)
286       || (ret_buffer_fill == NULL) || (ret_buffer_free == NULL)
287       || (ds == NULL) || (vl == NULL))
288     return (-EINVAL);
289
290   if (*ret_buffer_free < 3)
291     return (-ENOMEM);
292
293   return (format_json_value_list_nocheck (buffer,
294         ret_buffer_fill, ret_buffer_free, ds, vl,
295         store_rates, (*ret_buffer_free) - 2));
296 } /* }}} int format_json_value_list */
297
298 /* vim: set sw=2 sts=2 et fdm=marker : */