1 /**
2 * collectd - src/curl_json.c
3 * Copyright (C) 2009 Doug MacEachern
4 * Copyright (C) 2006-2011 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 * Doug MacEachern <dougm at hyperic.com>
21 * Florian octo Forster <octo at collectd.org>
22 **/
24 #include "collectd.h"
25 #include "common.h"
26 #include "plugin.h"
27 #include "configfile.h"
28 #include "utils_avltree.h"
29 #include "utils_complain.h"
31 #include <curl/curl.h>
32 #include <yajl/yajl_parse.h>
33 #if HAVE_YAJL_YAJL_VERSION_H
34 # include <yajl/yajl_version.h>
35 #endif
37 #if defined(YAJL_MAJOR) && (YAJL_MAJOR > 1)
38 # define HAVE_YAJL_V2 1
39 #endif
41 #define CJ_DEFAULT_HOST "localhost"
42 #define CJ_KEY_MAGIC 0x43484b59UL /* CHKY */
43 #define CJ_IS_KEY(key) ((key)->magic == CJ_KEY_MAGIC)
44 #define CJ_ANY "*"
45 #define COUCH_MIN(x,y) ((x) < (y) ? (x) : (y))
47 struct cj_key_s;
48 typedef struct cj_key_s cj_key_t;
49 struct cj_key_s /* {{{ */
50 {
51 char *path;
52 char *type;
53 char *instance;
54 unsigned long magic;
55 };
56 /* }}} */
58 struct cj_s /* {{{ */
59 {
60 char *instance;
61 char *host;
63 char *url;
64 char *user;
65 char *pass;
66 char *credentials;
67 _Bool verify_peer;
68 _Bool verify_host;
69 char *cacert;
71 CURL *curl;
72 char curl_errbuf[CURL_ERROR_SIZE];
74 yajl_handle yajl;
75 c_avl_tree_t *tree;
76 cj_key_t *key;
77 int depth;
78 struct {
79 union {
80 c_avl_tree_t *tree;
81 cj_key_t *key;
82 };
83 char name[DATA_MAX_NAME_LEN];
84 } state[YAJL_MAX_DEPTH];
85 };
86 typedef struct cj_s cj_t; /* }}} */
88 #if HAVE_YAJL_V2
89 typedef size_t yajl_len_t;
90 #else
91 typedef unsigned int yajl_len_t;
92 #endif
94 static int cj_read (user_data_t *ud);
95 static int cj_curl_perform (cj_t *db, CURL *curl);
96 static void cj_submit (cj_t *db, cj_key_t *key, value_t *value);
98 static size_t cj_curl_callback (void *buf, /* {{{ */
99 size_t size, size_t nmemb, void *user_data)
100 {
101 cj_t *db;
102 size_t len;
103 yajl_status status;
105 len = size * nmemb;
107 if (len <= 0)
108 return (len);
110 db = user_data;
111 if (db == NULL)
112 return (0);
114 status = yajl_parse(db->yajl, (unsigned char *)buf, len);
115 if (status == yajl_status_ok)
116 return (len);
117 #if !HAVE_YAJL_V2
118 else if (status == yajl_status_insufficient_data)
119 return (len);
120 #endif
122 if (status != yajl_status_ok)
123 {
124 unsigned char *msg =
125 yajl_get_error(db->yajl, /* verbose = */ 1,
126 /* jsonText = */ (unsigned char *) buf, (unsigned int) len);
127 ERROR ("curl_json plugin: yajl_parse failed: %s", msg);
128 yajl_free_error(db->yajl, msg);
129 return (0); /* abort write callback */
130 }
132 return (len);
133 } /* }}} size_t cj_curl_callback */
135 static int cj_get_type (cj_key_t *key)
136 {
137 const data_set_t *ds;
139 ds = plugin_get_ds (key->type);
140 if (ds == NULL)
141 {
142 static char type[DATA_MAX_NAME_LEN] = "!!!invalid!!!";
144 assert (key->type != NULL);
145 if (strcmp (type, key->type) != 0)
146 {
147 ERROR ("curl_json plugin: Unable to look up DS type \"%s\".",
148 key->type);
149 sstrncpy (type, key->type, sizeof (type));
150 }
152 return -1;
153 }
154 else if (ds->ds_num > 1)
155 {
156 static c_complain_t complaint = C_COMPLAIN_INIT_STATIC;
158 c_complain_once (LOG_WARNING, &complaint,
159 "curl_json plugin: The type \"%s\" has more than one data source. "
160 "This is currently not supported. I will return the type of the "
161 "first data source, but this will likely lead to problems later on.",
162 key->type);
163 }
165 return ds->ds[0].type;
166 }
168 /* yajl callbacks */
169 #define CJ_CB_ABORT 0
170 #define CJ_CB_CONTINUE 1
172 /* "number" may not be null terminated, so copy it into a buffer before
173 * parsing. */
174 static int cj_cb_number (void *ctx,
175 const char *number, yajl_len_t number_len)
176 {
177 char buffer[number_len + 1];
179 cj_t *db = (cj_t *)ctx;
180 cj_key_t *key = db->state[db->depth].key;
181 value_t vt;
182 int type;
183 int status;
185 if ((key == NULL) || !CJ_IS_KEY (key))
186 return (CJ_CB_CONTINUE);
188 memcpy (buffer, number, number_len);
189 buffer[sizeof (buffer) - 1] = 0;
191 type = cj_get_type (key);
192 status = parse_value (buffer, &vt, type);
193 if (status != 0)
194 {
195 NOTICE ("curl_json plugin: Unable to parse number: \"%s\"", buffer);
196 return (CJ_CB_CONTINUE);
197 }
199 cj_submit (db, key, &vt);
200 return (CJ_CB_CONTINUE);
201 } /* int cj_cb_number */
203 static int cj_cb_map_key (void *ctx, const unsigned char *val,
204 yajl_len_t len)
205 {
206 cj_t *db = (cj_t *)ctx;
207 c_avl_tree_t *tree;
209 tree = db->state[db->depth-1].tree;
211 if (tree != NULL)
212 {
213 cj_key_t *value;
214 char *name;
216 name = db->state[db->depth].name;
217 len = COUCH_MIN(len, sizeof (db->state[db->depth].name)-1);
218 sstrncpy (name, (char *)val, len+1);
220 if (c_avl_get (tree, name, (void *) &value) == 0)
221 db->state[db->depth].key = value;
222 else if (c_avl_get (tree, CJ_ANY, (void *) &value) == 0)
223 db->state[db->depth].key = value;
224 else
225 db->state[db->depth].key = NULL;
226 }
228 return (CJ_CB_CONTINUE);
229 }
231 static int cj_cb_string (void *ctx, const unsigned char *val,
232 yajl_len_t len)
233 {
234 cj_t *db = (cj_t *)ctx;
235 char str[len + 1];
237 /* Create a null-terminated version of the string. */
238 memcpy (str, val, len);
239 str[len] = 0;
241 /* No configuration for this string -> simply return. */
242 if (db->state[db->depth].key == NULL)
243 return (CJ_CB_CONTINUE);
245 if (!CJ_IS_KEY (db->state[db->depth].key))
246 {
247 NOTICE ("curl_json plugin: Found string \"%s\", but the configuration "
248 "expects a map here.", str);
249 return (CJ_CB_CONTINUE);
250 }
252 /* Handle the string as if it was a number. */
253 return (cj_cb_number (ctx, (const char *) val, len));
254 } /* int cj_cb_string */
256 static int cj_cb_start (void *ctx)
257 {
258 cj_t *db = (cj_t *)ctx;
259 if (++db->depth >= YAJL_MAX_DEPTH)
260 {
261 ERROR ("curl_json plugin: %s depth exceeds max, aborting.", db->url);
262 return (CJ_CB_ABORT);
263 }
264 return (CJ_CB_CONTINUE);
265 }
267 static int cj_cb_end (void *ctx)
268 {
269 cj_t *db = (cj_t *)ctx;
270 db->state[db->depth].tree = NULL;
271 --db->depth;
272 return (CJ_CB_CONTINUE);
273 }
275 static int cj_cb_start_map (void *ctx)
276 {
277 return cj_cb_start (ctx);
278 }
280 static int cj_cb_end_map (void *ctx)
281 {
282 return cj_cb_end (ctx);
283 }
285 static int cj_cb_start_array (void * ctx)
286 {
287 return cj_cb_start (ctx);
288 }
290 static int cj_cb_end_array (void * ctx)
291 {
292 return cj_cb_end (ctx);
293 }
295 static yajl_callbacks ycallbacks = {
296 NULL, /* null */
297 NULL, /* boolean */
298 NULL, /* integer */
299 NULL, /* double */
300 cj_cb_number,
301 cj_cb_string,
302 cj_cb_start_map,
303 cj_cb_map_key,
304 cj_cb_end_map,
305 cj_cb_start_array,
306 cj_cb_end_array
307 };
309 /* end yajl callbacks */
311 static void cj_key_free (cj_key_t *key) /* {{{ */
312 {
313 if (key == NULL)
314 return;
316 sfree (key->path);
317 sfree (key->type);
318 sfree (key->instance);
320 sfree (key);
321 } /* }}} void cj_key_free */
323 static void cj_tree_free (c_avl_tree_t *tree) /* {{{ */
324 {
325 char *name;
326 void *value;
328 while (c_avl_pick (tree, (void *) &name, (void *) &value) == 0)
329 {
330 cj_key_t *key = (cj_key_t *)value;
332 if (CJ_IS_KEY(key))
333 cj_key_free (key);
334 else
335 cj_tree_free ((c_avl_tree_t *)value);
337 sfree (name);
338 }
340 c_avl_destroy (tree);
341 } /* }}} void cj_tree_free */
343 static void cj_free (void *arg) /* {{{ */
344 {
345 cj_t *db;
347 DEBUG ("curl_json plugin: cj_free (arg = %p);", arg);
349 db = (cj_t *) arg;
351 if (db == NULL)
352 return;
354 if (db->curl != NULL)
355 curl_easy_cleanup (db->curl);
356 db->curl = NULL;
358 if (db->tree != NULL)
359 cj_tree_free (db->tree);
360 db->tree = NULL;
362 sfree (db->instance);
363 sfree (db->host);
365 sfree (db->url);
366 sfree (db->user);
367 sfree (db->pass);
368 sfree (db->credentials);
369 sfree (db->cacert);
371 sfree (db);
372 } /* }}} void cj_free */
374 /* Configuration handling functions {{{ */
376 static c_avl_tree_t *cj_avl_create(void)
377 {
378 return c_avl_create ((int (*) (const void *, const void *)) strcmp);
379 }
381 static int cj_config_add_key (cj_t *db, /* {{{ */
382 oconfig_item_t *ci)
383 {
384 cj_key_t *key;
385 int status;
386 int i;
388 if ((ci->values_num != 1)
389 || (ci->values[0].type != OCONFIG_TYPE_STRING))
390 {
391 WARNING ("curl_json plugin: The `Key' block "
392 "needs exactly one string argument.");
393 return (-1);
394 }
396 key = (cj_key_t *) malloc (sizeof (*key));
397 if (key == NULL)
398 {
399 ERROR ("curl_json plugin: malloc failed.");
400 return (-1);
401 }
402 memset (key, 0, sizeof (*key));
403 key->magic = CJ_KEY_MAGIC;
405 if (strcasecmp ("Key", ci->key) == 0)
406 {
407 status = cf_util_get_string (ci, &key->path);
408 if (status != 0)
409 {
410 sfree (key);
411 return (status);
412 }
413 }
414 else
415 {
416 ERROR ("curl_json plugin: cj_config: "
417 "Invalid key: %s", ci->key);
418 return (-1);
419 }
421 status = 0;
422 for (i = 0; i < ci->children_num; i++)
423 {
424 oconfig_item_t *child = ci->children + i;
426 if (strcasecmp ("Type", child->key) == 0)
427 status = cf_util_get_string (child, &key->type);
428 else if (strcasecmp ("Instance", child->key) == 0)
429 status = cf_util_get_string (child, &key->instance);
430 else
431 {
432 WARNING ("curl_json plugin: Option `%s' not allowed here.", child->key);
433 status = -1;
434 }
436 if (status != 0)
437 break;
438 } /* for (i = 0; i < ci->children_num; i++) */
440 while (status == 0)
441 {
442 if (key->type == NULL)
443 {
444 WARNING ("curl_json plugin: `Type' missing in `Key' block.");
445 status = -1;
446 }
448 break;
449 } /* while (status == 0) */
451 /* store path in a tree that will match the json map structure, example:
452 * "httpd/requests/count",
453 * "httpd/requests/current" ->
454 * { "httpd": { "requests": { "count": $key, "current": $key } } }
455 */
456 if (status == 0)
457 {
458 char *ptr;
459 char *name;
460 char ent[PATH_MAX];
461 c_avl_tree_t *tree;
463 if (db->tree == NULL)
464 db->tree = cj_avl_create();
466 tree = db->tree;
467 name = key->path;
468 ptr = key->path;
469 if (*ptr == '/')
470 ++ptr;
472 name = ptr;
473 while (*ptr)
474 {
475 if (*ptr == '/')
476 {
477 c_avl_tree_t *value;
478 int len;
480 len = ptr-name;
481 if (len == 0)
482 break;
483 sstrncpy (ent, name, len+1);
485 if (c_avl_get (tree, ent, (void *) &value) != 0)
486 {
487 value = cj_avl_create ();
488 c_avl_insert (tree, strdup (ent), value);
489 }
491 tree = value;
492 name = ptr+1;
493 }
494 ++ptr;
495 }
496 if (*name)
497 c_avl_insert (tree, strdup(name), key);
498 else
499 {
500 ERROR ("curl_json plugin: invalid key: %s", key->path);
501 status = -1;
502 }
503 }
505 return (status);
506 } /* }}} int cj_config_add_key */
508 static int cj_init_curl (cj_t *db) /* {{{ */
509 {
510 db->curl = curl_easy_init ();
511 if (db->curl == NULL)
512 {
513 ERROR ("curl_json plugin: curl_easy_init failed.");
514 return (-1);
515 }
517 curl_easy_setopt (db->curl, CURLOPT_NOSIGNAL, 1L);
518 curl_easy_setopt (db->curl, CURLOPT_WRITEFUNCTION, cj_curl_callback);
519 curl_easy_setopt (db->curl, CURLOPT_WRITEDATA, db);
520 curl_easy_setopt (db->curl, CURLOPT_USERAGENT,
521 PACKAGE_NAME"/"PACKAGE_VERSION);
522 curl_easy_setopt (db->curl, CURLOPT_ERRORBUFFER, db->curl_errbuf);
523 curl_easy_setopt (db->curl, CURLOPT_URL, db->url);
525 if (db->user != NULL)
526 {
527 size_t credentials_size;
529 credentials_size = strlen (db->user) + 2;
530 if (db->pass != NULL)
531 credentials_size += strlen (db->pass);
533 db->credentials = (char *) malloc (credentials_size);
534 if (db->credentials == NULL)
535 {
536 ERROR ("curl_json plugin: malloc failed.");
537 return (-1);
538 }
540 ssnprintf (db->credentials, credentials_size, "%s:%s",
541 db->user, (db->pass == NULL) ? "" : db->pass);
542 curl_easy_setopt (db->curl, CURLOPT_USERPWD, db->credentials);
543 }
545 curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYPEER, (long) db->verify_peer);
546 curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYHOST,
547 db->verify_host ? 2L : 0L);
548 if (db->cacert != NULL)
549 curl_easy_setopt (db->curl, CURLOPT_CAINFO, db->cacert);
551 return (0);
552 } /* }}} int cj_init_curl */
554 static int cj_config_add_url (oconfig_item_t *ci) /* {{{ */
555 {
556 cj_t *db;
557 int status = 0;
558 int i;
560 if ((ci->values_num != 1)
561 || (ci->values[0].type != OCONFIG_TYPE_STRING))
562 {
563 WARNING ("curl_json plugin: The `URL' block "
564 "needs exactly one string argument.");
565 return (-1);
566 }
568 db = (cj_t *) malloc (sizeof (*db));
569 if (db == NULL)
570 {
571 ERROR ("curl_json plugin: malloc failed.");
572 return (-1);
573 }
574 memset (db, 0, sizeof (*db));
576 if (strcasecmp ("URL", ci->key) == 0)
577 {
578 status = cf_util_get_string (ci, &db->url);
579 if (status != 0)
580 {
581 sfree (db);
582 return (status);
583 }
584 }
585 else
586 {
587 ERROR ("curl_json plugin: cj_config: "
588 "Invalid key: %s", ci->key);
589 return (-1);
590 }
592 /* Fill the `cj_t' structure.. */
593 for (i = 0; i < ci->children_num; i++)
594 {
595 oconfig_item_t *child = ci->children + i;
597 if (strcasecmp ("Instance", child->key) == 0)
598 status = cf_util_get_string (child, &db->instance);
599 else if (strcasecmp ("Host", child->key) == 0)
600 status = cf_util_get_string (child, &db->host);
601 else if (strcasecmp ("User", child->key) == 0)
602 status = cf_util_get_string (child, &db->user);
603 else if (strcasecmp ("Password", child->key) == 0)
604 status = cf_util_get_string (child, &db->pass);
605 else if (strcasecmp ("VerifyPeer", child->key) == 0)
606 status = cf_util_get_boolean (child, &db->verify_peer);
607 else if (strcasecmp ("VerifyHost", child->key) == 0)
608 status = cf_util_get_boolean (child, &db->verify_host);
609 else if (strcasecmp ("CACert", child->key) == 0)
610 status = cf_util_get_string (child, &db->cacert);
611 else if (strcasecmp ("Key", child->key) == 0)
612 status = cj_config_add_key (db, child);
613 else
614 {
615 WARNING ("curl_json plugin: Option `%s' not allowed here.", child->key);
616 status = -1;
617 }
619 if (status != 0)
620 break;
621 }
623 if (status == 0)
624 {
625 if (db->tree == NULL)
626 {
627 WARNING ("curl_json plugin: No (valid) `Key' block "
628 "within `URL' block `%s'.", db->url);
629 status = -1;
630 }
631 if (status == 0)
632 status = cj_init_curl (db);
633 }
635 /* If all went well, register this database for reading */
636 if (status == 0)
637 {
638 user_data_t ud;
639 char cb_name[DATA_MAX_NAME_LEN];
641 if (db->instance == NULL)
642 db->instance = strdup("default");
644 DEBUG ("curl_json plugin: Registering new read callback: %s",
645 db->instance);
647 memset (&ud, 0, sizeof (ud));
648 ud.data = (void *) db;
649 ud.free_func = cj_free;
651 ssnprintf (cb_name, sizeof (cb_name), "curl_json-%s-%s",
652 db->instance, db->url);
654 plugin_register_complex_read (/* group = */ NULL, cb_name, cj_read,
655 /* interval = */ NULL, &ud);
656 }
657 else
658 {
659 cj_free (db);
660 return (-1);
661 }
663 return (0);
664 }
665 /* }}} int cj_config_add_database */
667 static int cj_config (oconfig_item_t *ci) /* {{{ */
668 {
669 int success;
670 int errors;
671 int status;
672 int i;
674 success = 0;
675 errors = 0;
677 for (i = 0; i < ci->children_num; i++)
678 {
679 oconfig_item_t *child = ci->children + i;
681 if (strcasecmp ("URL", child->key) == 0)
682 {
683 status = cj_config_add_url (child);
684 if (status == 0)
685 success++;
686 else
687 errors++;
688 }
689 else
690 {
691 WARNING ("curl_json plugin: Option `%s' not allowed here.", child->key);
692 errors++;
693 }
694 }
696 if ((success == 0) && (errors > 0))
697 {
698 ERROR ("curl_json plugin: All statements failed.");
699 return (-1);
700 }
702 return (0);
703 } /* }}} int cj_config */
705 /* }}} End of configuration handling functions */
707 static void cj_submit (cj_t *db, cj_key_t *key, value_t *value) /* {{{ */
708 {
709 value_list_t vl = VALUE_LIST_INIT;
710 char *host;
712 vl.values = value;
713 vl.values_len = 1;
715 if ((db->host == NULL)
716 || (strcmp ("", db->host) == 0)
717 || (strcmp (CJ_DEFAULT_HOST, db->host) == 0))
718 host = hostname_g;
719 else
720 host = db->host;
722 if (key->instance == NULL)
723 {
724 if ((db->depth == 0) || (strcmp ("", db->state[db->depth-1].name) == 0))
725 sstrncpy (vl.type_instance, db->state[db->depth].name, sizeof (vl.type_instance));
726 else
727 ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-%s",
728 db->state[db->depth-1].name, db->state[db->depth].name);
729 }
730 else
731 sstrncpy (vl.type_instance, key->instance, sizeof (vl.type_instance));
733 sstrncpy (vl.host, host, sizeof (vl.host));
734 sstrncpy (vl.plugin, "curl_json", sizeof (vl.plugin));
735 sstrncpy (vl.plugin_instance, db->instance, sizeof (vl.plugin_instance));
736 sstrncpy (vl.type, key->type, sizeof (vl.type));
738 plugin_dispatch_values (&vl);
739 } /* }}} int cj_submit */
741 static int cj_curl_perform (cj_t *db, CURL *curl) /* {{{ */
742 {
743 int status;
744 long rc;
745 char *url;
746 yajl_handle yprev = db->yajl;
748 db->yajl = yajl_alloc (&ycallbacks,
749 #if HAVE_YAJL_V2
750 /* alloc funcs = */ NULL,
751 #else
752 /* alloc funcs = */ NULL, NULL,
753 #endif
754 /* context = */ (void *)db);
755 if (db->yajl == NULL)
756 {
757 ERROR ("curl_json plugin: yajl_alloc failed.");
758 db->yajl = yprev;
759 return (-1);
760 }
762 url = NULL;
763 curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
765 status = curl_easy_perform (curl);
766 if (status != CURLE_OK)
767 {
768 ERROR ("curl_json plugin: curl_easy_perform failed with status %i: %s (%s)",
769 status, db->curl_errbuf, (url != NULL) ? url : "<null>");
770 yajl_free (db->yajl);
771 db->yajl = yprev;
772 return (-1);
773 }
775 curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &rc);
777 /* The response code is zero if a non-HTTP transport was used. */
778 if ((rc != 0) && (rc != 200))
779 {
780 ERROR ("curl_json plugin: curl_easy_perform failed with "
781 "response code %ld (%s)", rc, url);
782 yajl_free (db->yajl);
783 db->yajl = yprev;
784 return (-1);
785 }
787 #if HAVE_YAJL_V2
788 status = yajl_complete_parse(db->yajl);
789 #else
790 status = yajl_parse_complete(db->yajl);
791 #endif
792 if (status != yajl_status_ok)
793 {
794 unsigned char *errmsg;
796 errmsg = yajl_get_error (db->yajl, /* verbose = */ 0,
797 /* jsonText = */ NULL, /* jsonTextLen = */ 0);
798 ERROR ("curl_json plugin: yajl_parse_complete failed: %s",
799 (char *) errmsg);
800 yajl_free_error (db->yajl, errmsg);
801 yajl_free (db->yajl);
802 db->yajl = yprev;
803 return (-1);
804 }
806 yajl_free (db->yajl);
807 db->yajl = yprev;
808 return (0);
809 } /* }}} int cj_curl_perform */
811 static int cj_read (user_data_t *ud) /* {{{ */
812 {
813 cj_t *db;
815 if ((ud == NULL) || (ud->data == NULL))
816 {
817 ERROR ("curl_json plugin: cj_read: Invalid user data.");
818 return (-1);
819 }
821 db = (cj_t *) ud->data;
823 db->depth = 0;
824 memset (&db->state, 0, sizeof(db->state));
825 db->state[db->depth].tree = db->tree;
826 db->key = NULL;
828 return cj_curl_perform (db, db->curl);
829 } /* }}} int cj_read */
831 void module_register (void)
832 {
833 plugin_register_complex_config ("curl_json", cj_config);
834 } /* void module_register */
836 /* vim: set sw=2 sts=2 et fdm=marker : */