src/powerdns.c

   1 /**
   2  * collectd - src/powerdns.c
   3  * Copyright (C) 2007-2008  C-Ware, Inc.
   4  * Copyright (C) 2008       Florian Forster
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; only version 2 of the License is applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Author:
  20  *   Luke Heberling <lukeh at c-ware.com>
  21  *   Florian Forster <octo at collectd.org>
  22  *
  23  * DESCRIPTION
  24  *   Queries a PowerDNS control socket for statistics
  25  **/
  26
  27 #include "collectd.h"
  28 #include "common.h"
  29 #include "plugin.h"
  30 #include "configfile.h"
  31 #include "utils_llist.h"
  32
  33 #include <sys/stat.h>
  34 #include <unistd.h>
  35 #include <stdlib.h>
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <errno.h>
  39 #include <sys/types.h>
  40 #include <sys/socket.h>
  41 #include <sys/un.h>
  42
  43 #ifndef UNIX_PATH_MAX
  44 # define UNIX_PATH_MAX sizeof (((struct sockaddr_un *)0)->sun_path)
  45 #endif
  46 #define FUNC_ERROR(func) do { char errbuf[1024]; ERROR ("powerdns plugin: %s failed: %s", func, sstrerror (errno, errbuf, sizeof (errbuf))); } while (0)
  47
  48 #define SERVER_SOCKET  LOCALSTATEDIR"/run/pdns.controlsocket"
  49 #define SERVER_COMMAND "SHOW * \n"
  50
  51 #define RECURSOR_SOCKET  LOCALSTATEDIR"/run/pdns_recursor.controlsocket"
  52 #define RECURSOR_COMMAND "get noerror-answers nxdomain-answers " \
  53   "servfail-answers sys-msec user-msec qa-latency cache-entries cache-hits " \
  54   "cache-misses questions\n"
  55
  56 struct list_item_s;
  57 typedef struct list_item_s list_item_t;
  58
  59 struct list_item_s
  60 {
  61   enum
  62   {
  63     SRV_AUTHORITATIVE,
  64     SRV_RECURSOR
  65   } server_type;
  66   int (*func) (list_item_t *item);
  67   char *instance;
  68
  69   char **fields;
  70   int fields_num;
  71   char *command;
  72
  73   struct sockaddr_un sockaddr;
  74   int socktype;
  75 };
  76
  77 struct statname_lookup_s
  78 {
  79   char *name;
  80   char *type;
  81   char *type_instance;
  82 };
  83 typedef struct statname_lookup_s statname_lookup_t;
  84
  85 /* Description of statistics returned by the recursor: {{{
  86 all-outqueries      counts the number of outgoing UDP queries since starting
  87 answers0-1          counts the number of queries answered within 1 millisecond
  88 answers100-1000     counts the number of queries answered within 1 second
  89 answers10-100       counts the number of queries answered within 100 milliseconds
  90 answers1-10         counts the number of queries answered within 10 milliseconds
  91 answers-slow        counts the number of queries answered after 1 second
  92 cache-entries       shows the number of entries in the cache
  93 cache-hits          counts the number of cache hits since starting
  94 cache-misses        counts the number of cache misses since starting
  95 chain-resends       number of queries chained to existing outstanding query
  96 client-parse-errors counts number of client packets that could not be parsed
  97 concurrent-queries  shows the number of MThreads currently running
  98 dlg-only-drops      number of records dropped because of delegation only setting
  99 negcache-entries    shows the number of entries in the Negative answer cache
 100 noerror-answers     counts the number of times it answered NOERROR since starting
 101 nsspeeds-entries    shows the number of entries in the NS speeds map
 102 nsset-invalidations number of times an nsset was dropped because it no longer worked
 103 nxdomain-answers    counts the number of times it answered NXDOMAIN since starting
 104 outgoing-timeouts   counts the number of timeouts on outgoing UDP queries since starting
 105 qa-latency          shows the current latency average
 106 questions           counts all End-user initiated queries with the RD bit set
 107 resource-limits     counts number of queries that could not be performed because of resource limits
 108 server-parse-errors counts number of server replied packets that could not be parsed
 109 servfail-answers    counts the number of times it answered SERVFAIL since starting
 110 spoof-prevents      number of times PowerDNS considered itself spoofed, and dropped the data
 111 sys-msec            number of CPU milliseconds spent in 'system' mode
 112 tcp-client-overflow number of times an IP address was denied TCP access because it already had too many connections
 113 tcp-outqueries      counts the number of outgoing TCP queries since starting
 114 tcp-questions       counts all incoming TCP queries (since starting)
 115 throttled-out       counts the number of throttled outgoing UDP queries since starting
 116 throttle-entries    shows the number of entries in the throttle map
 117 unauthorized-tcp    number of TCP questions denied because of allow-from restrictions
 118 unauthorized-udp    number of UDP questions denied because of allow-from restrictions
 119 unexpected-packets  number of answers from remote servers that were unexpected (might point to spoofing)
 120 uptime              number of seconds process has been running (since 3.1.5)
 121 user-msec           number of CPU milliseconds spent in 'user' mode
 122 }}} */
 123
 124 const char* const default_server_fields[] = /* {{{ */
 125 {
 126   "latency"
 127   "packetcache-hit",
 128   "packetcache-miss",
 129   "packetcache-size",
 130   "query-cache-hit",
 131   "query-cache-miss",
 132   "recursing-answers",
 133   "recursing-questions",
 134   "tcp-answers",
 135   "tcp-queries",
 136   "udp-answers",
 137   "udp-queries",
 138 }; /* }}} */
 139 int default_server_fields_num = STATIC_ARRAY_SIZE (default_server_fields);
 140
 141 statname_lookup_t lookup_table[] = /* {{{ */
 142 {
 143   /*********************
 144    * Server statistics *
 145    *********************/
 146   /* Questions */
 147   {"recursing-questions",    "dns_question", "recurse"},
 148   {"tcp-queries",            "dns_question", "tcp"},
 149   {"udp-queries",            "dns_question", "udp"},
 150   {"rd-queries",             "dns_question", "rd"},
 151
 152   /* Answers */
 153   {"recursing-answers",      "dns_answer",   "recurse"},
 154   {"tcp-answers",            "dns_answer",   "tcp"},
 155   {"udp-answers",            "dns_answer",   "udp"},
 156   {"recursion-unanswered",   "dns_answer",   "recursion-unanswered"},
 157   {"udp-answers-bytes",      "total_bytes",  "udp-answers-bytes"},
 158
 159   /* Cache stuff */
 160   {"packetcache-hit",        "cache_result", "packet-hit"},
 161   {"packetcache-miss",       "cache_result", "packet-miss"},
 162   {"packetcache-size",       "cache_size",   "packet"},
 163   {"key-cache-size",         "cache_size",   "key"},
 164   {"meta-cache-size",        "cache_size",   "meta"},
 165   {"signature-cache-size",   "cache_size",   "signature"},
 166   {"query-cache-hit",        "cache_result", "query-hit"},
 167   {"query-cache-miss",       "cache_result", "query-miss"},
 168
 169   /* Latency */
 170   {"latency",                "latency",      NULL},
 171
 172   /* DNS updates */
 173   {"dnsupdate-answers",      "dns_answer",   "dnsupdate-answer"},
 174   {"dnsupdate-changes",      "dns_question", "dnsupdate-changes"},
 175   {"dnsupdate-queries",      "dns_question", "dnsupdate-queries"},
 176   {"dnsupdate-refused",      "dns_answer",   "dnsupdate-refused"},
 177
 178   /* Other stuff.. */
 179   {"corrupt-packets",        "ipt_packets",  "corrupt"},
 180   {"deferred-cache-inserts", "counter",      "cache-deferred_insert"},
 181   {"deferred-cache-lookup",  "counter",      "cache-deferred_lookup"},
 182   {"qsize-a",                "cache_size",   "answers"},
 183   {"qsize-q",                "cache_size",   "questions"},
 184   {"servfail-packets",       "ipt_packets",  "servfail"},
 185   {"timedout-packets",       "ipt_packets",  "timeout"},
 186   {"udp4-answers",           "dns_answer",   "udp4"},
 187   {"udp4-queries",           "dns_question", "queries-udp4"},
 188   {"udp6-answers",           "dns_answer",   "udp6"},
 189   {"udp6-queries",           "dns_question", "queries-udp6"},
 190   {"security-status",        "dns_question", "security-status"},
 191   {"udp-do-queries",         "dns_question", "udp-do_queries"},
 192   {"signatures",             "counter",      "signatures"},
 193
 194   /***********************
 195    * Recursor statistics *
 196    ***********************/
 197   /* Answers by return code */
 198   {"noerror-answers",     "dns_rcode",    "NOERROR"},
 199   {"nxdomain-answers",    "dns_rcode",    "NXDOMAIN"},
 200   {"servfail-answers",    "dns_rcode",    "SERVFAIL"},
 201
 202   /* CPU utilization */
 203   {"sys-msec",            "cpu",          "system"},
 204   {"user-msec",           "cpu",          "user"},
 205
 206   /* Question-to-answer latency */
 207   {"qa-latency",          "latency",      NULL},
 208
 209   /* Cache */
 210   {"cache-entries",       "cache_size",   NULL},
 211   {"cache-hits",          "cache_result", "hit"},
 212   {"cache-misses",        "cache_result", "miss"},
 213
 214   /* Total number of questions.. */
 215   {"questions",           "dns_qtype",    "total"},
 216
 217   /* All the other stuff.. */
 218   {"all-outqueries",      "dns_question", "outgoing"},
 219   {"answers0-1",          "dns_answer",   "0_1"},
 220   {"answers1-10",         "dns_answer",   "1_10"},
 221   {"answers10-100",       "dns_answer",   "10_100"},
 222   {"answers100-1000",     "dns_answer",   "100_1000"},
 223   {"answers-slow",        "dns_answer",   "slow"},
 224   {"chain-resends",       "dns_question", "chained"},
 225   {"client-parse-errors", "counter",      "drops-client_parse_error"},
 226   {"concurrent-queries",  "dns_question", "concurrent"},
 227   {"dlg-only-drops",      "counter",      "drops-delegation_only"},
 228   {"negcache-entries",    "cache_size",   "negative"},
 229   {"nsspeeds-entries",    "gauge",        "entries-ns_speeds"},
 230   {"nsset-invalidations", "counter",      "ns_set_invalidation"},
 231   {"outgoing-timeouts",   "counter",      "drops-timeout_outgoing"},
 232   {"resource-limits",     "counter",      "drops-resource_limit"},
 233   {"server-parse-errors", "counter",      "drops-server_parse_error"},
 234   {"spoof-prevents",      "counter",      "drops-spoofed"},
 235   {"tcp-client-overflow", "counter",      "denied-client_overflow_tcp"},
 236   {"tcp-outqueries",      "dns_question", "outgoing-tcp"},
 237   {"tcp-questions",       "dns_question", "incoming-tcp"},
 238   {"throttled-out",       "dns_question", "outgoing-throttled"},
 239   {"throttle-entries",    "gauge",        "entries-throttle"},
 240   {"unauthorized-tcp",    "counter",      "denied-unauthorized_tcp"},
 241   {"unauthorized-udp",    "counter",      "denied-unauthorized_udp"},
 242   {"unexpected-packets",  "dns_answer",   "unexpected"},
 243   {"uptime",              "uptime",       NULL}
 244 }; /* }}} */
 245 int lookup_table_length = STATIC_ARRAY_SIZE (lookup_table);
 246
 247 static llist_t *list = NULL;
 248
 249 #define PDNS_LOCAL_SOCKPATH LOCALSTATEDIR"/run/"PACKAGE_NAME"-powerdns"
 250 static char *local_sockpath = NULL;
 251
 252 /* TODO: Do this before 4.4:
 253  * - Recursor:
 254  *   - Complete list of known pdns -> collectd mappings.
 255  * - Update the collectd.conf(5) manpage.
 256  *
 257  * -octo
 258  */
 259
 260 /* <http://doc.powerdns.com/recursor-stats.html> */
 261 static void submit (const char *plugin_instance, /* {{{ */
 262     const char *pdns_type, const char *value)
 263 {
 264   value_list_t vl = VALUE_LIST_INIT;
 265   value_t values[1];
 266
 267   const char *type = NULL;
 268   const char *type_instance = NULL;
 269   const data_set_t *ds;
 270
 271   int i;
 272
 273   for (i = 0; i < lookup_table_length; i++)
 274     if (strcmp (lookup_table[i].name, pdns_type) == 0)
 275       break;
 276
 277   if (i >= lookup_table_length)
 278   {
 279     INFO ("powerdns plugin: submit: Not found in lookup table: %s = %s;",
 280         pdns_type, value);
 281     return;
 282   }
 283
 284   if (lookup_table[i].type == NULL)
 285     return;
 286
 287   type = lookup_table[i].type;
 288   type_instance = lookup_table[i].type_instance;
 289
 290   ds = plugin_get_ds (type);
 291   if (ds == NULL)
 292   {
 293     ERROR ("powerdns plugin: The lookup table returned type `%s', "
 294         "but I cannot find it via `plugin_get_ds'.",
 295         type);
 296     return;
 297   }
 298
 299   if (ds->ds_num != 1)
 300   {
 301     ERROR ("powerdns plugin: type `%s' has %zu data sources, "
 302         "but I can only handle one.",
 303         type, ds->ds_num);
 304     return;
 305   }
 306
 307   if (0 != parse_value (value, &values[0], ds->ds[0].type))
 308   {
 309     ERROR ("powerdns plugin: Cannot convert `%s' "
 310         "to a number.", value);
 311     return;
 312   }
 313
 314   vl.values = values;
 315   vl.values_len = 1;
 316   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 317   sstrncpy (vl.plugin, "powerdns", sizeof (vl.plugin));
 318   sstrncpy (vl.type, type, sizeof (vl.type));
 319   if (type_instance != NULL)
 320     sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 321   sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
 322
 323   plugin_dispatch_values (&vl);
 324 } /* }}} static void submit */
 325
 326 static int powerdns_get_data_dgram (list_item_t *item, /* {{{ */
 327     char **ret_buffer,
 328     size_t *ret_buffer_size)
 329 {
 330   int sd;
 331   int status;
 332
 333   char temp[4096];
 334   char *buffer = NULL;
 335   size_t buffer_size = 0;
 336
 337   struct sockaddr_un sa_unix;
 338
 339   struct timeval stv_timeout;
 340   cdtime_t cdt_timeout;
 341
 342   sd = socket (PF_UNIX, item->socktype, 0);
 343   if (sd < 0)
 344   {
 345     FUNC_ERROR ("socket");
 346     return (-1);
 347   }
 348
 349   memset (&sa_unix, 0, sizeof (sa_unix));
 350   sa_unix.sun_family = AF_UNIX;
 351   sstrncpy (sa_unix.sun_path,
 352       (local_sockpath != NULL) ? local_sockpath : PDNS_LOCAL_SOCKPATH,
 353       sizeof (sa_unix.sun_path));
 354
 355   status = unlink (sa_unix.sun_path);
 356   if ((status != 0) && (errno != ENOENT))
 357   {
 358     FUNC_ERROR ("unlink");
 359     close (sd);
 360     return (-1);
 361   }
 362
 363   do /* while (0) */
 364   {
 365     /* We need to bind to a specific path, because this is a datagram socket
 366      * and otherwise the daemon cannot answer. */
 367     status = bind (sd, (struct sockaddr *) &sa_unix, sizeof (sa_unix));
 368     if (status != 0)
 369     {
 370       FUNC_ERROR ("bind");
 371       break;
 372     }
 373
 374     /* Make the socket writeable by the daemon.. */
 375     status = chmod (sa_unix.sun_path, 0666);
 376     if (status != 0)
 377     {
 378       FUNC_ERROR ("chmod");
 379       break;
 380     }
 381
 382     cdt_timeout = plugin_get_interval () * 3 / 4;
 383     if (cdt_timeout < TIME_T_TO_CDTIME_T (2))
 384       cdt_timeout = TIME_T_TO_CDTIME_T (2);
 385
 386     CDTIME_T_TO_TIMEVAL (cdt_timeout, &stv_timeout);
 387
 388     status = setsockopt (sd, SOL_SOCKET, SO_RCVTIMEO, &stv_timeout, sizeof (stv_timeout));
 389     if (status != 0)
 390     {
 391       FUNC_ERROR ("setsockopt");
 392       break;
 393     }
 394
 395     status = connect (sd, (struct sockaddr *) &item->sockaddr,
 396         sizeof (item->sockaddr));
 397     if (status != 0)
 398     {
 399       FUNC_ERROR ("connect");
 400       break;
 401     }
 402
 403     status = send (sd, item->command, strlen (item->command), 0);
 404     if (status < 0)
 405     {
 406       FUNC_ERROR ("send");
 407       break;
 408     }
 409
 410     status = recv (sd, temp, sizeof (temp), /* flags = */ 0);
 411     if (status < 0)
 412     {
 413       FUNC_ERROR ("recv");
 414       break;
 415     }
 416     buffer_size = status + 1;
 417     status = 0;
 418   } while (0);
 419
 420   close (sd);
 421   unlink (sa_unix.sun_path);
 422
 423   if (status != 0)
 424     return (-1);
 425
 426   assert (buffer_size > 0);
 427   buffer = (char *) malloc (buffer_size);
 428   if (buffer == NULL)
 429   {
 430     FUNC_ERROR ("malloc");
 431     return (-1);
 432   }
 433
 434   memcpy (buffer, temp, buffer_size - 1);
 435   buffer[buffer_size - 1] = 0;
 436
 437   *ret_buffer = buffer;
 438   *ret_buffer_size = buffer_size;
 439
 440   return (0);
 441 } /* }}} int powerdns_get_data_dgram */
 442
 443 static int powerdns_get_data_stream (list_item_t *item, /* {{{ */
 444     char **ret_buffer,
 445     size_t *ret_buffer_size)
 446 {
 447   int sd;
 448   int status;
 449
 450   char temp[4096];
 451   char *buffer = NULL;
 452   size_t buffer_size = 0;
 453
 454   sd = socket (PF_UNIX, item->socktype, 0);
 455   if (sd < 0)
 456   {
 457     FUNC_ERROR ("socket");
 458     return (-1);
 459   }
 460
 461   struct timeval timeout;
 462   timeout.tv_sec=5;
 463   timeout.tv_usec=0;
 464   status = setsockopt (sd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof (timeout));
 465   if (status != 0)
 466   {
 467     FUNC_ERROR ("setsockopt");
 468     close (sd);
 469     return (-1);
 470   }
 471
 472   status = connect (sd, (struct sockaddr *) &item->sockaddr,
 473       sizeof (item->sockaddr));
 474   if (status != 0)
 475   {
 476     FUNC_ERROR ("connect");
 477     close (sd);
 478     return (-1);
 479   }
 480
 481   /* strlen + 1, because we need to send the terminating NULL byte, too. */
 482   status = send (sd, item->command, strlen (item->command) + 1,
 483       /* flags = */ 0);
 484   if (status < 0)
 485   {
 486     FUNC_ERROR ("send");
 487     close (sd);
 488     return (-1);
 489   }
 490
 491   while (42)
 492   {
 493     char *buffer_new;
 494
 495     status = recv (sd, temp, sizeof (temp), /* flags = */ 0);
 496     if (status < 0)
 497     {
 498       FUNC_ERROR ("recv");
 499       break;
 500     }
 501     else if (status == 0)
 502       break;
 503
 504     buffer_new = (char *) realloc (buffer, buffer_size + status + 1);
 505     if (buffer_new == NULL)
 506     {
 507       FUNC_ERROR ("realloc");
 508       status = -1;
 509       break;
 510     }
 511     buffer = buffer_new;
 512
 513     memcpy (buffer + buffer_size, temp, status);
 514     buffer_size += status;
 515     buffer[buffer_size] = 0;
 516   } /* while (42) */
 517   close (sd);
 518
 519   if (status < 0)
 520   {
 521     sfree (buffer);
 522   }
 523   else
 524   {
 525     assert (status == 0);
 526     *ret_buffer = buffer;
 527     *ret_buffer_size = buffer_size;
 528   }
 529
 530   return (status);
 531 } /* }}} int powerdns_get_data_stream */
 532
 533 static int powerdns_get_data (list_item_t *item, char **ret_buffer,
 534     size_t *ret_buffer_size)
 535 {
 536   if (item->socktype == SOCK_DGRAM)
 537     return (powerdns_get_data_dgram (item, ret_buffer, ret_buffer_size));
 538   else if (item->socktype == SOCK_STREAM)
 539     return (powerdns_get_data_stream (item, ret_buffer, ret_buffer_size));
 540   else
 541   {
 542     ERROR ("powerdns plugin: Unknown socket type: %i", (int) item->socktype);
 543     return (-1);
 544   }
 545 } /* int powerdns_get_data */
 546
 547 static int powerdns_read_server (list_item_t *item) /* {{{ */
 548 {
 549   char *buffer = NULL;
 550   size_t buffer_size = 0;
 551   int status;
 552
 553   char *dummy;
 554   char *saveptr;
 555
 556   char *key;
 557   char *value;
 558
 559   const char* const *fields;
 560   int fields_num;
 561
 562   if (item->command == NULL)
 563     item->command = strdup (SERVER_COMMAND);
 564   if (item->command == NULL)
 565   {
 566     ERROR ("powerdns plugin: strdup failed.");
 567     return (-1);
 568   }
 569
 570   status = powerdns_get_data (item, &buffer, &buffer_size);
 571   if (status != 0)
 572     return (-1);
 573
 574   if (item->fields_num != 0)
 575   {
 576     fields = (const char* const *) item->fields;
 577     fields_num = item->fields_num;
 578   }
 579   else
 580   {
 581     fields = default_server_fields;
 582     fields_num = default_server_fields_num;
 583   }
 584
 585   assert (fields != NULL);
 586   assert (fields_num > 0);
 587
 588   /* corrupt-packets=0,deferred-cache-inserts=0,deferred-cache-lookup=0,latency=0,packetcache-hit=0,packetcache-miss=0,packetcache-size=0,qsize-q=0,query-cache-hit=0,query-cache-miss=0,recursing-answers=0,recursing-questions=0,servfail-packets=0,tcp-answers=0,tcp-queries=0,timedout-packets=0,udp-answers=0,udp-queries=0,udp4-answers=0,udp4-queries=0,udp6-answers=0,udp6-queries=0, */
 589   dummy = buffer;
 590   saveptr = NULL;
 591   while ((key = strtok_r (dummy, ",", &saveptr)) != NULL)
 592   {
 593     int i;
 594
 595     dummy = NULL;
 596
 597     value = strchr (key, '=');
 598     if (value == NULL)
 599       break;
 600
 601     *value = '\0';
 602     value++;
 603
 604     if (value[0] == '\0')
 605       continue;
 606
 607     /* Check if this item was requested. */
 608     for (i = 0; i < fields_num; i++)
 609       if (strcasecmp (key, fields[i]) == 0)
 610         break;
 611     if (i >= fields_num)
 612       continue;
 613
 614     submit (item->instance, key, value);
 615   } /* while (strtok_r) */
 616
 617   sfree (buffer);
 618
 619   return (0);
 620 } /* }}} int powerdns_read_server */
 621
 622 /*
 623  * powerdns_update_recursor_command
 624  *
 625  * Creates a string that holds the command to be sent to the recursor. This
 626  * string is stores in the `command' member of the `list_item_t' passed to the
 627  * function. This function is called by `powerdns_read_recursor'.
 628  */
 629 static int powerdns_update_recursor_command (list_item_t *li) /* {{{ */
 630 {
 631   char buffer[4096];
 632   int status;
 633
 634   if (li == NULL)
 635     return (0);
 636
 637   if (li->fields_num < 1)
 638   {
 639     sstrncpy (buffer, RECURSOR_COMMAND, sizeof (buffer));
 640   }
 641   else
 642   {
 643     sstrncpy (buffer, "get ", sizeof (buffer));
 644     status = strjoin (&buffer[strlen("get ")], sizeof (buffer) - strlen ("get "),
 645         li->fields, li->fields_num,
 646         /* seperator = */ " ");
 647     if (status < 0)
 648     {
 649       ERROR ("powerdns plugin: strjoin failed.");
 650       return (-1);
 651     }
 652     buffer[sizeof (buffer) - 1] = 0;
 653     size_t len = strlen (buffer);
 654     if (len < sizeof (buffer) - 2)
 655     {
 656       buffer[len++] = ' ';
 657       buffer[len++] = '\n';
 658       buffer[len++] = '\0';
 659     }
 660   }
 661
 662   buffer[sizeof (buffer) - 1] = 0;
 663   li->command = strdup (buffer);
 664   if (li->command == NULL)
 665   {
 666     ERROR ("powerdns plugin: strdup failed.");
 667     return (-1);
 668   }
 669
 670   return (0);
 671 } /* }}} int powerdns_update_recursor_command */
 672
 673 static int powerdns_read_recursor (list_item_t *item) /* {{{ */
 674 {
 675   char *buffer = NULL;
 676   size_t buffer_size = 0;
 677   int status;
 678
 679   char *dummy;
 680
 681   char *keys_list;
 682   char *key;
 683   char *key_saveptr;
 684   char *value;
 685   char *value_saveptr;
 686
 687   if (item->command == NULL)
 688   {
 689     status = powerdns_update_recursor_command (item);
 690     if (status != 0)
 691     {
 692       ERROR ("powerdns plugin: powerdns_update_recursor_command failed.");
 693       return (-1);
 694     }
 695
 696     DEBUG ("powerdns plugin: powerdns_read_recursor: item->command = %s;",
 697         item->command);
 698   }
 699   assert (item->command != NULL);
 700
 701   status = powerdns_get_data (item, &buffer, &buffer_size);
 702   if (status != 0)
 703   {
 704     ERROR ("powerdns plugin: powerdns_get_data failed.");
 705     return (-1);
 706   }
 707
 708   keys_list = strdup (item->command);
 709   if (keys_list == NULL)
 710   {
 711     FUNC_ERROR ("strdup");
 712     sfree (buffer);
 713     return (-1);
 714   }
 715
 716   key_saveptr = NULL;
 717   value_saveptr = NULL;
 718
 719   /* Skip the `get' at the beginning */
 720   strtok_r (keys_list, " \t", &key_saveptr);
 721
 722   dummy = buffer;
 723   while ((value = strtok_r (dummy, " \t\n\r", &value_saveptr)) != NULL)
 724   {
 725     dummy = NULL;
 726
 727     key = strtok_r (NULL, " \t", &key_saveptr);
 728     if (key == NULL)
 729       break;
 730
 731     submit (item->instance, key, value);
 732   } /* while (strtok_r) */
 733
 734   sfree (buffer);
 735   sfree (keys_list);
 736
 737   return (0);
 738 } /* }}} int powerdns_read_recursor */
 739
 740 static int powerdns_config_add_collect (list_item_t *li, /* {{{ */
 741     oconfig_item_t *ci)
 742 {
 743   int i;
 744   char **temp;
 745
 746   if (ci->values_num < 1)
 747   {
 748     WARNING ("powerdns plugin: The `Collect' option needs "
 749         "at least one argument.");
 750     return (-1);
 751   }
 752
 753   for (i = 0; i < ci->values_num; i++)
 754     if (ci->values[i].type != OCONFIG_TYPE_STRING)
 755     {
 756       WARNING ("powerdns plugin: Only string arguments are allowed to "
 757           "the `Collect' option.");
 758       return (-1);
 759     }
 760
 761   temp = (char **) realloc (li->fields,
 762       sizeof (char *) * (li->fields_num + ci->values_num));
 763   if (temp == NULL)
 764   {
 765     WARNING ("powerdns plugin: realloc failed.");
 766     return (-1);
 767   }
 768   li->fields = temp;
 769
 770   for (i = 0; i < ci->values_num; i++)
 771   {
 772     li->fields[li->fields_num] = strdup (ci->values[i].value.string);
 773     if (li->fields[li->fields_num] == NULL)
 774     {
 775       WARNING ("powerdns plugin: strdup failed.");
 776       continue;
 777     }
 778     li->fields_num++;
 779   }
 780
 781   /* Invalidate a previously computed command */
 782   sfree (li->command);
 783
 784   return (0);
 785 } /* }}} int powerdns_config_add_collect */
 786
 787 static int powerdns_config_add_server (oconfig_item_t *ci) /* {{{ */
 788 {
 789   char *socket_temp;
 790
 791   list_item_t *item;
 792   int status;
 793   int i;
 794
 795   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
 796   {
 797     WARNING ("powerdns plugin: `%s' needs exactly one string argument.",
 798         ci->key);
 799     return (-1);
 800   }
 801
 802   item = (list_item_t *) malloc (sizeof (list_item_t));
 803   if (item == NULL)
 804   {
 805     ERROR ("powerdns plugin: malloc failed.");
 806     return (-1);
 807   }
 808   memset (item, '\0', sizeof (list_item_t));
 809
 810   item->instance = strdup (ci->values[0].value.string);
 811   if (item->instance == NULL)
 812   {
 813     ERROR ("powerdns plugin: strdup failed.");
 814     sfree (item);
 815     return (-1);
 816   }
 817
 818   /*
 819    * Set default values for the members of list_item_t
 820    */
 821   if (strcasecmp ("Server", ci->key) == 0)
 822   {
 823     item->server_type = SRV_AUTHORITATIVE;
 824     item->func = powerdns_read_server;
 825     item->socktype = SOCK_STREAM;
 826     socket_temp = strdup (SERVER_SOCKET);
 827   }
 828   else if (strcasecmp ("Recursor", ci->key) == 0)
 829   {
 830     item->server_type = SRV_RECURSOR;
 831     item->func = powerdns_read_recursor;
 832     item->socktype = SOCK_DGRAM;
 833     socket_temp = strdup (RECURSOR_SOCKET);
 834   }
 835   else
 836   {
 837     /* We must never get here.. */
 838     assert (0);
 839     return (-1);
 840   }
 841
 842   status = 0;
 843   for (i = 0; i < ci->children_num; i++)
 844   {
 845     oconfig_item_t *option = ci->children + i;
 846
 847     if (strcasecmp ("Collect", option->key) == 0)
 848       status = powerdns_config_add_collect (item, option);
 849     else if (strcasecmp ("Socket", option->key) == 0)
 850       status = cf_util_get_string (option, &socket_temp);
 851     else
 852     {
 853       ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
 854       status = -1;
 855     }
 856
 857     if (status != 0)
 858       break;
 859   }
 860
 861   while (status == 0)
 862   {
 863     llentry_t *e;
 864
 865     if (socket_temp == NULL)
 866     {
 867       ERROR ("powerdns plugin: socket_temp == NULL.");
 868       status = -1;
 869       break;
 870     }
 871
 872     item->sockaddr.sun_family = AF_UNIX;
 873     sstrncpy (item->sockaddr.sun_path, socket_temp,
 874       sizeof (item->sockaddr.sun_path));
 875
 876     e = llentry_create (item->instance, item);
 877     if (e == NULL)
 878     {
 879       ERROR ("powerdns plugin: llentry_create failed.");
 880       status = -1;
 881       break;
 882     }
 883     llist_append (list, e);
 884
 885     break;
 886   }
 887
 888   if (status != 0)
 889   {
 890     sfree (socket_temp);
 891     sfree (item);
 892     return (-1);
 893   }
 894
 895   DEBUG ("powerdns plugin: Add server: instance = %s;", item->instance);
 896
 897   sfree (socket_temp);
 898   return (0);
 899 } /* }}} int powerdns_config_add_server */
 900
 901 static int powerdns_config (oconfig_item_t *ci) /* {{{ */
 902 {
 903   int i;
 904
 905   DEBUG ("powerdns plugin: powerdns_config (ci = %p);", (void *) ci);
 906
 907   if (list == NULL)
 908   {
 909     list = llist_create ();
 910
 911     if (list == NULL)
 912     {
 913       ERROR ("powerdns plugin: `llist_create' failed.");
 914       return (-1);
 915     }
 916   }
 917
 918   for (i = 0; i < ci->children_num; i++)
 919   {
 920     oconfig_item_t *option = ci->children + i;
 921
 922     if ((strcasecmp ("Server", option->key) == 0)
 923         || (strcasecmp ("Recursor", option->key) == 0))
 924       powerdns_config_add_server (option);
 925     else if (strcasecmp ("LocalSocket", option->key) == 0)
 926     {
 927       if ((option->values_num != 1) || (option->values[0].type != OCONFIG_TYPE_STRING))
 928       {
 929         WARNING ("powerdns plugin: `%s' needs exactly one string argument.", option->key);
 930       }
 931       else
 932       {
 933         char *temp = strdup (option->values[0].value.string);
 934         if (temp == NULL)
 935           return (1);
 936         sfree (local_sockpath);
 937         local_sockpath = temp;
 938       }
 939     }
 940     else
 941     {
 942       ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
 943     }
 944   } /* for (i = 0; i < ci->children_num; i++) */
 945
 946   return (0);
 947 } /* }}} int powerdns_config */
 948
 949 static int powerdns_read (void)
 950 {
 951   llentry_t *e;
 952
 953   for (e = llist_head (list); e != NULL; e = e->next)
 954   {
 955     list_item_t *item = e->value;
 956     item->func (item);
 957   }
 958
 959   return (0);
 960 } /* static int powerdns_read */
 961
 962 static int powerdns_shutdown (void)
 963 {
 964   llentry_t *e;
 965
 966   if (list == NULL)
 967     return (0);
 968
 969   for (e = llist_head (list); e != NULL; e = e->next)
 970   {
 971     list_item_t *item = (list_item_t *) e->value;
 972     e->value = NULL;
 973
 974     sfree (item->instance);
 975     sfree (item->command);
 976     sfree (item);
 977   }
 978
 979   llist_destroy (list);
 980   list = NULL;
 981
 982   return (0);
 983 } /* static int powerdns_shutdown */
 984
 985 void module_register (void)
 986 {
 987   plugin_register_complex_config ("powerdns", powerdns_config);
 988   plugin_register_read ("powerdns", powerdns_read);
 989   plugin_register_shutdown ("powerdns", powerdns_shutdown );
 990 } /* void module_register */
 991
 992 /* vim: set sw=2 sts=2 ts=8 fdm=marker : */