src/curl_xml.c

   1 /**
   2  * collectd - src/curl_xml.c
   3  * Copyright (C) 2009       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        }
 420
 421        /* free up object */
 422        xmlXPathFreeObject (values_node_obj);
 423
 424        /* We have reached here which means that */
 425        /* we have got something to work */
 426        status = 0;
 427      }
 428
 429      /* submit the values */
 430      if (vl.values)
 431        plugin_dispatch_values (&vl);
 432
 433      sfree(vl.values);
 434      if (instance_node_obj != NULL)
 435        xmlXPathFreeObject (instance_node_obj);
 436   }
 437
 438   /* free up the allocated memory */
 439   xmlXPathFreeObject (base_node_obj);
 440
 441   return status;
 442 } /* }}} cx_submit_xpath_values */
 443
 444 static int cx_submit_statistics(xmlDocPtr doc, /* {{{ */
 445                        xmlXPathContextPtr xpath_ctx, cx_t *db)
 446 {
 447   c_avl_iterator_t *iter;
 448   char *key;
 449   cx_xpath_t *value;
 450   int status=-1;
 451
 452   iter = c_avl_get_iterator (db->tree);
 453   while (c_avl_iterator_next (iter, (void *) &key, (void *) &value) == 0)
 454   {
 455     if (cx_check_type(value) == -1)
 456       continue;
 457
 458     if (cx_submit_xpath_values(db->instance, xpath_ctx, key, value) == 0)
 459       status = 0; /* we got atleast one success */
 460   } /* while (c_avl_iterator_next) */
 461
 462   return status;
 463 } /* }}} cx_submit_statistics */
 464
 465 static int cx_parse_stats_xml(xmlChar* xml, cx_t *db) /* {{{ */
 466 {
 467   int status;
 468   xmlDocPtr doc;
 469   xmlXPathContextPtr xpath_ctx;
 470
 471   /* Load the XML */
 472   doc = xmlParseDoc(xml);
 473   if (doc == NULL)
 474   {
 475     ERROR ("curl_xml plugin: Failed to parse the xml document  - %s", xml);
 476     return (-1);
 477   }
 478
 479   xpath_ctx = xmlXPathNewContext(doc);
 480   if(xpath_ctx == NULL)
 481   {
 482     ERROR ("curl_xml plugin: Failed to create the xml context");
 483     xmlFreeDoc(doc);
 484     return (-1);
 485   }
 486
 487   status = cx_submit_statistics (doc, xpath_ctx, db);
 488   /* Cleanup */
 489   xmlXPathFreeContext(xpath_ctx);
 490   xmlFreeDoc(doc);
 491   return status;
 492 } /* }}} cx_parse_stats_xml */
 493
 494 static int cx_curl_perform (cx_t *db, CURL *curl) /* {{{ */
 495 {
 496   int status;
 497   long rc;
 498   char *ptr;
 499   char *url;
 500
 501   db->buffer_fill = 0;
 502   status = curl_easy_perform (curl);
 503
 504   curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
 505   curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &rc);
 506
 507   if (rc != 200)
 508   {
 509     ERROR ("curl_xml plugin: curl_easy_perform failed with response code %ld (%s)",
 510            rc, url);
 511     return (-1);
 512   }
 513
 514   if (status != 0)
 515   {
 516     ERROR ("curl_xml plugin: curl_easy_perform failed with status %i: %s (%s)",
 517            status, db->curl_errbuf, url);
 518     return (-1);
 519   }
 520
 521   ptr = db->buffer;
 522
 523   status = cx_parse_stats_xml(BAD_CAST ptr, db);
 524   db->buffer_fill = 0;
 525
 526   return status;
 527 } /* }}} int cx_curl_perform */
 528
 529 static int cx_read (user_data_t *ud) /* {{{ */
 530 {
 531   cx_t *db;
 532
 533   if ((ud == NULL) || (ud->data == NULL))
 534   {
 535     ERROR ("curl_xml plugin: cx_read: Invalid user data.");
 536     return (-1);
 537   }
 538
 539   db = (cx_t *) ud->data;
 540
 541   return cx_curl_perform (db, db->curl);
 542 } /* }}} int cx_read */
 543
 544 /* Configuration handling functions {{{ */
 545
 546 static int cx_config_add_values (const char *name, cx_xpath_t *xpath, /* {{{ */
 547                                       oconfig_item_t *ci)
 548 {
 549   int i;
 550
 551   if (ci->values_num < 1)
 552   {
 553     WARNING ("curl_xml plugin: `Values' needs at least one argument.");
 554     return (-1);
 555   }
 556
 557   for (i = 0; i < ci->values_num; i++)
 558     if (ci->values[i].type != OCONFIG_TYPE_STRING)
 559     {
 560       WARNING ("curl_xml plugin: `Values' needs only string argument.");
 561       return (-1);
 562     }
 563
 564   sfree (xpath->values);
 565
 566   xpath->values_len = 0;
 567   xpath->values = (cx_values_t *) malloc (sizeof (cx_values_t) * ci->values_num);
 568   if (xpath->values == NULL)
 569     return (-1);
 570   xpath->values_len = ci->values_num;
 571
 572   /* populate cx_values_t structure */
 573   for (i = 0; i < ci->values_num; i++)
 574   {
 575     xpath->values[i].path_len = sizeof (ci->values[i].value.string);
 576     sstrncpy (xpath->values[i].path, ci->values[i].value.string, sizeof (xpath->values[i].path));
 577   }
 578
 579   return (0);
 580 } /* }}} cx_config_add_values */
 581
 582 static c_avl_tree_t *cx_avl_create(void) /* {{{ */
 583 {
 584   return c_avl_create ((int (*) (const void *, const void *)) strcmp);
 585 } /* }}} cx_avl_create */
 586
 587 static int cx_config_add_xpath (cx_t *db, /* {{{ */
 588                                    oconfig_item_t *ci)
 589 {
 590   cx_xpath_t *xpath;
 591   int status;
 592   int i;
 593
 594   if ((ci->values_num != 1)
 595       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 596   {
 597     WARNING ("curl_xml plugin: The `xpath' block "
 598              "needs exactly one string argument.");
 599     return (-1);
 600   }
 601
 602   xpath = (cx_xpath_t *) malloc (sizeof (*xpath));
 603   if (xpath == NULL)
 604   {
 605     ERROR ("curl_xml plugin: malloc failed.");
 606     return (-1);
 607   }
 608   memset (xpath, 0, sizeof (*xpath));
 609   xpath->magic = CX_KEY_MAGIC;
 610
 611   if (strcasecmp ("xpath", ci->key) == 0)
 612   {
 613     status = cf_util_get_string (ci, &xpath->path);
 614     if (status != 0)
 615     {
 616       sfree (xpath);
 617       return (status);
 618     }
 619   }
 620   else
 621   {
 622     ERROR ("curl_xml plugin: cx_config: "
 623            "Invalid key: %s", ci->key);
 624     return (-1);
 625   }
 626
 627   status = 0;
 628   for (i = 0; i < ci->children_num; i++)
 629   {
 630     oconfig_item_t *child = ci->children + i;
 631
 632     if (strcasecmp ("Type", child->key) == 0)
 633       status = cf_util_get_string (child, &xpath->type);
 634     else if (strcasecmp ("InstancePrefix", child->key) == 0)
 635       status = cf_util_get_string (child, &xpath->instance_prefix);
 636     else if (strcasecmp ("Instance", child->key) == 0)
 637       status = cf_util_get_string (child, &xpath->instance);
 638     else if (strcasecmp ("Values", child->key) == 0)
 639       status = cx_config_add_values ("Values", xpath, child);
 640     else
 641     {
 642       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 643       status = -1;
 644     }
 645
 646     if (status != 0)
 647       break;
 648   } /* for (i = 0; i < ci->children_num; i++) */
 649
 650   while (status == 0)
 651   {
 652     if (xpath->type == NULL)
 653     {
 654       WARNING ("curl_xml plugin: `Type' missing in `xpath' block.");
 655       status = -1;
 656     }
 657
 658     break;
 659   } /* while (status == 0) */
 660
 661   if (status == 0)
 662   {
 663     char *name;
 664     c_avl_tree_t *tree;
 665
 666     if (db->tree == NULL)
 667       db->tree = cx_avl_create();
 668
 669     tree = db->tree;
 670     name = xpath->path;
 671
 672     if (*name)
 673       c_avl_insert (tree, strdup(name), xpath);
 674     else
 675     {
 676       ERROR ("curl_xml plugin: invalid key: %s", xpath->path);
 677       status = -1;
 678     }
 679   }
 680
 681   return (status);
 682 } /* }}} int cx_config_add_xpath */
 683
 684 /* Initialize db->curl */
 685 static int cx_init_curl (cx_t *db) /* {{{ */
 686 {
 687   db->curl = curl_easy_init ();
 688   if (db->curl == NULL)
 689   {
 690     ERROR ("curl_xml plugin: curl_easy_init failed.");
 691     return (-1);
 692   }
 693
 694   curl_easy_setopt (db->curl, CURLOPT_WRITEFUNCTION, cx_curl_callback);
 695   curl_easy_setopt (db->curl, CURLOPT_WRITEDATA, db);
 696   curl_easy_setopt (db->curl, CURLOPT_USERAGENT,
 697                     PACKAGE_NAME"/"PACKAGE_VERSION);
 698   curl_easy_setopt (db->curl, CURLOPT_ERRORBUFFER, db->curl_errbuf);
 699   curl_easy_setopt (db->curl, CURLOPT_URL, db->url);
 700
 701   if (db->user != NULL)
 702   {
 703     size_t credentials_size;
 704
 705     credentials_size = strlen (db->user) + 2;
 706     if (db->pass != NULL)
 707       credentials_size += strlen (db->pass);
 708
 709     db->credentials = (char *) malloc (credentials_size);
 710     if (db->credentials == NULL)
 711     {
 712       ERROR ("curl_xml plugin: malloc failed.");
 713       return (-1);
 714     }
 715
 716     ssnprintf (db->credentials, credentials_size, "%s:%s",
 717                db->user, (db->pass == NULL) ? "" : db->pass);
 718     curl_easy_setopt (db->curl, CURLOPT_USERPWD, db->credentials);
 719   }
 720
 721   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYPEER, db->verify_peer);
 722   curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYHOST,
 723                     db->verify_host ? 2 : 0);
 724   if (db->cacert != NULL)
 725     curl_easy_setopt (db->curl, CURLOPT_CAINFO, db->cacert);
 726
 727   return (0);
 728 } /* }}} int cx_init_curl */
 729
 730 static int cx_config_add_url (oconfig_item_t *ci) /* {{{ */
 731 {
 732   cx_t *db;
 733   int status = 0;
 734   int i;
 735
 736   if ((ci->values_num != 1)
 737       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 738   {
 739     WARNING ("curl_xml plugin: The `URL' block "
 740              "needs exactly one string argument.");
 741     return (-1);
 742   }
 743
 744   db = (cx_t *) malloc (sizeof (*db));
 745   if (db == NULL)
 746   {
 747     ERROR ("curl_xml plugin: malloc failed.");
 748     return (-1);
 749   }
 750   memset (db, 0, sizeof (*db));
 751
 752   if (strcasecmp ("URL", ci->key) == 0)
 753   {
 754     status = cf_util_get_string (ci, &db->url);
 755     if (status != 0)
 756     {
 757       sfree (db);
 758       return (status);
 759     }
 760   }
 761   else
 762   {
 763     ERROR ("curl_xml plugin: cx_config: "
 764            "Invalid key: %s", ci->key);
 765     return (-1);
 766   }
 767
 768   /* Fill the `cx_t' structure.. */
 769   for (i = 0; i < ci->children_num; i++)
 770   {
 771     oconfig_item_t *child = ci->children + i;
 772
 773     if (strcasecmp ("Instance", child->key) == 0)
 774       status = cf_util_get_string (child, &db->instance);
 775     else if (strcasecmp ("Host", child->key) == 0)
 776       status = cf_util_get_string (child, &db->host);
 777     else if (strcasecmp ("User", child->key) == 0)
 778       status = cf_util_get_string (child, &db->user);
 779     else if (strcasecmp ("Password", child->key) == 0)
 780       status = cf_util_get_string (child, &db->pass);
 781     else if (strcasecmp ("VerifyPeer", child->key) == 0)
 782       status = cf_util_get_boolean (child, &db->verify_peer);
 783     else if (strcasecmp ("VerifyHost", child->key) == 0)
 784       status = cf_util_get_boolean (child, &db->verify_host);
 785     else if (strcasecmp ("CACert", child->key) == 0)
 786       status = cf_util_get_string (child, &db->cacert);
 787     else if (strcasecmp ("xpath", child->key) == 0)
 788       status = cx_config_add_xpath (db, child);
 789     else
 790     {
 791       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 792       status = -1;
 793     }
 794
 795     if (status != 0)
 796       break;
 797   }
 798
 799   if (status == 0)
 800   {
 801     if (db->tree == NULL)
 802     {
 803       WARNING ("curl_xml plugin: No (valid) `Key' block "
 804                "within `URL' block `%s'.", db->url);
 805       status = -1;
 806     }
 807     if (status == 0)
 808       status = cx_init_curl (db);
 809   }
 810
 811   /* If all went well, register this database for reading */
 812   if (status == 0)
 813   {
 814     user_data_t ud;
 815     char cb_name[DATA_MAX_NAME_LEN];
 816
 817     if (db->instance == NULL)
 818       db->instance = strdup("default");
 819
 820     DEBUG ("curl_xml plugin: Registering new read callback: %s",
 821            db->instance);
 822
 823     memset (&ud, 0, sizeof (ud));
 824     ud.data = (void *) db;
 825     ud.free_func = cx_free;
 826
 827     ssnprintf (cb_name, sizeof (cb_name), "curl_xml-%s-%s",
 828                db->instance, db->url);
 829
 830     plugin_register_complex_read (cb_name, cx_read,
 831                                   /* interval = */ NULL, &ud);
 832   }
 833   else
 834   {
 835     cx_free (db);
 836     return (-1);
 837   }
 838
 839   return (0);
 840 } /* }}} int cx_config_add_url */
 841
 842 /* }}} End of configuration handling functions */
 843
 844 static int cx_config (oconfig_item_t *ci) /* {{{ */
 845 {
 846   int success;
 847   int errors;
 848   int status;
 849   int i;
 850
 851   success = 0;
 852   errors = 0;
 853
 854   for (i = 0; i < ci->children_num; i++)
 855   {
 856     oconfig_item_t *child = ci->children + i;
 857
 858     if (strcasecmp ("URL", child->key) == 0)
 859     {
 860       status = cx_config_add_url (child);
 861       if (status == 0)
 862         success++;
 863       else
 864         errors++;
 865     }
 866     else
 867     {
 868       WARNING ("curl_xml plugin: Option `%s' not allowed here.", child->key);
 869       errors++;
 870     }
 871   }
 872
 873   if ((success == 0) && (errors > 0))
 874   {
 875     ERROR ("curl_xml plugin: All statements failed.");
 876     return (-1);
 877   }
 878
 879   return (0);
 880 } /* }}} int cx_config */
 881
 882 void module_register (void)
 883 {
 884   plugin_register_complex_config ("curl_xml", cx_config);
 885 } /* void module_register */
 886
 887 /* vim: set sw=2 sts=2 et fdm=marker : */