Debian Codegraph @

src/utils/format_json/format_json.c

raw
1 /**
2 * collectd - src/utils_format_json.c
3 * Copyright (C) 2009-2015 Florian octo Forster
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 *
23 * Authors:
24 * Florian octo Forster <octo at collectd.org>
25 **/
26
27 #include "collectd.h"
28
29 #include "utils/format_json/format_json.h"
30
31 #include "plugin.h"
32 #include "utils/common/common.h"
33 #include "utils_cache.h"
34
35 #if HAVE_LIBYAJL
36 #include <yajl/yajl_common.h>
37 #include <yajl/yajl_gen.h>
38 #if HAVE_YAJL_YAJL_VERSION_H
39 #include <yajl/yajl_version.h>
40 #endif
41 #if defined(YAJL_MAJOR) && (YAJL_MAJOR > 1)
42 #define HAVE_YAJL_V2 1
43 #endif
44 #endif
45
46 static int json_escape_string(char *buffer, size_t buffer_size, /* {{{ */
47 const char *string) {
48 size_t dst_pos;
49
50 if ((buffer == NULL) || (string == NULL))
51 return -EINVAL;
52
53 if (buffer_size < 3)
54 return -ENOMEM;
55
56 dst_pos = 0;
57
58 #define BUFFER_ADD(c) \
59 do { \
60 if (dst_pos >= (buffer_size - 1)) { \
61 buffer[buffer_size - 1] = '\0'; \
62 return -ENOMEM; \
63 } \
64 buffer[dst_pos] = (c); \
65 dst_pos++; \
66 } while (0)
67
68 /* Escape special characters */
69 BUFFER_ADD('"');
70 for (size_t src_pos = 0; string[src_pos] != 0; src_pos++) {
71 if ((string[src_pos] == '"') || (string[src_pos] == '\\')) {
72 BUFFER_ADD('\\');
73 BUFFER_ADD(string[src_pos]);
74 } else if (string[src_pos] <= 0x001F)
75 BUFFER_ADD('?');
76 else
77 BUFFER_ADD(string[src_pos]);
78 } /* for */
79 BUFFER_ADD('"');
80 buffer[dst_pos] = 0;
81
82 #undef BUFFER_ADD
83
84 return 0;
85 } /* }}} int json_escape_string */
86
87 static int values_to_json(char *buffer, size_t buffer_size, /* {{{ */
88 const data_set_t *ds, const value_list_t *vl,
89 int store_rates) {
90 size_t offset = 0;
91 gauge_t *rates = NULL;
92
93 memset(buffer, 0, buffer_size);
94
95 #define BUFFER_ADD(...) \
96 do { \
97 int status; \
98 status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
99 if (status < 1) { \
100 sfree(rates); \
101 return -1; \
102 } else if (((size_t)status) >= (buffer_size - offset)) { \
103 sfree(rates); \
104 return -ENOMEM; \
105 } else \
106 offset += ((size_t)status); \
107 } while (0)
108
109 BUFFER_ADD("[");
110 for (size_t i = 0; i < ds->ds_num; i++) {
111 if (i > 0)
112 BUFFER_ADD(",");
113
114 if (ds->ds[i].type == DS_TYPE_GAUGE) {
115 if (isfinite(vl->values[i].gauge))
116 BUFFER_ADD(JSON_GAUGE_FORMAT, vl->values[i].gauge);
117 else
118 BUFFER_ADD("null");
119 } else if (store_rates) {
120 if (rates == NULL)
121 rates = uc_get_rate(ds, vl);
122 if (rates == NULL) {
123 WARNING("utils_format_json: uc_get_rate failed.");
124 sfree(rates);
125 return -1;
126 }
127
128 if (isfinite(rates[i]))
129 BUFFER_ADD(JSON_GAUGE_FORMAT, rates[i]);
130 else
131 BUFFER_ADD("null");
132 } else if (ds->ds[i].type == DS_TYPE_COUNTER)
133 BUFFER_ADD("%" PRIu64, (uint64_t)vl->values[i].counter);
134 else if (ds->ds[i].type == DS_TYPE_DERIVE)
135 BUFFER_ADD("%" PRIi64, vl->values[i].derive);
136 else if (ds->ds[i].type == DS_TYPE_ABSOLUTE)
137 BUFFER_ADD("%" PRIu64, vl->values[i].absolute);
138 else {
139 ERROR("format_json: Unknown data source type: %i", ds->ds[i].type);
140 sfree(rates);
141 return -1;
142 }
143 } /* for ds->ds_num */
144 BUFFER_ADD("]");
145
146 #undef BUFFER_ADD
147
148 sfree(rates);
149 return 0;
150 } /* }}} int values_to_json */
151
152 static int dstypes_to_json(char *buffer, size_t buffer_size, /* {{{ */
153 const data_set_t *ds) {
154 size_t offset = 0;
155
156 memset(buffer, 0, buffer_size);
157
158 #define BUFFER_ADD(...) \
159 do { \
160 int status; \
161 status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
162 if (status < 1) \
163 return -1; \
164 else if (((size_t)status) >= (buffer_size - offset)) \
165 return -ENOMEM; \
166 else \
167 offset += ((size_t)status); \
168 } while (0)
169
170 BUFFER_ADD("[");
171 for (size_t i = 0; i < ds->ds_num; i++) {
172 if (i > 0)
173 BUFFER_ADD(",");
174
175 BUFFER_ADD("\"%s\"", DS_TYPE_TO_STRING(ds->ds[i].type));
176 } /* for ds->ds_num */
177 BUFFER_ADD("]");
178
179 #undef BUFFER_ADD
180
181 return 0;
182 } /* }}} int dstypes_to_json */
183
184 static int dsnames_to_json(char *buffer, size_t buffer_size, /* {{{ */
185 const data_set_t *ds) {
186 size_t offset = 0;
187
188 memset(buffer, 0, buffer_size);
189
190 #define BUFFER_ADD(...) \
191 do { \
192 int status; \
193 status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
194 if (status < 1) \
195 return -1; \
196 else if (((size_t)status) >= (buffer_size - offset)) \
197 return -ENOMEM; \
198 else \
199 offset += ((size_t)status); \
200 } while (0)
201
202 BUFFER_ADD("[");
203 for (size_t i = 0; i < ds->ds_num; i++) {
204 if (i > 0)
205 BUFFER_ADD(",");
206
207 BUFFER_ADD("\"%s\"", ds->ds[i].name);
208 } /* for ds->ds_num */
209 BUFFER_ADD("]");
210
211 #undef BUFFER_ADD
212
213 return 0;
214 } /* }}} int dsnames_to_json */
215
216 static int meta_data_keys_to_json(char *buffer, size_t buffer_size, /* {{{ */
217 meta_data_t *meta, char **keys,
218 size_t keys_num) {
219 size_t offset = 0;
220 int status;
221
222 buffer[0] = 0;
223
224 #define BUFFER_ADD(...) \
225 do { \
226 status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
227 if (status < 1) \
228 return -1; \
229 else if (((size_t)status) >= (buffer_size - offset)) \
230 return -ENOMEM; \
231 else \
232 offset += ((size_t)status); \
233 } while (0)
234
235 for (size_t i = 0; i < keys_num; ++i) {
236 int type;
237 char *key = keys[i];
238
239 type = meta_data_type(meta, key);
240 if (type == MD_TYPE_STRING) {
241 char *value = NULL;
242 if (meta_data_get_string(meta, key, &value) == 0) {
243 char temp[512] = "";
244
245 status = json_escape_string(temp, sizeof(temp), value);
246 sfree(value);
247 if (status != 0)
248 return status;
249
250 BUFFER_ADD(",\"%s\":%s", key, temp);
251 }
252 } else if (type == MD_TYPE_SIGNED_INT) {
253 int64_t value = 0;
254 if (meta_data_get_signed_int(meta, key, &value) == 0)
255 BUFFER_ADD(",\"%s\":%" PRIi64, key, value);
256 } else if (type == MD_TYPE_UNSIGNED_INT) {
257 uint64_t value = 0;
258 if (meta_data_get_unsigned_int(meta, key, &value) == 0)
259 BUFFER_ADD(",\"%s\":%" PRIu64, key, value);
260 } else if (type == MD_TYPE_DOUBLE) {
261 double value = 0.0;
262 if (meta_data_get_double(meta, key, &value) == 0)
263 BUFFER_ADD(",\"%s\":%f", key, value);
264 } else if (type == MD_TYPE_BOOLEAN) {
265 bool value = false;
266 if (meta_data_get_boolean(meta, key, &value) == 0)
267 BUFFER_ADD(",\"%s\":%s", key, value ? "true" : "false");
268 }
269 } /* for (keys) */
270
271 if (offset == 0)
272 return ENOENT;
273
274 buffer[0] = '{'; /* replace leading ',' */
275 BUFFER_ADD("}");
276
277 #undef BUFFER_ADD
278
279 return 0;
280 } /* }}} int meta_data_keys_to_json */
281
282 static int meta_data_to_json(char *buffer, size_t buffer_size, /* {{{ */
283 meta_data_t *meta) {
284 char **keys = NULL;
285 size_t keys_num;
286 int status;
287
288 if ((buffer == NULL) || (buffer_size == 0) || (meta == NULL))
289 return EINVAL;
290
291 status = meta_data_toc(meta, &keys);
292 if (status <= 0)
293 return status;
294 keys_num = (size_t)status;
295
296 status = meta_data_keys_to_json(buffer, buffer_size, meta, keys, keys_num);
297
298 for (size_t i = 0; i < keys_num; ++i)
299 sfree(keys[i]);
300 sfree(keys);
301
302 return status;
303 } /* }}} int meta_data_to_json */
304
305 static int value_list_to_json(char *buffer, size_t buffer_size, /* {{{ */
306 const data_set_t *ds, const value_list_t *vl,
307 int store_rates) {
308 char temp[512];
309 size_t offset = 0;
310 int status;
311
312 memset(buffer, 0, buffer_size);
313
314 #define BUFFER_ADD(...) \
315 do { \
316 status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
317 if (status < 1) \
318 return -1; \
319 else if (((size_t)status) >= (buffer_size - offset)) \
320 return -ENOMEM; \
321 else \
322 offset += ((size_t)status); \
323 } while (0)
324
325 /* All value lists have a leading comma. The first one will be replaced with
326 * a square bracket in `format_json_finalize'. */
327 BUFFER_ADD(",{");
328
329 status = values_to_json(temp, sizeof(temp), ds, vl, store_rates);
330 if (status != 0)
331 return status;
332 BUFFER_ADD("\"values\":%s", temp);
333
334 status = dstypes_to_json(temp, sizeof(temp), ds);
335 if (status != 0)
336 return status;
337 BUFFER_ADD(",\"dstypes\":%s", temp);
338
339 status = dsnames_to_json(temp, sizeof(temp), ds);
340 if (status != 0)
341 return status;
342 BUFFER_ADD(",\"dsnames\":%s", temp);
343
344 BUFFER_ADD(",\"time\":%.3f", CDTIME_T_TO_DOUBLE(vl->time));
345 BUFFER_ADD(",\"interval\":%.3f", CDTIME_T_TO_DOUBLE(vl->interval));
346
347 #define BUFFER_ADD_KEYVAL(key, value) \
348 do { \
349 status = json_escape_string(temp, sizeof(temp), (value)); \
350 if (status != 0) \
351 return status; \
352 BUFFER_ADD(",\"%s\":%s", (key), temp); \
353 } while (0)
354
355 BUFFER_ADD_KEYVAL("host", vl->host);
356 BUFFER_ADD_KEYVAL("plugin", vl->plugin);
357 BUFFER_ADD_KEYVAL("plugin_instance", vl->plugin_instance);
358 BUFFER_ADD_KEYVAL("type", vl->type);
359 BUFFER_ADD_KEYVAL("type_instance", vl->type_instance);
360
361 if (vl->meta != NULL) {
362 char meta_buffer[buffer_size];
363 memset(meta_buffer, 0, sizeof(meta_buffer));
364 status = meta_data_to_json(meta_buffer, sizeof(meta_buffer), vl->meta);
365 if (status != 0)
366 return status;
367
368 BUFFER_ADD(",\"meta\":%s", meta_buffer);
369 } /* if (vl->meta != NULL) */
370
371 BUFFER_ADD("}");
372
373 #undef BUFFER_ADD_KEYVAL
374 #undef BUFFER_ADD
375
376 return 0;
377 } /* }}} int value_list_to_json */
378
379 static int format_json_value_list_nocheck(char *buffer, /* {{{ */
380 size_t *ret_buffer_fill,
381 size_t *ret_buffer_free,
382 const data_set_t *ds,
383 const value_list_t *vl,
384 int store_rates, size_t temp_size) {
385 char temp[temp_size];
386 int status;
387
388 status = value_list_to_json(temp, sizeof(temp), ds, vl, store_rates);
389 if (status != 0)
390 return status;
391 temp_size = strlen(temp);
392
393 memcpy(buffer + (*ret_buffer_fill), temp, temp_size + 1);
394 (*ret_buffer_fill) += temp_size;
395 (*ret_buffer_free) -= temp_size;
396
397 return 0;
398 } /* }}} int format_json_value_list_nocheck */
399
400 int format_json_initialize(char *buffer, /* {{{ */
401 size_t *ret_buffer_fill, size_t *ret_buffer_free) {
402 size_t buffer_fill;
403 size_t buffer_free;
404
405 if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
406 (ret_buffer_free == NULL))
407 return -EINVAL;
408
409 buffer_fill = *ret_buffer_fill;
410 buffer_free = *ret_buffer_free;
411
412 buffer_free = buffer_fill + buffer_free;
413 buffer_fill = 0;
414
415 if (buffer_free < 3)
416 return -ENOMEM;
417
418 memset(buffer, 0, buffer_free);
419 *ret_buffer_fill = buffer_fill;
420 *ret_buffer_free = buffer_free;
421
422 return 0;
423 } /* }}} int format_json_initialize */
424
425 int format_json_finalize(char *buffer, /* {{{ */
426 size_t *ret_buffer_fill, size_t *ret_buffer_free) {
427 size_t pos;
428
429 if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
430 (ret_buffer_free == NULL))
431 return -EINVAL;
432
433 if (*ret_buffer_free < 2)
434 return -ENOMEM;
435
436 /* Replace the leading comma added in `value_list_to_json' with a square
437 * bracket. */
438 if (buffer[0] != ',')
439 return -EINVAL;
440 buffer[0] = '[';
441
442 pos = *ret_buffer_fill;
443 buffer[pos] = ']';
444 buffer[pos + 1] = 0;
445
446 (*ret_buffer_fill)++;
447 (*ret_buffer_free)--;
448
449 return 0;
450 } /* }}} int format_json_finalize */
451
452 int format_json_value_list(char *buffer, /* {{{ */
453 size_t *ret_buffer_fill, size_t *ret_buffer_free,
454 const data_set_t *ds, const value_list_t *vl,
455 int store_rates) {
456 if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
457 (ret_buffer_free == NULL) || (ds == NULL) || (vl == NULL))
458 return -EINVAL;
459
460 if (*ret_buffer_free < 3)
461 return -ENOMEM;
462
463 return format_json_value_list_nocheck(buffer, ret_buffer_fill,
464 ret_buffer_free, ds, vl, store_rates,
465 (*ret_buffer_free) - 2);
466 } /* }}} int format_json_value_list */
467
468 #if HAVE_LIBYAJL
469 static int json_add_string(yajl_gen g, char const *str) /* {{{ */
470 {
471 if (str == NULL)
472 return (int)yajl_gen_null(g);
473
474 return (int)yajl_gen_string(g, (const unsigned char *)str,
475 (unsigned int)strlen(str));
476 } /* }}} int json_add_string */
477
478 #define JSON_ADD(g, str) \
479 do { \
480 yajl_gen_status status = json_add_string(g, str); \
481 if (status != yajl_gen_status_ok) { \
482 return -1; \
483 } \
484 } while (0)
485
486 #define JSON_ADDF(g, format, ...) \
487 do { \
488 char *str = ssnprintf_alloc(format, __VA_ARGS__); \
489 yajl_gen_status status = json_add_string(g, str); \
490 free(str); \
491 if (status != yajl_gen_status_ok) { \
492 return -1; \
493 } \
494 } while (0)
495
496 #define CHECK_SUCCESS(cmd) \
497 do { \
498 yajl_gen_status s = (cmd); \
499 if (s != yajl_gen_status_ok) { \
500 return (int)s; \
501 } \
502 } while (0)
503
504 static int format_json_meta(yajl_gen g, notification_meta_t *meta) /* {{{ */
505 {
506 if (meta == NULL)
507 return 0;
508
509 JSON_ADD(g, meta->name);
510 switch (meta->type) {
511 case NM_TYPE_STRING:
512 JSON_ADD(g, meta->nm_value.nm_string);
513 break;
514 case NM_TYPE_SIGNED_INT:
515 JSON_ADDF(g, "%" PRIi64, meta->nm_value.nm_signed_int);
516 break;
517 case NM_TYPE_UNSIGNED_INT:
518 JSON_ADDF(g, "%" PRIu64, meta->nm_value.nm_unsigned_int);
519 break;
520 case NM_TYPE_DOUBLE:
521 JSON_ADDF(g, JSON_GAUGE_FORMAT, meta->nm_value.nm_double);
522 break;
523 case NM_TYPE_BOOLEAN:
524 JSON_ADD(g, meta->nm_value.nm_boolean ? "true" : "false");
525 break;
526 default:
527 ERROR("format_json_meta: unknown meta data type %d (name \"%s\")",
528 meta->type, meta->name);
529 CHECK_SUCCESS(yajl_gen_null(g));
530 }
531
532 return format_json_meta(g, meta->next);
533 } /* }}} int format_json_meta */
534
535 static int format_time(yajl_gen g, cdtime_t t) /* {{{ */
536 {
537 char buffer[RFC3339NANO_SIZE] = "";
538
539 if (rfc3339nano(buffer, sizeof(buffer), t) != 0)
540 return -1;
541
542 JSON_ADD(g, buffer);
543 return 0;
544 } /* }}} int format_time */
545
546 static int format_alert(yajl_gen g, notification_t const *n) /* {{{ */
547 {
548 CHECK_SUCCESS(yajl_gen_array_open(g)); /* BEGIN array */
549 CHECK_SUCCESS(yajl_gen_map_open(g)); /* BEGIN alert */
550
551 /*
552 * labels
553 */
554 JSON_ADD(g, "labels");
555 CHECK_SUCCESS(yajl_gen_map_open(g)); /* BEGIN labels */
556
557 JSON_ADD(g, "alertname");
558 if (strncmp(n->plugin, n->type, strlen(n->plugin)) == 0)
559 JSON_ADDF(g, "collectd_%s", n->type);
560 else
561 JSON_ADDF(g, "collectd_%s_%s", n->plugin, n->type);
562
563 JSON_ADD(g, "instance");
564 JSON_ADD(g, n->host);
565
566 /* mangling of plugin instance and type instance into labels is copied from
567 * the Prometheus collectd exporter. */
568 if (strlen(n->plugin_instance) > 0) {
569 JSON_ADD(g, n->plugin);
570 JSON_ADD(g, n->plugin_instance);
571 }
572 if (strlen(n->type_instance) > 0) {
573 if (strlen(n->plugin_instance) > 0)
574 JSON_ADD(g, "type");
575 else
576 JSON_ADD(g, n->plugin);
577 JSON_ADD(g, n->type_instance);
578 }
579
580 JSON_ADD(g, "severity");
581 JSON_ADD(g, (n->severity == NOTIF_FAILURE)
582 ? "FAILURE"
583 : (n->severity == NOTIF_WARNING)
584 ? "WARNING"
585 : (n->severity == NOTIF_OKAY) ? "OKAY" : "UNKNOWN");
586
587 JSON_ADD(g, "service");
588 JSON_ADD(g, "collectd");
589
590 CHECK_SUCCESS(yajl_gen_map_close(g)); /* END labels */
591
592 /*
593 * annotations
594 */
595 JSON_ADD(g, "annotations");
596 CHECK_SUCCESS(yajl_gen_map_open(g)); /* BEGIN annotations */
597
598 JSON_ADD(g, "summary");
599 JSON_ADD(g, n->message);
600
601 if (format_json_meta(g, n->meta) != 0) {
602 return -1;
603 }
604
605 CHECK_SUCCESS(yajl_gen_map_close(g)); /* END annotations */
606
607 JSON_ADD(g, "startsAt");
608 if (format_time(g, n->time) != 0) {
609 return -1;
610 }
611
612 CHECK_SUCCESS(yajl_gen_map_close(g)); /* END alert */
613 CHECK_SUCCESS(yajl_gen_array_close(g)); /* END array */
614
615 return 0;
616 } /* }}} format_alert */
617
618 /*
619 * Format (prometheus/alertmanager v1):
620 *
621 * [{
622 * "labels": {
623 * "alertname": "collectd_cpu",
624 * "instance": "host.example.com",
625 * "severity": "FAILURE",
626 * "service": "collectd",
627 * "cpu": "0",
628 * "type": "wait"
629 * },
630 * "annotations": {
631 * "summary": "...",
632 * // meta
633 * },
634 * "startsAt": <rfc3339 time>,
635 * "endsAt": <rfc3339 time>, // not used
636 * }]
637 */
638 int format_json_notification(char *buffer, size_t buffer_size, /* {{{ */
639 notification_t const *n) {
640 yajl_gen g;
641 unsigned char const *out;
642 #if HAVE_YAJL_V2
643 size_t unused_out_len;
644 #else
645 unsigned int unused_out_len;
646 #endif
647
648 if ((buffer == NULL) || (n == NULL))
649 return EINVAL;
650
651 #if HAVE_YAJL_V2
652 g = yajl_gen_alloc(NULL);
653 if (g == NULL)
654 return -1;
655 #if COLLECT_DEBUG
656 yajl_gen_config(g, yajl_gen_beautify, 1);
657 yajl_gen_config(g, yajl_gen_validate_utf8, 1);
658 #endif
659
660 #else /* !HAVE_YAJL_V2 */
661 yajl_gen_config conf = {0};
662 #if COLLECT_DEBUG
663 conf.beautify = 1;
664 conf.indentString = " ";
665 #endif
666 g = yajl_gen_alloc(&conf, NULL);
667 if (g == NULL)
668 return -1;
669 #endif
670
671 if (format_alert(g, n) != 0) {
672 yajl_gen_clear(g);
673 yajl_gen_free(g);
674 return -1;
675 }
676
677 /* copy to output buffer */
678 if (yajl_gen_get_buf(g, &out, &unused_out_len) != yajl_gen_status_ok) {
679 yajl_gen_clear(g);
680 yajl_gen_free(g);
681 return -1;
682 }
683 sstrncpy(buffer, (void *)out, buffer_size);
684
685 yajl_gen_clear(g);
686 yajl_gen_free(g);
687 return 0;
688 } /* }}} format_json_notification */
689 #else
690 int format_json_notification(char *buffer, size_t buffer_size, /* {{{ */
691 notification_t const *n) {
692 ERROR("format_json_notification: Not available (requires libyajl).");
693 return ENOTSUP;
694 } /* }}} int format_json_notification */
695 #endif