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 && (vl->type_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
 554   db->buffer_fill = 0;
 555   status = curl_easy_perform (curl);
 556   if (status != CURLE_OK)
 557   {
 558     ERROR ("curl_xml plugin: curl_easy_perform failed with status %i: %s",
 559            status, db->curl_errbuf);
 560     return (-1);
 561   }
 562
 563   curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
 564   curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &rc);
 565
 566   /* The response code is zero if a non-HTTP transport was used. */
 567   if ((rc != 0) && (rc != 200))
 568   {
 569     ERROR ("curl_xml plugin: curl_easy_perform failed with response code %ld (%s)",
 570            rc, url);
 571     return (-1);
 572   }
 573
 574   ptr = db->buffer;
 575
 576   status = cx_parse_stats_xml(BAD_CAST ptr, db);
 577   db->buffer_fill = 0;
 578
 579   return status;
 580 } /* }}} int cx_curl_perform */
 581
 582 static int cx_read (user_data_t *ud) /* {{{ */
 583 {
 584   cx_t *db;
 585
 586   if ((ud == NULL) || (ud->data == NULL))
 587   {
 588     ERROR ("curl_xml plugin: cx_read: Invalid user data.");
 589     return (-1);
 590   }
 591
 592   db = (cx_t *) ud->data;
 593
 594   return cx_curl_perform (db, db->curl);
 595 } /* }}} int cx_read */
 596
 597 /* Configuration handling functions {{{ */
 598
 599 static int cx_config_add_values (const char *name, cx_xpath_t *xpath, /* {{{ */
 600                                       oconfig_item_t *ci)
 601 {
 602   int i;
 603
 604   if (ci->values_num < 1)
 605   {
 606     WARNING ("curl_xml plugin: `ValuesFrom' needs at least one argument.");
 607     return (-1);
 608   }
 609
 610   for (i = 0; i < ci->values_num; i++)
 611     if (ci->values[i].type != OCONFIG_TYPE_STRING)
 612     {
 613       WARNING ("curl_xml plugin: `ValuesFrom' needs only string argument.");
 614       return (-1);
 615     }
 616
 617   sfree (xpath->values);
 618
 619   xpath->values_len = 0;
 620   xpath->values = (cx_values_t *) malloc (sizeof (cx_values_t) * ci->values_num);
 621   if (xpath->values == NULL)
 622     return (-1);
 623   xpath->values_len = ci->values_num;
 624
 625   /* populate cx_values_t structure */
 626   for (i = 0; i < ci->values_num; i++)
 627   {
 628     xpath->values[i].path_len = sizeof (ci->values[i].value.string);
 629     sstrncpy (xpath->values[i].path, ci->values[i].value.string, sizeof (xpath->values[i].path));
 630   }
 631
 632   return (0);
 633 } /* }}} cx_config_add_values */
 634
 635 static int cx_config_add_xpath (cx_t *db, /* {{{ */
 636                                    oconfig_item_t *ci)
 637 {
 638   cx_xpath_t *xpath;
 639   int status;
 640   int i;
 641
 642   xpath = (cx_xpath_t *) malloc (sizeof (*xpath));
 643   if (xpath == NULL)
 644   {
 645     ERROR ("curl_xml plugin: malloc failed.");
 646     return (-1);
 647   }
 648   memset (xpath, 0, sizeof (*xpath));
 649
 650   status = cf_util_get_string (ci, &xpath->path);
 651   if (status != 0)
 652   {
 653     sfree (xpath);
 654     return (status);
 655   }
 656
 657   /* error out if xpath->path is an empty string */
 658   if (*xpath->path == 0)
 659   {
 660     ERROR ("curl_xml plugin: invalid xpath. "
 661            "xpath value can't be an empty string");
 662     return (-1);
 663   }
 664
 665   status = 0;
 666   for (i = 0; i < ci->children_num; i++)
 667   {
 668     oconfig_item_t *child = ci->children + i;
 669
 670     if (strcasecmp ("Type", child->key) == 0)
 671       status = cf_util_get_string (child, &xpath->type);
 672     else if (strcasecmp ("InstancePrefix", child->key) == 0)
 673       status = cf_util_get_string (child, &xpath->instance_prefix);
 674     else if (strcasecmp ("InstanceFrom", child->key) == 0)
 675       status = cf_util_get_string (child, &xpath->instance);
 676     else if (strcasecmp ("ValuesFrom", child->key) == 0)
 677       status = cx_config_add_values ("ValuesFrom", xpath, child);
 678     else
 679     {
 680       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 681       status = -1;
 682     }
 683
 684     if (status != 0)
 685       break;
 686   } /* for (i = 0; i < ci->children_num; i++) */
 687
 688   if (status == 0 && xpath->type == NULL)
 689   {
 690     WARNING ("curl_xml plugin: `Type' missing in `xpath' block.");
 691     status = -1;
 692   }
 693
 694   if (status == 0)
 695   {
 696     char *name;
 697     llentry_t *le;
 698
 699     if (db->list == NULL)
 700     {
 701       db->list = llist_create();
 702       if (db->list == NULL)
 703       {
 704         ERROR ("curl_xml plugin: list creation failed.");
 705         return (-1);
 706       }
 707     }
 708
 709     name = strdup(xpath->path);
 710     if (name == NULL)
 711     {
 712         ERROR ("curl_xml plugin: strdup failed.");
 713         return (-1);
 714     }
 715
 716     le = llentry_create (name, xpath);
 717     if (le == NULL)
 718     {
 719       ERROR ("curl_xml plugin: llentry_create failed.");
 720       return (-1);
 721     }
 722
 723     llist_append (db->list, le);
 724   }
 725
 726   return (status);
 727 } /* }}} int cx_config_add_xpath */
 728
 729 /* Initialize db->curl */
 730 static int cx_init_curl (cx_t *db) /* {{{ */
 731 {
 732   db->curl = curl_easy_init ();
 733   if (db->curl == NULL)
 734   {
 735     ERROR ("curl_xml plugin: curl_easy_init failed.");
 736     return (-1);
 737   }
 738
 739   curl_easy_setopt (db->curl, CURLOPT_NOSIGNAL, 1L);
 740   curl_easy_setopt (db->curl, CURLOPT_WRITEFUNCTION, cx_curl_callback);
 741   curl_easy_setopt (db->curl, CURLOPT_WRITEDATA, db);
 742   curl_easy_setopt (db->curl, CURLOPT_USERAGENT,
 743                     PACKAGE_NAME"/"PACKAGE_VERSION);
 744   curl_easy_setopt (db->curl, CURLOPT_ERRORBUFFER, db->curl_errbuf);
 745   curl_easy_setopt (db->curl, CURLOPT_URL, db->url);
 746
 747   if (db->user != NULL)
 748   {
 749     size_t credentials_size;
 750
 751     credentials_size = strlen (db->user) + 2;
 752     if (db->pass != NULL)
 753       credentials_size += strlen (db->pass);
 754
 755     db->credentials = (char *) malloc (credentials_size);
 756     if (db->credentials == NULL)
 757     {
 758       ERROR ("curl_xml plugin: malloc failed.");
 759       return (-1);
 760     }
 761
 762     ssnprintf (db->credentials, credentials_size, "%s:%s",
 763                db->user, (db->pass == NULL) ? "" : db->pass);
 764     curl_easy_setopt (db->curl, CURLOPT_USERPWD, db->credentials);
 765   }
 766
 767   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYPEER, db->verify_peer ? 1L : 0L);
 768   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYHOST,
 769                     db->verify_host ? 2L : 0L);
 770   if (db->cacert != NULL)
 771     curl_easy_setopt (db->curl, CURLOPT_CAINFO, db->cacert);
 772
 773   return (0);
 774 } /* }}} int cx_init_curl */
 775
 776 static int cx_config_add_url (oconfig_item_t *ci) /* {{{ */
 777 {
 778   cx_t *db;
 779   int status = 0;
 780   int i;
 781
 782   if ((ci->values_num != 1)
 783       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 784   {
 785     WARNING ("curl_xml plugin: The `URL' block "
 786              "needs exactly one string argument.");
 787     return (-1);
 788   }
 789
 790   db = (cx_t *) malloc (sizeof (*db));
 791   if (db == NULL)
 792   {
 793     ERROR ("curl_xml plugin: malloc failed.");
 794     return (-1);
 795   }
 796   memset (db, 0, sizeof (*db));
 797
 798   if (strcasecmp ("URL", ci->key) == 0)
 799   {
 800     status = cf_util_get_string (ci, &db->url);
 801     if (status != 0)
 802     {
 803       sfree (db);
 804       return (status);
 805     }
 806   }
 807   else
 808   {
 809     ERROR ("curl_xml plugin: cx_config: "
 810            "Invalid key: %s", ci->key);
 811     return (-1);
 812   }
 813
 814   /* Fill the `cx_t' structure.. */
 815   for (i = 0; i < ci->children_num; i++)
 816   {
 817     oconfig_item_t *child = ci->children + i;
 818
 819     if (strcasecmp ("Instance", child->key) == 0)
 820       status = cf_util_get_string (child, &db->instance);
 821     else if (strcasecmp ("Host", child->key) == 0)
 822       status = cf_util_get_string (child, &db->host);
 823     else if (strcasecmp ("User", child->key) == 0)
 824       status = cf_util_get_string (child, &db->user);
 825     else if (strcasecmp ("Password", child->key) == 0)
 826       status = cf_util_get_string (child, &db->pass);
 827     else if (strcasecmp ("VerifyPeer", child->key) == 0)
 828       status = cf_util_get_boolean (child, &db->verify_peer);
 829     else if (strcasecmp ("VerifyHost", child->key) == 0)
 830       status = cf_util_get_boolean (child, &db->verify_host);
 831     else if (strcasecmp ("CACert", child->key) == 0)
 832       status = cf_util_get_string (child, &db->cacert);
 833     else if (strcasecmp ("xpath", child->key) == 0)
 834       status = cx_config_add_xpath (db, child);
 835     else
 836     {
 837       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 838       status = -1;
 839     }
 840
 841     if (status != 0)
 842       break;
 843   }
 844
 845   if (status == 0)
 846   {
 847     if (db->list == NULL)
 848     {
 849       WARNING ("curl_xml plugin: No (valid) `Key' block "
 850                "within `URL' block `%s'.", db->url);
 851       status = -1;
 852     }
 853     if (status == 0)
 854       status = cx_init_curl (db);
 855   }
 856
 857   /* If all went well, register this database for reading */
 858   if (status == 0)
 859   {
 860     user_data_t ud;
 861     char cb_name[DATA_MAX_NAME_LEN];
 862
 863     if (db->instance == NULL)
 864       db->instance = strdup("default");
 865
 866     DEBUG ("curl_xml plugin: Registering new read callback: %s",
 867            db->instance);
 868
 869     memset (&ud, 0, sizeof (ud));
 870     ud.data = (void *) db;
 871     ud.free_func = cx_free;
 872
 873     ssnprintf (cb_name, sizeof (cb_name), "curl_xml-%s-%s",
 874                db->instance, db->url);
 875
 876     plugin_register_complex_read (/* group = */ NULL, cb_name, cx_read,
 877                                   /* interval = */ NULL, &ud);
 878   }
 879   else
 880   {
 881     cx_free (db);
 882     return (-1);
 883   }
 884
 885   return (0);
 886 } /* }}} int cx_config_add_url */
 887
 888 /* }}} End of configuration handling functions */
 889
 890 static int cx_config (oconfig_item_t *ci) /* {{{ */
 891 {
 892   int success;
 893   int errors;
 894   int status;
 895   int i;
 896
 897   success = 0;
 898   errors = 0;
 899
 900   for (i = 0; i < ci->children_num; i++)
 901   {
 902     oconfig_item_t *child = ci->children + i;
 903
 904     if (strcasecmp ("URL", child->key) == 0)
 905     {
 906       status = cx_config_add_url (child);
 907       if (status == 0)
 908         success++;
 909       else
 910         errors++;
 911     }
 912     else
 913     {
 914       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 915       errors++;
 916     }
 917   }
 918
 919   if ((success == 0) && (errors > 0))
 920   {
 921     ERROR ("curl_xml plugin: All statements failed.");
 922     return (-1);
 923   }
 924
 925   return (0);
 926 } /* }}} int cx_config */
 927
 928 void module_register (void)
 929 {
 930   plugin_register_complex_config ("curl_xml", cx_config);
 931 } /* void module_register */
 932
 933 /* vim: set sw=2 sts=2 et fdm=marker : */