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   xmlXPathObjectPtr values_node_obj = NULL;
 255   xmlNodeSetPtr base_nodes = NULL;
 256   xmlNodeSetPtr instance_node = NULL;
 257   xmlNodeSetPtr values_node = NULL;
 258
 259   value_list_t vl = VALUE_LIST_INIT;
 260   const data_set_t *ds;
 261
 262   base_node_obj = cx_evaluate_xpath (xpath_ctx, BAD_CAST base_xpath);
 263   if (base_node_obj == NULL)
 264     return -1; /* error is logged already */
 265
 266   base_nodes = base_node_obj->nodesetval;
 267   total_nodes = (base_nodes) ? base_nodes->nodeNr : 0;
 268
 269   if (total_nodes == 0)
 270   {
 271      ERROR ("curl_xml plugin: "
 272               "xpath expression \"%s\" doesn't match any of the node. Skipping...", base_xpath);
 273      xmlXPathFreeObject (base_node_obj);
 274      return -1;
 275   }
 276
 277   /* If base_xpath returned multiple results, then */
 278   /* Instance in the xpath block is required */
 279   if (total_nodes > 1 && xpath->instance == NULL)
 280   {
 281     ERROR ("curl_xml plugin: "
 282              "Instance is must in xpath block since the base xpath expression \"%s\" "
 283              "returned multiple results. Skipping the xpath block...", base_xpath);
 284     return -1;
 285   }
 286
 287   /* set the values for the value_list */
 288   ds = plugin_get_ds (xpath->type);
 289   vl.values_len = ds->ds_num;
 290   sstrncpy (vl.type, xpath->type, sizeof (vl.type));
 291   sstrncpy (vl.plugin, "curl_xml", sizeof (vl.plugin));
 292   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 293   if (plugin_instance != NULL)
 294     sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
 295
 296   for (i = 0; i < total_nodes; i++)
 297   {
 298      xpath_ctx->node = base_nodes->nodeTab[i];
 299
 300      /* instance has to be an xpath expression */
 301      if (xpath->instance != NULL)
 302      {
 303         instance_node_obj = cx_evaluate_xpath (xpath_ctx, BAD_CAST xpath->instance);
 304         if (instance_node_obj == NULL)
 305           continue; /* error is logged already */
 306
 307         instance_node = instance_node_obj->nodesetval;
 308         tmp_size = (instance_node) ? instance_node->nodeNr : 0;
 309
 310         if ( (tmp_size == 0) && (total_nodes > 1) )
 311         {
 312            WARNING ("curl_xml plugin: "
 313                     "relative xpath expression for 'Instance' \"%s\" doesn't match "
 314                     "any of the nodes. Skipping the node - %s",
 315                     xpath->instance, base_nodes->nodeTab[i]->name);
 316            xmlXPathFreeObject (instance_node_obj);
 317            continue;
 318         }
 319
 320         if (tmp_size > 1)
 321         {
 322           WARNING ("curl_xml plugin: "
 323                    "relative xpath expression for 'Instance' \"%s\" is expected "
 324                    "to return only one text node. Skipping the node - %s",
 325                    xpath->instance, base_nodes->nodeTab[i]->name);
 326           xmlXPathFreeObject (instance_node_obj);
 327           continue;
 328         }
 329
 330         // ignoring the element if other than textnode/attribute
 331         if (cx_if_not_text_node(instance_node->nodeTab[0]))
 332         {
 333           WARNING ("curl_xml plugin: "
 334                    "relative xpath expression \"%s\" is expected to return only text node "
 335                     "which is not the case. Skipping the node - %s",
 336                     xpath->instance, base_nodes->nodeTab[i]->name);
 337           xmlXPathFreeObject (instance_node_obj);
 338           continue;
 339         }
 340      }
 341
 342      for (j = 0; j < xpath->values_len; j++)
 343      {
 344        values_node_obj = cx_evaluate_xpath (xpath_ctx, BAD_CAST xpath->values[j].path);
 345        values_node = values_node_obj->nodesetval;
 346        tmp_size = (values_node) ? values_node->nodeNr : 0;
 347
 348        if (tmp_size == 0)
 349        {
 350          WARNING ("curl_xml plugin: "
 351                 "relative xpath expression \"%s\" doesn't match any of the nodes. "
 352                 "Skipping...", xpath->values[j].path);
 353          xmlXPathFreeObject (values_node_obj);
 354          continue;
 355        }
 356
 357        if (tmp_size > 1)
 358        {
 359          WARNING ("curl_xml plugin: "
 360                   "relative xpath expression \"%s\" is expected to return "
 361                   "only one node. Skipping...", xpath->values[j].path);
 362          xmlXPathFreeObject (values_node_obj);
 363          continue;
 364        }
 365
 366        /* ignoring the element if other than textnode/attribute*/
 367        if (cx_if_not_text_node(values_node->nodeTab[0]))
 368        {
 369          WARNING ("curl_xml plugin: "
 370                   "relative xpath expression \"%s\" is expected to return "
 371                   "only text/attribute node which is not the case. Skipping...",
 372                   xpath->values[j].path);
 373          xmlXPathFreeObject (values_node_obj);
 374          continue;
 375        }
 376
 377        vl.values = (value_t *) malloc (sizeof (value_t) * vl.values_len);
 378        if (vl.values == NULL)
 379        {
 380          ERROR ("curl_xml plugin: malloc failed.");
 381          xmlXPathFreeObject (base_node_obj);
 382          xmlXPathFreeObject (instance_node_obj);
 383          xmlXPathFreeObject (values_node_obj);
 384          return (-1);
 385        }
 386
 387        node_value = (char *) xmlNodeGetContent(values_node->nodeTab[0]);
 388        switch (ds->ds[j].type)
 389        {
 390          case DS_TYPE_COUNTER:
 391            vl.values[j].counter = atoi(node_value);
 392            break;
 393          case DS_TYPE_DERIVE:
 394            vl.values[j].derive = atoi(node_value);
 395            break;
 396          case DS_TYPE_ABSOLUTE:
 397            vl.values[j].absolute = atoi(node_value);
 398            break;
 399          case DS_TYPE_GAUGE:
 400            vl.values[j].absolute = atoi(node_value);
 401        }
 402
 403        if (xpath->instance_prefix != NULL)
 404        {
 405          if (instance_node != NULL)
 406            ssnprintf (vl.type_instance, sizeof (vl.type_instance),"%s-%s",
 407                       xpath->instance_prefix, (char *) xmlNodeGetContent(instance_node->nodeTab[0]));
 408          else
 409            sstrncpy (vl.type_instance, xpath->instance_prefix,
 410                      sizeof (vl.type_instance));
 411        }
 412        else
 413        {
 414          /* If instance_prefix and instance_node are NULL , then */
 415          /* don't set the type_instance */
 416          if (instance_node != NULL)
 417            sstrncpy (vl.type_instance, (char *) xmlNodeGetContent(instance_node->nodeTab[0]),
 418                      sizeof (vl.type_instance));
 419          else
 420            vl.type_instance[0] = 0;
 421        }
 422
 423        /* free up object */
 424        xmlXPathFreeObject (values_node_obj);
 425
 426        /* We have reached here which means that */
 427        /* we have got something to work */
 428        status = 0;
 429      }
 430
 431      /* submit the values */
 432      if (vl.values)
 433        plugin_dispatch_values (&vl);
 434
 435      sfree(vl.values);
 436      if (instance_node_obj != NULL)
 437        xmlXPathFreeObject (instance_node_obj);
 438   }
 439
 440   /* free up the allocated memory */
 441   xmlXPathFreeObject (base_node_obj);
 442
 443   return status;
 444 } /* }}} cx_submit_xpath_values */
 445
 446 static int cx_submit_statistics(xmlDocPtr doc, /* {{{ */
 447                        xmlXPathContextPtr xpath_ctx, cx_t *db)
 448 {
 449   c_avl_iterator_t *iter;
 450   char *key;
 451   cx_xpath_t *value;
 452   int status=-1;
 453
 454   iter = c_avl_get_iterator (db->tree);
 455   while (c_avl_iterator_next (iter, (void *) &key, (void *) &value) == 0)
 456   {
 457     if (cx_check_type(value) == -1)
 458       continue;
 459
 460     if (cx_submit_xpath_values(db->instance, xpath_ctx, key, value) == 0)
 461       status = 0; /* we got atleast one success */
 462   } /* while (c_avl_iterator_next) */
 463
 464   return status;
 465 } /* }}} cx_submit_statistics */
 466
 467 static int cx_parse_stats_xml(xmlChar* xml, cx_t *db) /* {{{ */
 468 {
 469   int status;
 470   xmlDocPtr doc;
 471   xmlXPathContextPtr xpath_ctx;
 472
 473   /* Load the XML */
 474   doc = xmlParseDoc(xml);
 475   if (doc == NULL)
 476   {
 477     ERROR ("curl_xml plugin: Failed to parse the xml document  - %s", xml);
 478     return (-1);
 479   }
 480
 481   xpath_ctx = xmlXPathNewContext(doc);
 482   if(xpath_ctx == NULL)
 483   {
 484     ERROR ("curl_xml plugin: Failed to create the xml context");
 485     xmlFreeDoc(doc);
 486     return (-1);
 487   }
 488
 489   status = cx_submit_statistics (doc, xpath_ctx, db);
 490   /* Cleanup */
 491   xmlXPathFreeContext(xpath_ctx);
 492   xmlFreeDoc(doc);
 493   return status;
 494 } /* }}} cx_parse_stats_xml */
 495
 496 static int cx_curl_perform (cx_t *db, CURL *curl) /* {{{ */
 497 {
 498   int status;
 499   long rc;
 500   char *ptr;
 501   char *url;
 502
 503   db->buffer_fill = 0;
 504   status = curl_easy_perform (curl);
 505
 506   curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
 507   curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &rc);
 508
 509   if (rc != 200)
 510   {
 511     ERROR ("curl_xml plugin: curl_easy_perform failed with response code %ld (%s)",
 512            rc, url);
 513     return (-1);
 514   }
 515
 516   if (status != 0)
 517   {
 518     ERROR ("curl_xml plugin: curl_easy_perform failed with status %i: %s (%s)",
 519            status, db->curl_errbuf, url);
 520     return (-1);
 521   }
 522
 523   ptr = db->buffer;
 524
 525   status = cx_parse_stats_xml(BAD_CAST ptr, db);
 526   db->buffer_fill = 0;
 527
 528   return status;
 529 } /* }}} int cx_curl_perform */
 530
 531 static int cx_read (user_data_t *ud) /* {{{ */
 532 {
 533   cx_t *db;
 534
 535   if ((ud == NULL) || (ud->data == NULL))
 536   {
 537     ERROR ("curl_xml plugin: cx_read: Invalid user data.");
 538     return (-1);
 539   }
 540
 541   db = (cx_t *) ud->data;
 542
 543   return cx_curl_perform (db, db->curl);
 544 } /* }}} int cx_read */
 545
 546 /* Configuration handling functions {{{ */
 547
 548 static int cx_config_add_values (const char *name, cx_xpath_t *xpath, /* {{{ */
 549                                       oconfig_item_t *ci)
 550 {
 551   int i;
 552
 553   if (ci->values_num < 1)
 554   {
 555     WARNING ("curl_xml plugin: `Values' needs at least one argument.");
 556     return (-1);
 557   }
 558
 559   for (i = 0; i < ci->values_num; i++)
 560     if (ci->values[i].type != OCONFIG_TYPE_STRING)
 561     {
 562       WARNING ("curl_xml plugin: `Values' needs only string argument.");
 563       return (-1);
 564     }
 565
 566   sfree (xpath->values);
 567
 568   xpath->values_len = 0;
 569   xpath->values = (cx_values_t *) malloc (sizeof (cx_values_t) * ci->values_num);
 570   if (xpath->values == NULL)
 571     return (-1);
 572   xpath->values_len = ci->values_num;
 573
 574   /* populate cx_values_t structure */
 575   for (i = 0; i < ci->values_num; i++)
 576   {
 577     xpath->values[i].path_len = sizeof (ci->values[i].value.string);
 578     sstrncpy (xpath->values[i].path, ci->values[i].value.string, sizeof (xpath->values[i].path));
 579   }
 580
 581   return (0);
 582 } /* }}} cx_config_add_values */
 583
 584 static c_avl_tree_t *cx_avl_create(void) /* {{{ */
 585 {
 586   return c_avl_create ((int (*) (const void *, const void *)) strcmp);
 587 } /* }}} cx_avl_create */
 588
 589 static int cx_config_add_xpath (cx_t *db, /* {{{ */
 590                                    oconfig_item_t *ci)
 591 {
 592   cx_xpath_t *xpath;
 593   int status;
 594   int i;
 595
 596   if ((ci->values_num != 1)
 597       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 598   {
 599     WARNING ("curl_xml plugin: The `xpath' block "
 600              "needs exactly one string argument.");
 601     return (-1);
 602   }
 603
 604   xpath = (cx_xpath_t *) malloc (sizeof (*xpath));
 605   if (xpath == NULL)
 606   {
 607     ERROR ("curl_xml plugin: malloc failed.");
 608     return (-1);
 609   }
 610   memset (xpath, 0, sizeof (*xpath));
 611   xpath->magic = CX_KEY_MAGIC;
 612
 613   if (strcasecmp ("xpath", ci->key) == 0)
 614   {
 615     status = cf_util_get_string (ci, &xpath->path);
 616     if (status != 0)
 617     {
 618       sfree (xpath);
 619       return (status);
 620     }
 621   }
 622   else
 623   {
 624     ERROR ("curl_xml plugin: cx_config: "
 625            "Invalid key: %s", ci->key);
 626     return (-1);
 627   }
 628
 629   status = 0;
 630   for (i = 0; i < ci->children_num; i++)
 631   {
 632     oconfig_item_t *child = ci->children + i;
 633
 634     if (strcasecmp ("Type", child->key) == 0)
 635       status = cf_util_get_string (child, &xpath->type);
 636     else if (strcasecmp ("InstancePrefix", child->key) == 0)
 637       status = cf_util_get_string (child, &xpath->instance_prefix);
 638     else if (strcasecmp ("Instance", child->key) == 0)
 639       status = cf_util_get_string (child, &xpath->instance);
 640     else if (strcasecmp ("Values", child->key) == 0)
 641       status = cx_config_add_values ("Values", xpath, child);
 642     else
 643     {
 644       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 645       status = -1;
 646     }
 647
 648     if (status != 0)
 649       break;
 650   } /* for (i = 0; i < ci->children_num; i++) */
 651
 652   while (status == 0)
 653   {
 654     if (xpath->type == NULL)
 655     {
 656       WARNING ("curl_xml plugin: `Type' missing in `xpath' block.");
 657       status = -1;
 658     }
 659
 660     break;
 661   } /* while (status == 0) */
 662
 663   if (status == 0)
 664   {
 665     char *name;
 666     c_avl_tree_t *tree;
 667
 668     if (db->tree == NULL)
 669       db->tree = cx_avl_create();
 670
 671     tree = db->tree;
 672     name = xpath->path;
 673
 674     if (*name)
 675       c_avl_insert (tree, strdup(name), xpath);
 676     else
 677     {
 678       ERROR ("curl_xml plugin: invalid key: %s", xpath->path);
 679       status = -1;
 680     }
 681   }
 682
 683   return (status);
 684 } /* }}} int cx_config_add_xpath */
 685
 686 /* Initialize db->curl */
 687 static int cx_init_curl (cx_t *db) /* {{{ */
 688 {
 689   db->curl = curl_easy_init ();
 690   if (db->curl == NULL)
 691   {
 692     ERROR ("curl_xml plugin: curl_easy_init failed.");
 693     return (-1);
 694   }
 695
 696   curl_easy_setopt (db->curl, CURLOPT_WRITEFUNCTION, cx_curl_callback);
 697   curl_easy_setopt (db->curl, CURLOPT_WRITEDATA, db);
 698   curl_easy_setopt (db->curl, CURLOPT_USERAGENT,
 699                     PACKAGE_NAME"/"PACKAGE_VERSION);
 700   curl_easy_setopt (db->curl, CURLOPT_ERRORBUFFER, db->curl_errbuf);
 701   curl_easy_setopt (db->curl, CURLOPT_URL, db->url);
 702
 703   if (db->user != NULL)
 704   {
 705     size_t credentials_size;
 706
 707     credentials_size = strlen (db->user) + 2;
 708     if (db->pass != NULL)
 709       credentials_size += strlen (db->pass);
 710
 711     db->credentials = (char *) malloc (credentials_size);
 712     if (db->credentials == NULL)
 713     {
 714       ERROR ("curl_xml plugin: malloc failed.");
 715       return (-1);
 716     }
 717
 718     ssnprintf (db->credentials, credentials_size, "%s:%s",
 719                db->user, (db->pass == NULL) ? "" : db->pass);
 720     curl_easy_setopt (db->curl, CURLOPT_USERPWD, db->credentials);
 721   }
 722
 723   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYPEER, db->verify_peer);
 724   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYHOST,
 725                     db->verify_host ? 2 : 0);
 726   if (db->cacert != NULL)
 727     curl_easy_setopt (db->curl, CURLOPT_CAINFO, db->cacert);
 728
 729   return (0);
 730 } /* }}} int cx_init_curl */
 731
 732 static int cx_config_add_url (oconfig_item_t *ci) /* {{{ */
 733 {
 734   cx_t *db;
 735   int status = 0;
 736   int i;
 737
 738   if ((ci->values_num != 1)
 739       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 740   {
 741     WARNING ("curl_xml plugin: The `URL' block "
 742              "needs exactly one string argument.");
 743     return (-1);
 744   }
 745
 746   db = (cx_t *) malloc (sizeof (*db));
 747   if (db == NULL)
 748   {
 749     ERROR ("curl_xml plugin: malloc failed.");
 750     return (-1);
 751   }
 752   memset (db, 0, sizeof (*db));
 753
 754   if (strcasecmp ("URL", ci->key) == 0)
 755   {
 756     status = cf_util_get_string (ci, &db->url);
 757     if (status != 0)
 758     {
 759       sfree (db);
 760       return (status);
 761     }
 762   }
 763   else
 764   {
 765     ERROR ("curl_xml plugin: cx_config: "
 766            "Invalid key: %s", ci->key);
 767     return (-1);
 768   }
 769
 770   /* Fill the `cx_t' structure.. */
 771   for (i = 0; i < ci->children_num; i++)
 772   {
 773     oconfig_item_t *child = ci->children + i;
 774
 775     if (strcasecmp ("Instance", child->key) == 0)
 776       status = cf_util_get_string (child, &db->instance);
 777     else if (strcasecmp ("Host", child->key) == 0)
 778       status = cf_util_get_string (child, &db->host);
 779     else if (strcasecmp ("User", child->key) == 0)
 780       status = cf_util_get_string (child, &db->user);
 781     else if (strcasecmp ("Password", child->key) == 0)
 782       status = cf_util_get_string (child, &db->pass);
 783     else if (strcasecmp ("VerifyPeer", child->key) == 0)
 784       status = cf_util_get_boolean (child, &db->verify_peer);
 785     else if (strcasecmp ("VerifyHost", child->key) == 0)
 786       status = cf_util_get_boolean (child, &db->verify_host);
 787     else if (strcasecmp ("CACert", child->key) == 0)
 788       status = cf_util_get_string (child, &db->cacert);
 789     else if (strcasecmp ("xpath", child->key) == 0)
 790       status = cx_config_add_xpath (db, child);
 791     else
 792     {
 793       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 794       status = -1;
 795     }
 796
 797     if (status != 0)
 798       break;
 799   }
 800
 801   if (status == 0)
 802   {
 803     if (db->tree == NULL)
 804     {
 805       WARNING ("curl_xml plugin: No (valid) `Key' block "
 806                "within `URL' block `%s'.", db->url);
 807       status = -1;
 808     }
 809     if (status == 0)
 810       status = cx_init_curl (db);
 811   }
 812
 813   /* If all went well, register this database for reading */
 814   if (status == 0)
 815   {
 816     user_data_t ud;
 817     char cb_name[DATA_MAX_NAME_LEN];
 818
 819     if (db->instance == NULL)
 820       db->instance = strdup("default");
 821
 822     DEBUG ("curl_xml plugin: Registering new read callback: %s",
 823            db->instance);
 824
 825     memset (&ud, 0, sizeof (ud));
 826     ud.data = (void *) db;
 827     ud.free_func = cx_free;
 828
 829     ssnprintf (cb_name, sizeof (cb_name), "curl_xml-%s-%s",
 830                db->instance, db->url);
 831
 832     plugin_register_complex_read (cb_name, cx_read,
 833                                   /* interval = */ NULL, &ud);
 834   }
 835   else
 836   {
 837     cx_free (db);
 838     return (-1);
 839   }
 840
 841   return (0);
 842 } /* }}} int cx_config_add_url */
 843
 844 /* }}} End of configuration handling functions */
 845
 846 static int cx_config (oconfig_item_t *ci) /* {{{ */
 847 {
 848   int success;
 849   int errors;
 850   int status;
 851   int i;
 852
 853   success = 0;
 854   errors = 0;
 855
 856   for (i = 0; i < ci->children_num; i++)
 857   {
 858     oconfig_item_t *child = ci->children + i;
 859
 860     if (strcasecmp ("URL", child->key) == 0)
 861     {
 862       status = cx_config_add_url (child);
 863       if (status == 0)
 864         success++;
 865       else
 866         errors++;
 867     }
 868     else
 869     {
 870       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 871       errors++;
 872     }
 873   }
 874
 875   if ((success == 0) && (errors > 0))
 876   {
 877     ERROR ("curl_xml plugin: All statements failed.");
 878     return (-1);
 879   }
 880
 881   return (0);
 882 } /* }}} int cx_config */
 883
 884 void module_register (void)
 885 {
 886   plugin_register_complex_config ("curl_xml", cx_config);
 887 } /* void module_register */
 888
 889 /* vim: set sw=2 sts=2 et fdm=marker : */