src/curl_json.c

   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  **/
  23
  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"
  30
  31 #include <sys/socket.h>
  32 #include <sys/types.h>
  33 #include <sys/un.h>
  34
  35 #include <curl/curl.h>
  36
  37 #include <yajl/yajl_parse.h>
  38 #if HAVE_YAJL_YAJL_VERSION_H
  39 # include <yajl/yajl_version.h>
  40 #endif
  41
  42 #if defined(YAJL_MAJOR) && (YAJL_MAJOR > 1)
  43 # define HAVE_YAJL_V2 1
  44 #endif
  45
  46 #define CJ_DEFAULT_HOST "localhost"
  47 #define CJ_KEY_MAGIC 0x43484b59UL /* CHKY */
  48 #define CJ_IS_KEY(key) ((key)->magic == CJ_KEY_MAGIC)
  49 #define CJ_ANY "*"
  50 #define COUCH_MIN(x,y) ((x) < (y) ? (x) : (y))
  51
  52 struct cj_key_s;
  53 typedef struct cj_key_s cj_key_t;
  54 struct cj_key_s /* {{{ */
  55 {
  56   char *path;
  57   char *type;
  58   char *instance;
  59   unsigned long magic;
  60 };
  61 /* }}} */
  62
  63 struct cj_s /* {{{ */
  64 {
  65   char *instance;
  66   char *host;
  67
  68   char *sock;
  69
  70   char *url;
  71   char *user;
  72   char *pass;
  73   char *credentials;
  74   _Bool verify_peer;
  75   _Bool verify_host;
  76   char *cacert;
  77   struct curl_slist *headers;
  78   char *post_body;
  79
  80   CURL *curl;
  81   char curl_errbuf[CURL_ERROR_SIZE];
  82
  83   yajl_handle yajl;
  84   c_avl_tree_t *tree;
  85   cj_key_t *key;
  86   int depth;
  87   struct {
  88     union {
  89       c_avl_tree_t *tree;
  90       cj_key_t *key;
  91     };
  92     char name[DATA_MAX_NAME_LEN];
  93   } state[YAJL_MAX_DEPTH];
  94 };
  95 typedef struct cj_s cj_t; /* }}} */
  96
  97 #if HAVE_YAJL_V2
  98 typedef size_t yajl_len_t;
  99 #else
 100 typedef unsigned int yajl_len_t;
 101 #endif
 102
 103 static int cj_read (user_data_t *ud);
 104 static void cj_submit (cj_t *db, cj_key_t *key, value_t *value);
 105
 106 static size_t cj_curl_callback (void *buf, /* {{{ */
 107     size_t size, size_t nmemb, void *user_data)
 108 {
 109   cj_t *db;
 110   size_t len;
 111   yajl_status status;
 112
 113   len = size * nmemb;
 114
 115   if (len <= 0)
 116     return (len);
 117
 118   db = user_data;
 119   if (db == NULL)
 120     return (0);
 121
 122   status = yajl_parse(db->yajl, (unsigned char *)buf, len);
 123   if (status == yajl_status_ok)
 124     return (len);
 125 #if !HAVE_YAJL_V2
 126   else if (status == yajl_status_insufficient_data)
 127     return (len);
 128 #endif
 129
 130   if (status != yajl_status_ok)
 131   {
 132     unsigned char *msg =
 133       yajl_get_error(db->yajl, /* verbose = */ 1,
 134           /* jsonText = */ (unsigned char *) buf, (unsigned int) len);
 135     ERROR ("curl_json plugin: yajl_parse failed: %s", msg);
 136     yajl_free_error(db->yajl, msg);
 137     return (0); /* abort write callback */
 138   }
 139
 140   return (len);
 141 } /* }}} size_t cj_curl_callback */
 142
 143 static int cj_get_type (cj_key_t *key)
 144 {
 145   const data_set_t *ds;
 146
 147   ds = plugin_get_ds (key->type);
 148   if (ds == NULL)
 149   {
 150     static char type[DATA_MAX_NAME_LEN] = "!!!invalid!!!";
 151
 152     assert (key->type != NULL);
 153     if (strcmp (type, key->type) != 0)
 154     {
 155       ERROR ("curl_json plugin: Unable to look up DS type \"%s\".",
 156           key->type);
 157       sstrncpy (type, key->type, sizeof (type));
 158     }
 159
 160     return -1;
 161   }
 162   else if (ds->ds_num > 1)
 163   {
 164     static c_complain_t complaint = C_COMPLAIN_INIT_STATIC;
 165
 166     c_complain_once (LOG_WARNING, &complaint,
 167         "curl_json plugin: The type \"%s\" has more than one data source. "
 168         "This is currently not supported. I will return the type of the "
 169         "first data source, but this will likely lead to problems later on.",
 170         key->type);
 171   }
 172
 173   return ds->ds[0].type;
 174 }
 175
 176 /* yajl callbacks */
 177 #define CJ_CB_ABORT    0
 178 #define CJ_CB_CONTINUE 1
 179
 180 /* "number" may not be null terminated, so copy it into a buffer before
 181  * parsing. */
 182 static int cj_cb_number (void *ctx,
 183     const char *number, yajl_len_t number_len)
 184 {
 185   char buffer[number_len + 1];
 186
 187   cj_t *db = (cj_t *)ctx;
 188   cj_key_t *key = db->state[db->depth].key;
 189   value_t vt;
 190   int type;
 191   int status;
 192
 193   if ((key == NULL) || !CJ_IS_KEY (key))
 194     return (CJ_CB_CONTINUE);
 195
 196   memcpy (buffer, number, number_len);
 197   buffer[sizeof (buffer) - 1] = 0;
 198
 199   type = cj_get_type (key);
 200   status = parse_value (buffer, &vt, type);
 201   if (status != 0)
 202   {
 203     NOTICE ("curl_json plugin: Unable to parse number: \"%s\"", buffer);
 204     return (CJ_CB_CONTINUE);
 205   }
 206
 207   cj_submit (db, key, &vt);
 208   return (CJ_CB_CONTINUE);
 209 } /* int cj_cb_number */
 210
 211 static int cj_cb_map_key (void *ctx, const unsigned char *val,
 212     yajl_len_t len)
 213 {
 214   cj_t *db = (cj_t *)ctx;
 215   c_avl_tree_t *tree;
 216
 217   tree = db->state[db->depth-1].tree;
 218
 219   if (tree != NULL)
 220   {
 221     cj_key_t *value;
 222     char *name;
 223
 224     name = db->state[db->depth].name;
 225     len = COUCH_MIN(len, sizeof (db->state[db->depth].name)-1);
 226     sstrncpy (name, (char *)val, len+1);
 227
 228     if (c_avl_get (tree, name, (void *) &value) == 0)
 229       db->state[db->depth].key = value;
 230     else if (c_avl_get (tree, CJ_ANY, (void *) &value) == 0)
 231       db->state[db->depth].key = value;
 232     else
 233       db->state[db->depth].key = NULL;
 234   }
 235
 236   return (CJ_CB_CONTINUE);
 237 }
 238
 239 static int cj_cb_string (void *ctx, const unsigned char *val,
 240     yajl_len_t len)
 241 {
 242   cj_t *db = (cj_t *)ctx;
 243   char str[len + 1];
 244
 245   /* Create a null-terminated version of the string. */
 246   memcpy (str, val, len);
 247   str[len] = 0;
 248
 249   /* No configuration for this string -> simply return. */
 250   if (db->state[db->depth].key == NULL)
 251     return (CJ_CB_CONTINUE);
 252
 253   if (!CJ_IS_KEY (db->state[db->depth].key))
 254   {
 255     NOTICE ("curl_json plugin: Found string \"%s\", but the configuration "
 256         "expects a map here.", str);
 257     return (CJ_CB_CONTINUE);
 258   }
 259
 260   /* Handle the string as if it was a number. */
 261   return (cj_cb_number (ctx, (const char *) val, len));
 262 } /* int cj_cb_string */
 263
 264 static int cj_cb_start (void *ctx)
 265 {
 266   cj_t *db = (cj_t *)ctx;
 267   if (++db->depth >= YAJL_MAX_DEPTH)
 268   {
 269     ERROR ("curl_json plugin: %s depth exceeds max, aborting.",
 270            db->url ? db->url : db->sock);
 271     return (CJ_CB_ABORT);
 272   }
 273   return (CJ_CB_CONTINUE);
 274 }
 275
 276 static int cj_cb_end (void *ctx)
 277 {
 278   cj_t *db = (cj_t *)ctx;
 279   db->state[db->depth].tree = NULL;
 280   --db->depth;
 281   return (CJ_CB_CONTINUE);
 282 }
 283
 284 static int cj_cb_start_map (void *ctx)
 285 {
 286   return cj_cb_start (ctx);
 287 }
 288
 289 static int cj_cb_end_map (void *ctx)
 290 {
 291   return cj_cb_end (ctx);
 292 }
 293
 294 static int cj_cb_start_array (void * ctx)
 295 {
 296   return cj_cb_start (ctx);
 297 }
 298
 299 static int cj_cb_end_array (void * ctx)
 300 {
 301   return cj_cb_end (ctx);
 302 }
 303
 304 static yajl_callbacks ycallbacks = {
 305   NULL, /* null */
 306   NULL, /* boolean */
 307   NULL, /* integer */
 308   NULL, /* double */
 309   cj_cb_number,
 310   cj_cb_string,
 311   cj_cb_start_map,
 312   cj_cb_map_key,
 313   cj_cb_end_map,
 314   cj_cb_start_array,
 315   cj_cb_end_array
 316 };
 317
 318 /* end yajl callbacks */
 319
 320 static void cj_key_free (cj_key_t *key) /* {{{ */
 321 {
 322   if (key == NULL)
 323     return;
 324
 325   sfree (key->path);
 326   sfree (key->type);
 327   sfree (key->instance);
 328
 329   sfree (key);
 330 } /* }}} void cj_key_free */
 331
 332 static void cj_tree_free (c_avl_tree_t *tree) /* {{{ */
 333 {
 334   char *name;
 335   void *value;
 336
 337   while (c_avl_pick (tree, (void *) &name, (void *) &value) == 0)
 338   {
 339     cj_key_t *key = (cj_key_t *)value;
 340
 341     if (CJ_IS_KEY(key))
 342       cj_key_free (key);
 343     else
 344       cj_tree_free ((c_avl_tree_t *)value);
 345
 346     sfree (name);
 347   }
 348
 349   c_avl_destroy (tree);
 350 } /* }}} void cj_tree_free */
 351
 352 static void cj_free (void *arg) /* {{{ */
 353 {
 354   cj_t *db;
 355
 356   DEBUG ("curl_json plugin: cj_free (arg = %p);", arg);
 357
 358   db = (cj_t *) arg;
 359
 360   if (db == NULL)
 361     return;
 362
 363   if (db->curl != NULL)
 364     curl_easy_cleanup (db->curl);
 365   db->curl = NULL;
 366
 367   if (db->tree != NULL)
 368     cj_tree_free (db->tree);
 369   db->tree = NULL;
 370
 371   sfree (db->instance);
 372   sfree (db->host);
 373
 374   sfree (db->url);
 375   sfree (db->user);
 376   sfree (db->pass);
 377   sfree (db->credentials);
 378   sfree (db->cacert);
 379   sfree (db->post_body);
 380   curl_slist_free_all (db->headers);
 381
 382   sfree (db);
 383 } /* }}} void cj_free */
 384
 385 /* Configuration handling functions {{{ */
 386
 387 static c_avl_tree_t *cj_avl_create(void)
 388 {
 389   return c_avl_create ((int (*) (const void *, const void *)) strcmp);
 390 }
 391
 392 static int cj_config_append_string (const char *name, struct curl_slist **dest, /* {{{ */
 393     oconfig_item_t *ci)
 394 {
 395   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
 396   {
 397     WARNING ("curl_json plugin: `%s' needs exactly one string argument.", name);
 398     return (-1);
 399   }
 400
 401   *dest = curl_slist_append(*dest, ci->values[0].value.string);
 402   if (*dest == NULL)
 403     return (-1);
 404
 405   return (0);
 406 } /* }}} int cj_config_append_string */
 407
 408 static int cj_config_add_key (cj_t *db, /* {{{ */
 409                                    oconfig_item_t *ci)
 410 {
 411   cj_key_t *key;
 412   int status;
 413   int i;
 414
 415   if ((ci->values_num != 1)
 416       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 417   {
 418     WARNING ("curl_json plugin: The `Key' block "
 419              "needs exactly one string argument.");
 420     return (-1);
 421   }
 422
 423   key = (cj_key_t *) malloc (sizeof (*key));
 424   if (key == NULL)
 425   {
 426     ERROR ("curl_json plugin: malloc failed.");
 427     return (-1);
 428   }
 429   memset (key, 0, sizeof (*key));
 430   key->magic = CJ_KEY_MAGIC;
 431
 432   if (strcasecmp ("Key", ci->key) == 0)
 433   {
 434     status = cf_util_get_string (ci, &key->path);
 435     if (status != 0)
 436     {
 437       sfree (key);
 438       return (status);
 439     }
 440   }
 441   else
 442   {
 443     ERROR ("curl_json plugin: cj_config: "
 444            "Invalid key: %s", ci->key);
 445     return (-1);
 446   }
 447
 448   status = 0;
 449   for (i = 0; i < ci->children_num; i++)
 450   {
 451     oconfig_item_t *child = ci->children + i;
 452
 453     if (strcasecmp ("Type", child->key) == 0)
 454       status = cf_util_get_string (child, &key->type);
 455     else if (strcasecmp ("Instance", child->key) == 0)
 456       status = cf_util_get_string (child, &key->instance);
 457     else
 458     {
 459       WARNING ("curl_json plugin: Option `%s' not allowed here.", child->key);
 460       status = -1;
 461     }
 462
 463     if (status != 0)
 464       break;
 465   } /* for (i = 0; i < ci->children_num; i++) */
 466
 467   while (status == 0)
 468   {
 469     if (key->type == NULL)
 470     {
 471       WARNING ("curl_json plugin: `Type' missing in `Key' block.");
 472       status = -1;
 473     }
 474
 475     break;
 476   } /* while (status == 0) */
 477
 478   /* store path in a tree that will match the json map structure, example:
 479    * "httpd/requests/count",
 480    * "httpd/requests/current" ->
 481    * { "httpd": { "requests": { "count": $key, "current": $key } } }
 482    */
 483   if (status == 0)
 484   {
 485     char *ptr;
 486     char *name;
 487     char ent[PATH_MAX];
 488     c_avl_tree_t *tree;
 489
 490     if (db->tree == NULL)
 491       db->tree = cj_avl_create();
 492
 493     tree = db->tree;
 494     name = key->path;
 495     ptr = key->path;
 496     if (*ptr == '/')
 497       ++ptr;
 498
 499     name = ptr;
 500     while (*ptr)
 501     {
 502       if (*ptr == '/')
 503       {
 504         c_avl_tree_t *value;
 505         int len;
 506
 507         len = ptr-name;
 508         if (len == 0)
 509           break;
 510         sstrncpy (ent, name, len+1);
 511
 512         if (c_avl_get (tree, ent, (void *) &value) != 0)
 513         {
 514           value = cj_avl_create ();
 515           c_avl_insert (tree, strdup (ent), value);
 516         }
 517
 518         tree = value;
 519         name = ptr+1;
 520       }
 521       ++ptr;
 522     }
 523     if (*name)
 524       c_avl_insert (tree, strdup(name), key);
 525     else
 526     {
 527       ERROR ("curl_json plugin: invalid key: %s", key->path);
 528       status = -1;
 529     }
 530   }
 531
 532   return (status);
 533 } /* }}} int cj_config_add_key */
 534
 535 static int cj_init_curl (cj_t *db) /* {{{ */
 536 {
 537   db->curl = curl_easy_init ();
 538   if (db->curl == NULL)
 539   {
 540     ERROR ("curl_json plugin: curl_easy_init failed.");
 541     return (-1);
 542   }
 543
 544   curl_easy_setopt (db->curl, CURLOPT_NOSIGNAL, 1L);
 545   curl_easy_setopt (db->curl, CURLOPT_WRITEFUNCTION, cj_curl_callback);
 546   curl_easy_setopt (db->curl, CURLOPT_WRITEDATA, db);
 547   curl_easy_setopt (db->curl, CURLOPT_USERAGENT,
 548                     PACKAGE_NAME"/"PACKAGE_VERSION);
 549   curl_easy_setopt (db->curl, CURLOPT_ERRORBUFFER, db->curl_errbuf);
 550   curl_easy_setopt (db->curl, CURLOPT_URL, db->url);
 551
 552   if (db->user != NULL)
 553   {
 554     size_t credentials_size;
 555
 556     credentials_size = strlen (db->user) + 2;
 557     if (db->pass != NULL)
 558       credentials_size += strlen (db->pass);
 559
 560     db->credentials = (char *) malloc (credentials_size);
 561     if (db->credentials == NULL)
 562     {
 563       ERROR ("curl_json plugin: malloc failed.");
 564       return (-1);
 565     }
 566
 567     ssnprintf (db->credentials, credentials_size, "%s:%s",
 568                db->user, (db->pass == NULL) ? "" : db->pass);
 569     curl_easy_setopt (db->curl, CURLOPT_USERPWD, db->credentials);
 570   }
 571
 572   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYPEER, (long) db->verify_peer);
 573   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYHOST,
 574                     db->verify_host ? 2L : 0L);
 575   if (db->cacert != NULL)
 576     curl_easy_setopt (db->curl, CURLOPT_CAINFO, db->cacert);
 577   if (db->headers != NULL)
 578     curl_easy_setopt (db->curl, CURLOPT_HTTPHEADER, db->headers);
 579   if (db->post_body != NULL)
 580     curl_easy_setopt (db->curl, CURLOPT_POSTFIELDS, db->post_body);
 581
 582   return (0);
 583 } /* }}} int cj_init_curl */
 584
 585 static int cj_config_add_url (oconfig_item_t *ci) /* {{{ */
 586 {
 587   cj_t *db;
 588   int status = 0;
 589   int i;
 590
 591   if ((ci->values_num != 1)
 592       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 593   {
 594     WARNING ("curl_json plugin: The `URL' block "
 595              "needs exactly one string argument.");
 596     return (-1);
 597   }
 598
 599   db = (cj_t *) malloc (sizeof (*db));
 600   if (db == NULL)
 601   {
 602     ERROR ("curl_json plugin: malloc failed.");
 603     return (-1);
 604   }
 605   memset (db, 0, sizeof (*db));
 606
 607   if (strcasecmp ("URL", ci->key) == 0)
 608     status = cf_util_get_string (ci, &db->url);
 609   else if (strcasecmp ("Sock", ci->key) == 0)
 610     status = cf_util_get_string (ci, &db->sock);
 611   else
 612   {
 613     ERROR ("curl_json plugin: cj_config: "
 614            "Invalid key: %s", ci->key);
 615     return (-1);
 616   }
 617   if (status != 0)
 618   {
 619     sfree (db);
 620     return (status);
 621   }
 622
 623   /* Fill the `cj_t' structure.. */
 624   for (i = 0; i < ci->children_num; i++)
 625   {
 626     oconfig_item_t *child = ci->children + i;
 627
 628     if (strcasecmp ("Instance", child->key) == 0)
 629       status = cf_util_get_string (child, &db->instance);
 630     else if (strcasecmp ("Host", child->key) == 0)
 631       status = cf_util_get_string (child, &db->host);
 632     else if (db->url && strcasecmp ("User", child->key) == 0)
 633       status = cf_util_get_string (child, &db->user);
 634     else if (db->url && strcasecmp ("Password", child->key) == 0)
 635       status = cf_util_get_string (child, &db->pass);
 636     else if (db->url && strcasecmp ("VerifyPeer", child->key) == 0)
 637       status = cf_util_get_boolean (child, &db->verify_peer);
 638     else if (db->url && strcasecmp ("VerifyHost", child->key) == 0)
 639       status = cf_util_get_boolean (child, &db->verify_host);
 640     else if (db->url && strcasecmp ("CACert", child->key) == 0)
 641       status = cf_util_get_string (child, &db->cacert);
 642     else if (db->url && strcasecmp ("Header", child->key) == 0)
 643       status = cj_config_append_string ("Header", &db->headers, child);
 644     else if (db->url && strcasecmp ("Post", child->key) == 0)
 645       status = cf_util_get_string (child, &db->post_body);
 646     else if (strcasecmp ("Key", child->key) == 0)
 647       status = cj_config_add_key (db, child);
 648     else
 649     {
 650       WARNING ("curl_json plugin: Option `%s' not allowed here.", child->key);
 651       status = -1;
 652     }
 653
 654     if (status != 0)
 655       break;
 656   }
 657
 658   if (status == 0)
 659   {
 660     if (db->tree == NULL)
 661     {
 662       WARNING ("curl_json plugin: No (valid) `Key' block within `%s' \"`%s'\".",
 663                db->url ? "URL" : "Sock", db->url ? db->url : db->sock);
 664       status = -1;
 665     }
 666     if (status == 0 && db->url)
 667       status = cj_init_curl (db);
 668   }
 669
 670   /* If all went well, register this database for reading */
 671   if (status == 0)
 672   {
 673     user_data_t ud;
 674     char cb_name[DATA_MAX_NAME_LEN];
 675
 676     if (db->instance == NULL)
 677       db->instance = strdup("default");
 678
 679     DEBUG ("curl_json plugin: Registering new read callback: %s",
 680            db->instance);
 681
 682     memset (&ud, 0, sizeof (ud));
 683     ud.data = (void *) db;
 684     ud.free_func = cj_free;
 685
 686     ssnprintf (cb_name, sizeof (cb_name), "curl_json-%s-%s",
 687                db->instance, db->url ? db->url : db->sock);
 688
 689     plugin_register_complex_read (/* group = */ NULL, cb_name, cj_read,
 690                                   /* interval = */ NULL, &ud);
 691   }
 692   else
 693   {
 694     cj_free (db);
 695     return (-1);
 696   }
 697
 698   return (0);
 699 }
 700  /* }}} int cj_config_add_database */
 701
 702 static int cj_config (oconfig_item_t *ci) /* {{{ */
 703 {
 704   int success;
 705   int errors;
 706   int status;
 707   int i;
 708
 709   success = 0;
 710   errors = 0;
 711
 712   for (i = 0; i < ci->children_num; i++)
 713   {
 714     oconfig_item_t *child = ci->children + i;
 715
 716     if (strcasecmp ("Sock", child->key) == 0
 717         || strcasecmp ("URL", child->key) == 0)
 718     {
 719       status = cj_config_add_url (child);
 720       if (status == 0)
 721         success++;
 722       else
 723         errors++;
 724     }
 725     else
 726     {
 727       WARNING ("curl_json plugin: Option `%s' not allowed here.", child->key);
 728       errors++;
 729     }
 730   }
 731
 732   if ((success == 0) && (errors > 0))
 733   {
 734     ERROR ("curl_json plugin: All statements failed.");
 735     return (-1);
 736   }
 737
 738   return (0);
 739 } /* }}} int cj_config */
 740
 741 /* }}} End of configuration handling functions */
 742
 743 static void cj_submit (cj_t *db, cj_key_t *key, value_t *value) /* {{{ */
 744 {
 745   value_list_t vl = VALUE_LIST_INIT;
 746   char *host;
 747
 748   vl.values     = value;
 749   vl.values_len = 1;
 750
 751   if ((db->host == NULL)
 752       || (strcmp ("", db->host) == 0)
 753       || (strcmp (CJ_DEFAULT_HOST, db->host) == 0))
 754     host = hostname_g;
 755   else
 756     host = db->host;
 757
 758   if (key->instance == NULL)
 759   {
 760     if ((db->depth == 0) || (strcmp ("", db->state[db->depth-1].name) == 0))
 761       sstrncpy (vl.type_instance, db->state[db->depth].name, sizeof (vl.type_instance));
 762     else
 763       ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-%s",
 764           db->state[db->depth-1].name, db->state[db->depth].name);
 765   }
 766   else
 767     sstrncpy (vl.type_instance, key->instance, sizeof (vl.type_instance));
 768
 769   sstrncpy (vl.host, host, sizeof (vl.host));
 770   sstrncpy (vl.plugin, "curl_json", sizeof (vl.plugin));
 771   sstrncpy (vl.plugin_instance, db->instance, sizeof (vl.plugin_instance));
 772   sstrncpy (vl.type, key->type, sizeof (vl.type));
 773
 774   plugin_dispatch_values (&vl);
 775 } /* }}} int cj_submit */
 776
 777 static int cj_sock_perform (cj_t *db) /* {{{ */
 778 {
 779   char errbuf[1024];
 780   struct sockaddr_un sa_unix = {};
 781   sa_unix.sun_family = AF_UNIX;
 782   sstrncpy (sa_unix.sun_path, db->sock, sizeof (sa_unix.sun_path));
 783
 784   int fd = socket (AF_UNIX, SOCK_STREAM, 0);
 785   if (fd < 0)
 786     return (-1);
 787   if (connect (fd, (struct sockaddr *)&sa_unix, sizeof(sa_unix)) < 0)
 788   {
 789     ERROR ("curl_json plugin: connect(%s) failed: %s",
 790            (db->sock != NULL) ? db->sock : "<null>",
 791            sstrerror(errno, errbuf, sizeof (errbuf)));
 792     close (fd);
 793     return (-1);
 794   }
 795
 796   ssize_t red;
 797   do {
 798     unsigned char buffer[4096];
 799     red = read (fd, buffer, sizeof(buffer));
 800     if (red < 0) {
 801         ERROR ("curl_json plugin: read(%s) failed: %s",
 802                (db->sock != NULL) ? db->sock : "<null>",
 803                sstrerror(errno, errbuf, sizeof (errbuf)));
 804         close (fd);
 805         return (-1);
 806     }
 807     if (!cj_curl_callback (buffer, red, 1, db))
 808         break;
 809   } while (red > 0);
 810   close (fd);
 811   return (0);
 812 } /* }}} int cj_sock_perform */
 813
 814
 815 static int cj_curl_perform(cj_t *db) /* {{{ */
 816 {
 817   int status;
 818   long rc;
 819   char *url;
 820   url = NULL;
 821   curl_easy_getinfo(db->curl, CURLINFO_EFFECTIVE_URL, &url);
 822
 823   status = curl_easy_perform (db->curl);
 824   if (status != CURLE_OK)
 825   {
 826     ERROR ("curl_json plugin: curl_easy_perform failed with status %i: %s (%s)",
 827            status, db->curl_errbuf, (url != NULL) ? url : "<null>");
 828     return (-1);
 829   }
 830
 831   curl_easy_getinfo(db->curl, CURLINFO_RESPONSE_CODE, &rc);
 832
 833   /* The response code is zero if a non-HTTP transport was used. */
 834   if ((rc != 0) && (rc != 200))
 835   {
 836     ERROR ("curl_json plugin: curl_easy_perform failed with "
 837         "response code %ld (%s)", rc, url);
 838     return (-1);
 839   }
 840   return (0);
 841 } /* }}} int cj_curl_perform */
 842
 843 static int cj_perform (cj_t *db) /* {{{ */
 844 {
 845   int status;
 846   yajl_handle yprev = db->yajl;
 847
 848   db->yajl = yajl_alloc (&ycallbacks,
 849 #if HAVE_YAJL_V2
 850       /* alloc funcs = */ NULL,
 851 #else
 852       /* alloc funcs = */ NULL, NULL,
 853 #endif
 854       /* context = */ (void *)db);
 855   if (db->yajl == NULL)
 856   {
 857     ERROR ("curl_json plugin: yajl_alloc failed.");
 858     db->yajl = yprev;
 859     return (-1);
 860   }
 861
 862   if (db->url)
 863     status = cj_curl_perform (db);
 864   else
 865     status = cj_sock_perform (db);
 866   if (status < 0)
 867   {
 868     yajl_free (db->yajl);
 869     db->yajl = yprev;
 870     return (-1);
 871   }
 872
 873 #if HAVE_YAJL_V2
 874     status = yajl_complete_parse(db->yajl);
 875 #else
 876     status = yajl_parse_complete(db->yajl);
 877 #endif
 878   if (status != yajl_status_ok)
 879   {
 880     unsigned char *errmsg;
 881
 882     errmsg = yajl_get_error (db->yajl, /* verbose = */ 0,
 883         /* jsonText = */ NULL, /* jsonTextLen = */ 0);
 884     ERROR ("curl_json plugin: yajl_parse_complete failed: %s",
 885         (char *) errmsg);
 886     yajl_free_error (db->yajl, errmsg);
 887     yajl_free (db->yajl);
 888     db->yajl = yprev;
 889     return (-1);
 890   }
 891
 892   yajl_free (db->yajl);
 893   db->yajl = yprev;
 894   return (0);
 895 } /* }}} int cj_perform */
 896
 897 static int cj_read (user_data_t *ud) /* {{{ */
 898 {
 899   cj_t *db;
 900
 901   if ((ud == NULL) || (ud->data == NULL))
 902   {
 903     ERROR ("curl_json plugin: cj_read: Invalid user data.");
 904     return (-1);
 905   }
 906
 907   db = (cj_t *) ud->data;
 908
 909   db->depth = 0;
 910   memset (&db->state, 0, sizeof(db->state));
 911   db->state[db->depth].tree = db->tree;
 912   db->key = NULL;
 913
 914   return cj_perform (db);
 915 } /* }}} int cj_read */
 916
 917 void module_register (void)
 918 {
 919   plugin_register_complex_config ("curl_json", cj_config);
 920 } /* void module_register */
 921
 922 /* vim: set sw=2 sts=2 et fdm=marker : */