src/curl_xml.c

   1 /**
   2  * collectd - src/curl_xml.c
   3  * Copyright (C) 2009,2010       Amit Gupta
   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  *   Amit Gupta <amit.gupta221 at gmail.com>
  20  **/
  21
  22 #include "collectd.h"
  23 #include "common.h"
  24 #include "plugin.h"
  25 #include "configfile.h"
  26 #include "utils_llist.h"
  27
  28 #include <libxml/parser.h>
  29 #include <libxml/tree.h>
  30 #include <libxml/xpath.h>
  31
  32 #include <curl/curl.h>
  33
  34 #define CX_DEFAULT_HOST "localhost"
  35
  36 /*
  37  * Private data structures
  38  */
  39 struct cx_values_s /* {{{ */
  40 {
  41   char path[DATA_MAX_NAME_LEN];
  42   size_t path_len;
  43 };
  44 typedef struct cx_values_s cx_values_t;
  45 /* }}} */
  46
  47 struct cx_xpath_s /* {{{ */
  48 {
  49   char *path;
  50   char *type;
  51   cx_values_t *values;
  52   int values_len;
  53   char *instance_prefix;
  54   char *instance;
  55   int is_table;
  56   unsigned long magic;
  57 };
  58 typedef struct cx_xpath_s cx_xpath_t;
  59 /* }}} */
  60
  61 struct cx_s /* {{{ */
  62 {
  63   char *instance;
  64   char *host;
  65
  66   char *url;
  67   char *user;
  68   char *pass;
  69   char *credentials;
  70   _Bool verify_peer;
  71   _Bool verify_host;
  72   char *cacert;
  73
  74   CURL *curl;
  75   char curl_errbuf[CURL_ERROR_SIZE];
  76   char *buffer;
  77   size_t buffer_size;
  78   size_t buffer_fill;
  79
  80   llist_t *list; /* list of xpath blocks */
  81 };
  82 typedef struct cx_s cx_t; /* }}} */
  83
  84 /*
  85  * Private functions
  86  */
  87 static size_t cx_curl_callback (void *buf, /* {{{ */
  88     size_t size, size_t nmemb, void *user_data)
  89 {
  90   size_t len = size * nmemb;
  91   cx_t *db;
  92
  93   db = user_data;
  94   if (db == NULL)
  95   {
  96     ERROR ("curl_xml plugin: cx_curl_callback: "
  97            "user_data pointer is NULL.");
  98     return (0);
  99   }
 100
 101    if (len <= 0)
 102     return (len);
 103
 104   if ((db->buffer_fill + len) >= db->buffer_size)
 105   {
 106     char *temp;
 107
 108     temp = (char *) realloc (db->buffer,
 109                     db->buffer_fill + len + 1);
 110     if (temp == NULL)
 111     {
 112       ERROR ("curl_xml plugin: realloc failed.");
 113       return (0);
 114     }
 115     db->buffer = temp;
 116     db->buffer_size = db->buffer_fill + len + 1;
 117   }
 118
 119   memcpy (db->buffer + db->buffer_fill, (char *) buf, len);
 120   db->buffer_fill += len;
 121   db->buffer[db->buffer_fill] = 0;
 122
 123   return (len);
 124 } /* }}} size_t cx_curl_callback */
 125
 126 static void cx_xpath_free (cx_xpath_t *xpath) /* {{{ */
 127 {
 128   if (xpath == NULL)
 129     return;
 130
 131   sfree (xpath->path);
 132   sfree (xpath->type);
 133   sfree (xpath->instance_prefix);
 134   sfree (xpath->instance);
 135   sfree (xpath->values);
 136   sfree (xpath);
 137 } /* }}} void cx_xpath_free */
 138
 139 static void cx_list_free (llist_t *list) /* {{{ */
 140 {
 141   llentry_t *le;
 142
 143   le = llist_head (list);
 144   while (le != NULL)
 145   {
 146     llentry_t *le_next;
 147
 148     le_next = le->next;
 149
 150     sfree (le->key);
 151     cx_xpath_free (le->value);
 152
 153     le = le_next;
 154   }
 155
 156   llist_destroy (list);
 157   list = NULL;
 158 } /* }}} void cx_list_free */
 159
 160 static void cx_free (void *arg) /* {{{ */
 161 {
 162   cx_t *db;
 163
 164   DEBUG ("curl_xml plugin: cx_free (arg = %p);", arg);
 165
 166   db = (cx_t *) arg;
 167
 168   if (db == NULL)
 169     return;
 170
 171   if (db->curl != NULL)
 172     curl_easy_cleanup (db->curl);
 173   db->curl = NULL;
 174
 175   if (db->list != NULL)
 176     cx_list_free (db->list);
 177
 178   sfree (db->buffer);
 179   sfree (db->instance);
 180   sfree (db->host);
 181
 182   sfree (db->url);
 183   sfree (db->user);
 184   sfree (db->pass);
 185   sfree (db->credentials);
 186   sfree (db->cacert);
 187
 188   sfree (db);
 189 } /* }}} void cx_free */
 190
 191 static int cx_check_type (const data_set_t *ds, cx_xpath_t *xpath) /* {{{ */
 192 {
 193   if (!ds)
 194   {
 195     WARNING ("curl_xml plugin: DataSet `%s' not defined.", xpath->type);
 196     return (-1);
 197   }
 198
 199   if (ds->ds_num != xpath->values_len)
 200   {
 201     WARNING ("curl_xml plugin: DataSet `%s' requires %i values, but config talks about %i",
 202         xpath->type, ds->ds_num, xpath->values_len);
 203     return (-1);
 204   }
 205
 206   return (0);
 207 } /* }}} cx_check_type */
 208
 209 static xmlXPathObjectPtr cx_evaluate_xpath (xmlXPathContextPtr xpath_ctx, /* {{{ */
 210            xmlChar *expr)
 211 {
 212   xmlXPathObjectPtr xpath_obj;
 213
 214   /* XXX: When to free this? */
 215   xpath_obj = xmlXPathEvalExpression(BAD_CAST expr, xpath_ctx);
 216   if (xpath_obj == NULL)
 217   {
 218      WARNING ("curl_xml plugin: "
 219                "Error unable to evaluate xpath expression \"%s\". Skipping...", expr);
 220      return NULL;
 221   }
 222
 223   return xpath_obj;
 224 } /* }}} cx_evaluate_xpath */
 225
 226 static int cx_if_not_text_node (xmlNodePtr node) /* {{{ */
 227 {
 228   if (node->type == XML_TEXT_NODE || node->type == XML_ATTRIBUTE_NODE)
 229     return (0);
 230
 231   WARNING ("curl_xml plugin: "
 232            "Node \"%s\" doesn't seem to be a text node. Skipping...", node->name);
 233   return -1;
 234 } /* }}} cx_if_not_text_node */
 235
 236 static int cx_handle_single_value_xpath (xmlXPathContextPtr xpath_ctx, /* {{{ */
 237     cx_xpath_t *xpath,
 238     const data_set_t *ds, value_list_t *vl, int index)
 239 {
 240   xmlXPathObjectPtr values_node_obj;
 241   xmlNodeSetPtr values_node;
 242   int tmp_size;
 243   char *node_value;
 244
 245   values_node_obj = cx_evaluate_xpath (xpath_ctx, BAD_CAST xpath->values[index].path);
 246   if (values_node_obj == NULL)
 247     return (-1); /* Error already logged. */
 248
 249   values_node = values_node_obj->nodesetval;
 250   tmp_size = (values_node) ? values_node->nodeNr : 0;
 251
 252   if (tmp_size == 0)
 253   {
 254     WARNING ("curl_xml plugin: "
 255         "relative xpath expression \"%s\" doesn't match any of the nodes. "
 256         "Skipping...", xpath->values[index].path);
 257     xmlXPathFreeObject (values_node_obj);
 258     return (-1);
 259   }
 260
 261   if (tmp_size > 1)
 262   {
 263     WARNING ("curl_xml plugin: "
 264         "relative xpath expression \"%s\" is expected to return "
 265         "only one node. Skipping...", xpath->values[index].path);
 266     xmlXPathFreeObject (values_node_obj);
 267     return (-1);
 268   }
 269
 270   /* ignoring the element if other than textnode/attribute*/
 271   if (cx_if_not_text_node(values_node->nodeTab[0]))
 272   {
 273     WARNING ("curl_xml plugin: "
 274         "relative xpath expression \"%s\" is expected to return "
 275         "only text/attribute node which is not the case. Skipping...",
 276         xpath->values[index].path);
 277     xmlXPathFreeObject (values_node_obj);
 278     return (-1);
 279   }
 280
 281   node_value = (char *) xmlNodeGetContent(values_node->nodeTab[0]);
 282   switch (ds->ds[index].type)
 283   {
 284     case DS_TYPE_COUNTER:
 285       vl->values[index].counter = (counter_t) strtoull (node_value,
 286           /* endptr = */ NULL, /* base = */ 0);
 287       break;
 288     case DS_TYPE_DERIVE:
 289       vl->values[index].derive = (derive_t) strtoll (node_value,
 290           /* endptr = */ NULL, /* base = */ 0);
 291       break;
 292     case DS_TYPE_ABSOLUTE:
 293       vl->values[index].absolute = (absolute_t) strtoull (node_value,
 294           /* endptr = */ NULL, /* base = */ 0);
 295       break;
 296     case DS_TYPE_GAUGE:
 297       vl->values[index].gauge = (gauge_t) strtod (node_value,
 298           /* endptr = */ NULL);
 299   }
 300
 301   /* free up object */
 302   xmlXPathFreeObject (values_node_obj);
 303
 304   /* We have reached here which means that
 305    * we have got something to work */
 306   return (0);
 307 } /* }}} int cx_handle_single_value_xpath */
 308
 309 static int cx_handle_all_value_xpaths (xmlXPathContextPtr xpath_ctx, /* {{{ */
 310     cx_xpath_t *xpath,
 311     const data_set_t *ds, value_list_t *vl)
 312 {
 313   value_t values[xpath->values_len];
 314   int status;
 315   int i;
 316
 317   assert (xpath->values_len > 0);
 318   assert (xpath->values_len == vl->values_len);
 319   assert (xpath->values_len == ds->ds_num);
 320   vl->values = values;
 321
 322   for (i = 0; i < xpath->values_len; i++)
 323   {
 324     status = cx_handle_single_value_xpath (xpath_ctx, xpath, ds, vl, i);
 325     if (status != 0)
 326       return (-1); /* An error has been printed. */
 327   } /* for (i = 0; i < xpath->values_len; i++) */
 328
 329   plugin_dispatch_values (vl);
 330   vl->values = NULL;
 331
 332   return (0);
 333 } /* }}} int cx_handle_all_value_xpaths */
 334
 335 static int cx_handle_instance_xpath (xmlXPathContextPtr xpath_ctx, /* {{{ */
 336     cx_xpath_t *xpath, value_list_t *vl,
 337     _Bool is_table)
 338 {
 339   xmlXPathObjectPtr instance_node_obj = NULL;
 340   xmlNodeSetPtr instance_node = NULL;
 341
 342   memset (vl->type_instance, 0, sizeof (vl->type_instance));
 343
 344   /* If the base xpath returns more than one block, the result is assumed to be
 345    * a table. The `Instnce' option is not optional in this case. Check for the
 346    * condition and inform the user. */
 347   if (is_table && (xpath->instance == NULL))
 348   {
 349     WARNING ("curl_xml plugin: "
 350         "Base-XPath %s is a table (more than one result was returned), "
 351         "but no instance-XPath has been defined.",
 352         xpath->path);
 353     return (-1);
 354   }
 355
 356   /* instance has to be an xpath expression */
 357   if (xpath->instance != NULL)
 358   {
 359     int tmp_size;
 360
 361     instance_node_obj = cx_evaluate_xpath (xpath_ctx, BAD_CAST xpath->instance);
 362     if (instance_node_obj == NULL)
 363       return (-1); /* error is logged already */
 364
 365     instance_node = instance_node_obj->nodesetval;
 366     tmp_size = (instance_node) ? instance_node->nodeNr : 0;
 367
 368     if (tmp_size <= 0)
 369     {
 370       WARNING ("curl_xml plugin: "
 371           "relative xpath expression for 'InstanceFrom' \"%s\" doesn't match "
 372           "any of the nodes. Skipping the node.", xpath->instance);
 373       xmlXPathFreeObject (instance_node_obj);
 374       return (-1);
 375     }
 376
 377     if (tmp_size > 1)
 378     {
 379       WARNING ("curl_xml plugin: "
 380           "relative xpath expression for 'InstanceFrom' \"%s\" is expected "
 381           "to return only one text node. Skipping the node.", xpath->instance);
 382       xmlXPathFreeObject (instance_node_obj);
 383       return (-1);
 384     }
 385
 386     /* ignoring the element if other than textnode/attribute */
 387     if (cx_if_not_text_node(instance_node->nodeTab[0]))
 388     {
 389       WARNING ("curl_xml plugin: "
 390           "relative xpath expression \"%s\" is expected to return only text node "
 391           "which is not the case. Skipping the node.", xpath->instance);
 392       xmlXPathFreeObject (instance_node_obj);
 393       return (-1);
 394     }
 395   } /* if (xpath->instance != NULL) */
 396
 397   if (xpath->instance_prefix != NULL)
 398   {
 399     if (instance_node != NULL)
 400       ssnprintf (vl->type_instance, sizeof (vl->type_instance),"%s%s",
 401           xpath->instance_prefix, (char *) xmlNodeGetContent(instance_node->nodeTab[0]));
 402     else
 403       sstrncpy (vl->type_instance, xpath->instance_prefix,
 404           sizeof (vl->type_instance));
 405   }
 406   else
 407   {
 408     /* If instance_prefix and instance_node are NULL, then
 409      * don't set the type_instance */
 410     if (instance_node != NULL)
 411       sstrncpy (vl->type_instance, (char *) xmlNodeGetContent(instance_node->nodeTab[0]),
 412           sizeof (vl->type_instance));
 413   }
 414
 415   /* Free `instance_node_obj' this late, because `instance_node' points to
 416    * somewhere inside this structure. */
 417   xmlXPathFreeObject (instance_node_obj);
 418
 419   return (0);
 420 } /* }}} int cx_handle_instance_xpath */
 421
 422 static int  cx_handle_base_xpath (char const *plugin_instance, /* {{{ */
 423     char const *host,
 424     xmlXPathContextPtr xpath_ctx, const data_set_t *ds,
 425     char *base_xpath, cx_xpath_t *xpath)
 426 {
 427   int total_nodes;
 428   int i;
 429
 430   xmlXPathObjectPtr base_node_obj = NULL;
 431   xmlNodeSetPtr base_nodes = NULL;
 432
 433   value_list_t vl = VALUE_LIST_INIT;
 434
 435   base_node_obj = cx_evaluate_xpath (xpath_ctx, BAD_CAST base_xpath);
 436   if (base_node_obj == NULL)
 437     return -1; /* error is logged already */
 438
 439   base_nodes = base_node_obj->nodesetval;
 440   total_nodes = (base_nodes) ? base_nodes->nodeNr : 0;
 441
 442   if (total_nodes == 0)
 443   {
 444      ERROR ("curl_xml plugin: "
 445               "xpath expression \"%s\" doesn't match any of the nodes. "
 446               "Skipping the xpath block...", base_xpath);
 447      xmlXPathFreeObject (base_node_obj);
 448      return -1;
 449   }
 450
 451   /* If base_xpath returned multiple results, then */
 452   /* Instance in the xpath block is required */
 453   if (total_nodes > 1 && xpath->instance == NULL)
 454   {
 455     ERROR ("curl_xml plugin: "
 456              "InstanceFrom is must in xpath block since the base xpath expression \"%s\" "
 457              "returned multiple results. Skipping the xpath block...", base_xpath);
 458     return -1;
 459   }
 460
 461   /* set the values for the value_list */
 462   vl.values_len = ds->ds_num;
 463   sstrncpy (vl.type, xpath->type, sizeof (vl.type));
 464   sstrncpy (vl.plugin, "curl_xml", sizeof (vl.plugin));
 465   sstrncpy (vl.host, (host != NULL) ? host : hostname_g, sizeof (vl.host));
 466   if (plugin_instance != NULL)
 467     sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
 468
 469   for (i = 0; i < total_nodes; i++)
 470   {
 471     int status;
 472
 473     xpath_ctx->node = base_nodes->nodeTab[i];
 474
 475     status = cx_handle_instance_xpath (xpath_ctx, xpath, &vl,
 476         /* is_table = */ (total_nodes > 1));
 477     if (status != 0)
 478       continue; /* An error has already been reported. */
 479
 480     status = cx_handle_all_value_xpaths (xpath_ctx, xpath, ds, &vl);
 481     if (status != 0)
 482       continue; /* An error has been logged. */
 483   } /* for (i = 0; i < total_nodes; i++) */
 484
 485   /* free up the allocated memory */
 486   xmlXPathFreeObject (base_node_obj);
 487
 488   return (0);
 489 } /* }}} cx_handle_base_xpath */
 490
 491 static int cx_handle_parsed_xml(xmlDocPtr doc, /* {{{ */
 492                        xmlXPathContextPtr xpath_ctx, cx_t *db)
 493 {
 494   llentry_t *le;
 495   const data_set_t *ds;
 496   cx_xpath_t *xpath;
 497   int status=-1;
 498
 499
 500   le = llist_head (db->list);
 501   while (le != NULL)
 502   {
 503     /* get the ds */
 504     xpath = (cx_xpath_t *) le->value;
 505     ds = plugin_get_ds (xpath->type);
 506
 507     if ( (cx_check_type(ds, xpath) == 0) &&
 508          (cx_handle_base_xpath(db->instance, db->host,
 509                                xpath_ctx, ds, le->key, xpath) == 0) )
 510       status = 0; /* we got atleast one success */
 511
 512     le = le->next;
 513   } /* while (le != NULL) */
 514
 515   return status;
 516 } /* }}} cx_handle_parsed_xml */
 517
 518 static int cx_parse_stats_xml(xmlChar* xml, cx_t *db) /* {{{ */
 519 {
 520   int status;
 521   xmlDocPtr doc;
 522   xmlXPathContextPtr xpath_ctx;
 523
 524   /* Load the XML */
 525   doc = xmlParseDoc(xml);
 526   if (doc == NULL)
 527   {
 528     ERROR ("curl_xml plugin: Failed to parse the xml document  - %s", xml);
 529     return (-1);
 530   }
 531
 532   xpath_ctx = xmlXPathNewContext(doc);
 533   if(xpath_ctx == NULL)
 534   {
 535     ERROR ("curl_xml plugin: Failed to create the xml context");
 536     xmlFreeDoc(doc);
 537     return (-1);
 538   }
 539
 540   status = cx_handle_parsed_xml (doc, xpath_ctx, db);
 541   /* Cleanup */
 542   xmlXPathFreeContext(xpath_ctx);
 543   xmlFreeDoc(doc);
 544   return status;
 545 } /* }}} cx_parse_stats_xml */
 546
 547 static int cx_curl_perform (cx_t *db, CURL *curl) /* {{{ */
 548 {
 549   int status;
 550   long rc;
 551   char *ptr;
 552   char *url;
 553   url = db->url;
 554
 555   db->buffer_fill = 0;
 556   status = curl_easy_perform (curl);
 557   if (status != CURLE_OK)
 558   {
 559     ERROR ("curl_xml plugin: curl_easy_perform failed with status %i: %s (%s)",
 560            status, db->curl_errbuf, url);
 561     return (-1);
 562   }
 563
 564   curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
 565   curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &rc);
 566
 567   /* The response code is zero if a non-HTTP transport was used. */
 568   if ((rc != 0) && (rc != 200))
 569   {
 570     ERROR ("curl_xml plugin: curl_easy_perform failed with response code %ld (%s)",
 571            rc, url);
 572     return (-1);
 573   }
 574
 575   ptr = db->buffer;
 576
 577   status = cx_parse_stats_xml(BAD_CAST ptr, db);
 578   db->buffer_fill = 0;
 579
 580   return status;
 581 } /* }}} int cx_curl_perform */
 582
 583 static int cx_read (user_data_t *ud) /* {{{ */
 584 {
 585   cx_t *db;
 586
 587   if ((ud == NULL) || (ud->data == NULL))
 588   {
 589     ERROR ("curl_xml plugin: cx_read: Invalid user data.");
 590     return (-1);
 591   }
 592
 593   db = (cx_t *) ud->data;
 594
 595   return cx_curl_perform (db, db->curl);
 596 } /* }}} int cx_read */
 597
 598 /* Configuration handling functions {{{ */
 599
 600 static int cx_config_add_values (const char *name, cx_xpath_t *xpath, /* {{{ */
 601                                       oconfig_item_t *ci)
 602 {
 603   int i;
 604
 605   if (ci->values_num < 1)
 606   {
 607     WARNING ("curl_xml plugin: `ValuesFrom' needs at least one argument.");
 608     return (-1);
 609   }
 610
 611   for (i = 0; i < ci->values_num; i++)
 612     if (ci->values[i].type != OCONFIG_TYPE_STRING)
 613     {
 614       WARNING ("curl_xml plugin: `ValuesFrom' needs only string argument.");
 615       return (-1);
 616     }
 617
 618   sfree (xpath->values);
 619
 620   xpath->values_len = 0;
 621   xpath->values = (cx_values_t *) malloc (sizeof (cx_values_t) * ci->values_num);
 622   if (xpath->values == NULL)
 623     return (-1);
 624   xpath->values_len = ci->values_num;
 625
 626   /* populate cx_values_t structure */
 627   for (i = 0; i < ci->values_num; i++)
 628   {
 629     xpath->values[i].path_len = sizeof (ci->values[i].value.string);
 630     sstrncpy (xpath->values[i].path, ci->values[i].value.string, sizeof (xpath->values[i].path));
 631   }
 632
 633   return (0);
 634 } /* }}} cx_config_add_values */
 635
 636 static int cx_config_add_xpath (cx_t *db, /* {{{ */
 637                                    oconfig_item_t *ci)
 638 {
 639   cx_xpath_t *xpath;
 640   int status;
 641   int i;
 642
 643   xpath = (cx_xpath_t *) malloc (sizeof (*xpath));
 644   if (xpath == NULL)
 645   {
 646     ERROR ("curl_xml plugin: malloc failed.");
 647     return (-1);
 648   }
 649   memset (xpath, 0, sizeof (*xpath));
 650
 651   status = cf_util_get_string (ci, &xpath->path);
 652   if (status != 0)
 653   {
 654     sfree (xpath);
 655     return (status);
 656   }
 657
 658   /* error out if xpath->path is an empty string */
 659   if (*xpath->path == 0)
 660   {
 661     ERROR ("curl_xml plugin: invalid xpath. "
 662            "xpath value can't be an empty string");
 663     return (-1);
 664   }
 665
 666   status = 0;
 667   for (i = 0; i < ci->children_num; i++)
 668   {
 669     oconfig_item_t *child = ci->children + i;
 670
 671     if (strcasecmp ("Type", child->key) == 0)
 672       status = cf_util_get_string (child, &xpath->type);
 673     else if (strcasecmp ("InstancePrefix", child->key) == 0)
 674       status = cf_util_get_string (child, &xpath->instance_prefix);
 675     else if (strcasecmp ("InstanceFrom", child->key) == 0)
 676       status = cf_util_get_string (child, &xpath->instance);
 677     else if (strcasecmp ("ValuesFrom", child->key) == 0)
 678       status = cx_config_add_values ("ValuesFrom", xpath, child);
 679     else
 680     {
 681       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 682       status = -1;
 683     }
 684
 685     if (status != 0)
 686       break;
 687   } /* for (i = 0; i < ci->children_num; i++) */
 688
 689   if (status == 0 && xpath->type == NULL)
 690   {
 691     WARNING ("curl_xml plugin: `Type' missing in `xpath' block.");
 692     status = -1;
 693   }
 694
 695   if (status == 0)
 696   {
 697     char *name;
 698     llentry_t *le;
 699
 700     if (db->list == NULL)
 701     {
 702       db->list = llist_create();
 703       if (db->list == NULL)
 704       {
 705         ERROR ("curl_xml plugin: list creation failed.");
 706         return (-1);
 707       }
 708     }
 709
 710     name = strdup(xpath->path);
 711     if (name == NULL)
 712     {
 713         ERROR ("curl_xml plugin: strdup failed.");
 714         return (-1);
 715     }
 716
 717     le = llentry_create (name, xpath);
 718     if (le == NULL)
 719     {
 720       ERROR ("curl_xml plugin: llentry_create failed.");
 721       return (-1);
 722     }
 723
 724     llist_append (db->list, le);
 725   }
 726
 727   return (status);
 728 } /* }}} int cx_config_add_xpath */
 729
 730 /* Initialize db->curl */
 731 static int cx_init_curl (cx_t *db) /* {{{ */
 732 {
 733   db->curl = curl_easy_init ();
 734   if (db->curl == NULL)
 735   {
 736     ERROR ("curl_xml plugin: curl_easy_init failed.");
 737     return (-1);
 738   }
 739
 740   curl_easy_setopt (db->curl, CURLOPT_NOSIGNAL, 1L);
 741   curl_easy_setopt (db->curl, CURLOPT_WRITEFUNCTION, cx_curl_callback);
 742   curl_easy_setopt (db->curl, CURLOPT_WRITEDATA, db);
 743   curl_easy_setopt (db->curl, CURLOPT_USERAGENT,
 744                     PACKAGE_NAME"/"PACKAGE_VERSION);
 745   curl_easy_setopt (db->curl, CURLOPT_ERRORBUFFER, db->curl_errbuf);
 746   curl_easy_setopt (db->curl, CURLOPT_URL, db->url);
 747
 748   if (db->user != NULL)
 749   {
 750     size_t credentials_size;
 751
 752     credentials_size = strlen (db->user) + 2;
 753     if (db->pass != NULL)
 754       credentials_size += strlen (db->pass);
 755
 756     db->credentials = (char *) malloc (credentials_size);
 757     if (db->credentials == NULL)
 758     {
 759       ERROR ("curl_xml plugin: malloc failed.");
 760       return (-1);
 761     }
 762
 763     ssnprintf (db->credentials, credentials_size, "%s:%s",
 764                db->user, (db->pass == NULL) ? "" : db->pass);
 765     curl_easy_setopt (db->curl, CURLOPT_USERPWD, db->credentials);
 766   }
 767
 768   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYPEER, db->verify_peer ? 1L : 0L);
 769   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYHOST,
 770                     db->verify_host ? 2L : 0L);
 771   if (db->cacert != NULL)
 772     curl_easy_setopt (db->curl, CURLOPT_CAINFO, db->cacert);
 773
 774   return (0);
 775 } /* }}} int cx_init_curl */
 776
 777 static int cx_config_add_url (oconfig_item_t *ci) /* {{{ */
 778 {
 779   cx_t *db;
 780   int status = 0;
 781   int i;
 782
 783   if ((ci->values_num != 1)
 784       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 785   {
 786     WARNING ("curl_xml plugin: The `URL' block "
 787              "needs exactly one string argument.");
 788     return (-1);
 789   }
 790
 791   db = (cx_t *) malloc (sizeof (*db));
 792   if (db == NULL)
 793   {
 794     ERROR ("curl_xml plugin: malloc failed.");
 795     return (-1);
 796   }
 797   memset (db, 0, sizeof (*db));
 798
 799   if (strcasecmp ("URL", ci->key) == 0)
 800   {
 801     status = cf_util_get_string (ci, &db->url);
 802     if (status != 0)
 803     {
 804       sfree (db);
 805       return (status);
 806     }
 807   }
 808   else
 809   {
 810     ERROR ("curl_xml plugin: cx_config: "
 811            "Invalid key: %s", ci->key);
 812     return (-1);
 813   }
 814
 815   /* Fill the `cx_t' structure.. */
 816   for (i = 0; i < ci->children_num; i++)
 817   {
 818     oconfig_item_t *child = ci->children + i;
 819
 820     if (strcasecmp ("Instance", child->key) == 0)
 821       status = cf_util_get_string (child, &db->instance);
 822     else if (strcasecmp ("Host", child->key) == 0)
 823       status = cf_util_get_string (child, &db->host);
 824     else if (strcasecmp ("User", child->key) == 0)
 825       status = cf_util_get_string (child, &db->user);
 826     else if (strcasecmp ("Password", child->key) == 0)
 827       status = cf_util_get_string (child, &db->pass);
 828     else if (strcasecmp ("VerifyPeer", child->key) == 0)
 829       status = cf_util_get_boolean (child, &db->verify_peer);
 830     else if (strcasecmp ("VerifyHost", child->key) == 0)
 831       status = cf_util_get_boolean (child, &db->verify_host);
 832     else if (strcasecmp ("CACert", child->key) == 0)
 833       status = cf_util_get_string (child, &db->cacert);
 834     else if (strcasecmp ("xpath", child->key) == 0)
 835       status = cx_config_add_xpath (db, child);
 836     else
 837     {
 838       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 839       status = -1;
 840     }
 841
 842     if (status != 0)
 843       break;
 844   }
 845
 846   if (status == 0)
 847   {
 848     if (db->list == NULL)
 849     {
 850       WARNING ("curl_xml plugin: No (valid) `Key' block "
 851                "within `URL' block `%s'.", db->url);
 852       status = -1;
 853     }
 854     if (status == 0)
 855       status = cx_init_curl (db);
 856   }
 857
 858   /* If all went well, register this database for reading */
 859   if (status == 0)
 860   {
 861     user_data_t ud;
 862     char cb_name[DATA_MAX_NAME_LEN];
 863
 864     if (db->instance == NULL)
 865       db->instance = strdup("default");
 866
 867     DEBUG ("curl_xml plugin: Registering new read callback: %s",
 868            db->instance);
 869
 870     memset (&ud, 0, sizeof (ud));
 871     ud.data = (void *) db;
 872     ud.free_func = cx_free;
 873
 874     ssnprintf (cb_name, sizeof (cb_name), "curl_xml-%s-%s",
 875                db->instance, db->url);
 876
 877     plugin_register_complex_read (/* group = */ NULL, cb_name, cx_read,
 878                                   /* interval = */ NULL, &ud);
 879   }
 880   else
 881   {
 882     cx_free (db);
 883     return (-1);
 884   }
 885
 886   return (0);
 887 } /* }}} int cx_config_add_url */
 888
 889 /* }}} End of configuration handling functions */
 890
 891 static int cx_config (oconfig_item_t *ci) /* {{{ */
 892 {
 893   int success;
 894   int errors;
 895   int status;
 896   int i;
 897
 898   success = 0;
 899   errors = 0;
 900
 901   for (i = 0; i < ci->children_num; i++)
 902   {
 903     oconfig_item_t *child = ci->children + i;
 904
 905     if (strcasecmp ("URL", child->key) == 0)
 906     {
 907       status = cx_config_add_url (child);
 908       if (status == 0)
 909         success++;
 910       else
 911         errors++;
 912     }
 913     else
 914     {
 915       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 916       errors++;
 917     }
 918   }
 919
 920   if ((success == 0) && (errors > 0))
 921   {
 922     ERROR ("curl_xml plugin: All statements failed.");
 923     return (-1);
 924   }
 925
 926   return (0);
 927 } /* }}} int cx_config */
 928
 929 static int cx_init (void) /* {{{ */
 930 {
 931   /* Call this while collectd is still single-threaded to avoid
 932    * initialization issues in libgcrypt. */
 933   curl_global_init (CURL_GLOBAL_SSL);
 934   return (0);
 935 } /* }}} int cx_init */
 936
 937 void module_register (void)
 938 {
 939   plugin_register_complex_config ("curl_xml", cx_config);
 940   plugin_register_init ("curl_xml", cx_init);
 941 } /* void module_register */
 942
 943 /* vim: set sw=2 sts=2 et fdm=marker : */