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