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 verplant.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 milisecond
  88 answers100-1000     counts the number of queries answered within 1 second
  89 answers10-100       counts the number of queries answered within 100 miliseconds
  90 answers1-10         counts the number of queries answered within 10 miliseconds
  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
 151   /* Answers */
 152   {"recursing-answers",      "dns_answer",   "recurse"},
 153   {"tcp-answers",            "dns_answer",   "tcp"},
 154   {"udp-answers",            "dns_answer",   "udp"},
 155
 156   /* Cache stuff */
 157   {"packetcache-hit",        "cache_result", "packet-hit"},
 158   {"packetcache-miss",       "cache_result", "packet-miss"},
 159   {"packetcache-size",       "cache_size",   "packet"},
 160   {"query-cache-hit",        "cache_result", "query-hit"},
 161   {"query-cache-miss",       "cache_result", "query-miss"},
 162
 163   /* Latency */
 164   {"latency",                "latency",      NULL},
 165
 166   /* Other stuff.. */
 167   {"corrupt-packets",        "ipt_packets",  "corrupt"},
 168   {"deferred-cache-inserts", "counter",      "cache-deferred_insert"},
 169   {"deferred-cache-lookup",  "counter",      "cache-deferred_lookup"},
 170   {"qsize-a",                "cache_size",   "answers"},
 171   {"qsize-q",                "cache_size",   "questions"},
 172   {"servfail-packets",       "ipt_packets",  "servfail"},
 173   {"timedout-packets",       "ipt_packets",  "timeout"},
 174   {"udp4-answers",           "dns_answer",   "udp4"},
 175   {"udp4-queries",           "dns_question", "queries-udp4"},
 176   {"udp6-answers",           "dns_answer",   "udp6"},
 177   {"udp6-queries",           "dns_question", "queries-udp6"},
 178
 179   /***********************
 180    * Recursor statistics *
 181    ***********************/
 182   /* Answers by return code */
 183   {"noerror-answers",     "dns_rcode",    "NOERROR"},
 184   {"nxdomain-answers",    "dns_rcode",    "NXDOMAIN"},
 185   {"servfail-answers",    "dns_rcode",    "SERVFAIL"},
 186
 187   /* CPU utilization */
 188   {"sys-msec",            "cpu",          "system"},
 189   {"user-msec",           "cpu",          "user"},
 190
 191   /* Question-to-answer latency */
 192   {"qa-latency",          "latency",      NULL},
 193
 194   /* Cache */
 195   {"cache-entries",       "cache_size",   NULL},
 196   {"cache-hits",          "cache_result", "hit"},
 197   {"cache-misses",        "cache_result", "miss"},
 198
 199   /* Total number of questions.. */
 200   {"questions",           "dns_qtype",    "total"},
 201
 202   /* All the other stuff.. */
 203   {"all-outqueries",      "dns_question", "outgoing"},
 204   {"answers0-1",          "dns_answer",   "0_1"},
 205   {"answers1-10",         "dns_answer",   "1_10"},
 206   {"answers10-100",       "dns_answer",   "10_100"},
 207   {"answers100-1000",     "dns_answer",   "100_1000"},
 208   {"answers-slow",        "dns_answer",   "slow"},
 209   {"chain-resends",       "dns_question", "chained"},
 210   {"client-parse-errors", "counter",      "drops-client_parse_error"},
 211   {"concurrent-queries",  "dns_question", "concurrent"},
 212   {"dlg-only-drops",      "counter",      "drops-delegation_only"},
 213   {"negcache-entries",    "cache_size",   "negative"},
 214   {"nsspeeds-entries",    "gauge",        "entries-ns_speeds"},
 215   {"nsset-invalidations", "counter",      "ns_set_invalidation"},
 216   {"outgoing-timeouts",   "counter",      "drops-timeout_outgoing"},
 217   {"resource-limits",     "counter",      "drops-resource_limit"},
 218   {"server-parse-errors", "counter",      "drops-server_parse_error"},
 219   {"spoof-prevents",      "counter",      "drops-spoofed"},
 220   {"tcp-client-overflow", "counter",      "denied-client_overflow_tcp"},
 221   {"tcp-outqueries",      "dns_question", "outgoing-tcp"},
 222   {"tcp-questions",       "dns_question", "incoming-tcp"},
 223   {"throttled-out",       "dns_question", "outgoing-throttled"},
 224   {"throttle-entries",    "gauge",        "entries-throttle"},
 225   {"unauthorized-tcp",    "counter",      "denied-unauthorized_tcp"},
 226   {"unauthorized-udp",    "counter",      "denied-unauthorized_udp"},
 227   {"unexpected-packets",  "dns_answer",   "unexpected"}
 228   /* {"uptime", "", ""} */
 229 }; /* }}} */
 230 int lookup_table_length = STATIC_ARRAY_SIZE (lookup_table);
 231
 232 static llist_t *list = NULL;
 233
 234 #define PDNS_LOCAL_SOCKPATH LOCALSTATEDIR"/run/"PACKAGE_NAME"-powerdns"
 235 static char *local_sockpath = NULL;
 236
 237 /* TODO: Do this before 4.4:
 238  * - Recursor:
 239  *   - Complete list of known pdns -> collectd mappings.
 240  * - Update the collectd.conf(5) manpage.
 241  *
 242  * -octo
 243  */
 244
 245 /* <http://doc.powerdns.com/recursor-stats.html> */
 246 static void submit (const char *plugin_instance, /* {{{ */
 247     const char *pdns_type, const char *value)
 248 {
 249   value_list_t vl = VALUE_LIST_INIT;
 250   value_t values[1];
 251
 252   const char *type = NULL;
 253   const char *type_instance = NULL;
 254   const data_set_t *ds;
 255
 256   int i;
 257
 258   for (i = 0; i < lookup_table_length; i++)
 259     if (strcmp (lookup_table[i].name, pdns_type) == 0)
 260       break;
 261
 262   if (lookup_table[i].type == NULL)
 263     return;
 264
 265   if (i >= lookup_table_length)
 266   {
 267     INFO ("powerdns plugin: submit: Not found in lookup table: %s = %s;",
 268         pdns_type, value);
 269     return;
 270   }
 271
 272   type = lookup_table[i].type;
 273   type_instance = lookup_table[i].type_instance;
 274
 275   ds = plugin_get_ds (type);
 276   if (ds == NULL)
 277   {
 278     ERROR ("powerdns plugin: The lookup table returned type `%s', "
 279         "but I cannot find it via `plugin_get_ds'.",
 280         type);
 281     return;
 282   }
 283
 284   if (ds->ds_num != 1)
 285   {
 286     ERROR ("powerdns plugin: type `%s' has %i data sources, "
 287         "but I can only handle one.",
 288         type, ds->ds_num);
 289     return;
 290   }
 291
 292   if (0 != parse_value (value, &values[0], ds->ds[0].type))
 293   {
 294     ERROR ("powerdns plugin: Cannot convert `%s' "
 295         "to a number.", value);
 296     return;
 297   }
 298
 299   vl.values = values;
 300   vl.values_len = 1;
 301   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 302   sstrncpy (vl.plugin, "powerdns", sizeof (vl.plugin));
 303   sstrncpy (vl.type, type, sizeof (vl.type));
 304   if (type_instance != NULL)
 305     sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 306   sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
 307
 308   plugin_dispatch_values (&vl);
 309 } /* }}} static void submit */
 310
 311 static int powerdns_get_data_dgram (list_item_t *item, /* {{{ */
 312     char **ret_buffer,
 313     size_t *ret_buffer_size)
 314 {
 315   int sd;
 316   int status;
 317
 318   char temp[4096];
 319   char *buffer = NULL;
 320   size_t buffer_size = 0;
 321
 322   struct sockaddr_un sa_unix;
 323
 324   struct timeval stv_timeout;
 325   cdtime_t cdt_timeout;
 326
 327   sd = socket (PF_UNIX, item->socktype, 0);
 328   if (sd < 0)
 329   {
 330     FUNC_ERROR ("socket");
 331     return (-1);
 332   }
 333
 334   memset (&sa_unix, 0, sizeof (sa_unix));
 335   sa_unix.sun_family = AF_UNIX;
 336   sstrncpy (sa_unix.sun_path,
 337       (local_sockpath != NULL) ? local_sockpath : PDNS_LOCAL_SOCKPATH,
 338       sizeof (sa_unix.sun_path));
 339
 340   status = unlink (sa_unix.sun_path);
 341   if ((status != 0) && (errno != ENOENT))
 342   {
 343     FUNC_ERROR ("unlink");
 344     close (sd);
 345     return (-1);
 346   }
 347
 348   do /* while (0) */
 349   {
 350     /* We need to bind to a specific path, because this is a datagram socket
 351      * and otherwise the daemon cannot answer. */
 352     status = bind (sd, (struct sockaddr *) &sa_unix, sizeof (sa_unix));
 353     if (status != 0)
 354     {
 355       FUNC_ERROR ("bind");
 356       break;
 357     }
 358
 359     /* Make the socket writeable by the daemon.. */
 360     status = chmod (sa_unix.sun_path, 0666);
 361     if (status != 0)
 362     {
 363       FUNC_ERROR ("chmod");
 364       break;
 365     }
 366
 367     /* TODO: Remove the macro once interval_g is of type cdtime_t. */
 368     cdt_timeout = TIME_T_TO_CDTIME_T (interval_g);
 369     cdt_timeout = cdt_timeout * 3 / 4;
 370     if (cdt_timeout < TIME_T_TO_CDTIME_T (2))
 371       cdt_timeout = TIME_T_TO_CDTIME_T (2);
 372
 373     CDTIME_T_TO_TIMEVAL (cdt_timeout, &stv_timeout);
 374
 375     status = setsockopt (sd, SOL_SOCKET, SO_RCVTIMEO, &stv_timeout, sizeof (stv_timeout));
 376     if (status != 0)
 377     {
 378       FUNC_ERROR ("setsockopt");
 379       break;
 380     }
 381
 382     status = connect (sd, (struct sockaddr *) &item->sockaddr,
 383         sizeof (item->sockaddr));
 384     if (status != 0)
 385     {
 386       FUNC_ERROR ("connect");
 387       break;
 388     }
 389
 390     status = send (sd, item->command, strlen (item->command), 0);
 391     if (status < 0)
 392     {
 393       FUNC_ERROR ("send");
 394       break;
 395     }
 396
 397     status = recv (sd, temp, sizeof (temp), /* flags = */ 0);
 398     if (status < 0)
 399     {
 400       FUNC_ERROR ("recv");
 401       break;
 402     }
 403     buffer_size = status + 1;
 404     status = 0;
 405   } while (0);
 406
 407   close (sd);
 408   unlink (sa_unix.sun_path);
 409
 410   if (status != 0)
 411     return (-1);
 412
 413   assert (buffer_size > 0);
 414   buffer = (char *) malloc (buffer_size);
 415   if (buffer == NULL)
 416   {
 417     FUNC_ERROR ("malloc");
 418     return (-1);
 419   }
 420
 421   memcpy (buffer, temp, buffer_size - 1);
 422   buffer[buffer_size - 1] = 0;
 423
 424   *ret_buffer = buffer;
 425   *ret_buffer_size = buffer_size;
 426
 427   return (0);
 428 } /* }}} int powerdns_get_data_dgram */
 429
 430 static int powerdns_get_data_stream (list_item_t *item, /* {{{ */
 431     char **ret_buffer,
 432     size_t *ret_buffer_size)
 433 {
 434   int sd;
 435   int status;
 436
 437   char temp[4096];
 438   char *buffer = NULL;
 439   size_t buffer_size = 0;
 440
 441   sd = socket (PF_UNIX, item->socktype, 0);
 442   if (sd < 0)
 443   {
 444     FUNC_ERROR ("socket");
 445     return (-1);
 446   }
 447
 448   struct timeval timeout;
 449   timeout.tv_sec=5;
 450   timeout.tv_usec=0;
 451   status = setsockopt (sd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof (timeout));
 452
 453   status = connect (sd, (struct sockaddr *) &item->sockaddr,
 454       sizeof (item->sockaddr));
 455   if (status != 0)
 456   {
 457     FUNC_ERROR ("connect");
 458     close (sd);
 459     return (-1);
 460   }
 461
 462   /* strlen + 1, because we need to send the terminating NULL byte, too. */
 463   status = send (sd, item->command, strlen (item->command) + 1,
 464       /* flags = */ 0);
 465   if (status < 0)
 466   {
 467     FUNC_ERROR ("send");
 468     close (sd);
 469     return (-1);
 470   }
 471
 472   while (42)
 473   {
 474     char *buffer_new;
 475
 476     status = recv (sd, temp, sizeof (temp), /* flags = */ 0);
 477     if (status < 0)
 478     {
 479       FUNC_ERROR ("recv");
 480       break;
 481     }
 482     else if (status == 0)
 483       break;
 484
 485     buffer_new = (char *) realloc (buffer, buffer_size + status + 1);
 486     if (buffer_new == NULL)
 487     {
 488       FUNC_ERROR ("realloc");
 489       status = -1;
 490       break;
 491     }
 492     buffer = buffer_new;
 493
 494     memcpy (buffer + buffer_size, temp, status);
 495     buffer_size += status;
 496     buffer[buffer_size] = 0;
 497   } /* while (42) */
 498   close (sd);
 499   sd = -1;
 500
 501   if (status < 0)
 502   {
 503     sfree (buffer);
 504   }
 505   else
 506   {
 507     assert (status == 0);
 508     *ret_buffer = buffer;
 509     *ret_buffer_size = buffer_size;
 510   }
 511
 512   return (status);
 513 } /* }}} int powerdns_get_data_stream */
 514
 515 static int powerdns_get_data (list_item_t *item, char **ret_buffer,
 516     size_t *ret_buffer_size)
 517 {
 518   if (item->socktype == SOCK_DGRAM)
 519     return (powerdns_get_data_dgram (item, ret_buffer, ret_buffer_size));
 520   else if (item->socktype == SOCK_STREAM)
 521     return (powerdns_get_data_stream (item, ret_buffer, ret_buffer_size));
 522   else
 523   {
 524     ERROR ("powerdns plugin: Unknown socket type: %i", (int) item->socktype);
 525     return (-1);
 526   }
 527 } /* int powerdns_get_data */
 528
 529 static int powerdns_read_server (list_item_t *item) /* {{{ */
 530 {
 531   char *buffer = NULL;
 532   size_t buffer_size = 0;
 533   int status;
 534
 535   char *dummy;
 536   char *saveptr;
 537
 538   char *key;
 539   char *value;
 540
 541   const char* const *fields;
 542   int fields_num;
 543
 544   if (item->command == NULL)
 545     item->command = strdup (SERVER_COMMAND);
 546   if (item->command == NULL)
 547   {
 548     ERROR ("powerdns plugin: strdup failed.");
 549     return (-1);
 550   }
 551
 552   status = powerdns_get_data (item, &buffer, &buffer_size);
 553   if (status != 0)
 554     return (-1);
 555
 556   if (item->fields_num != 0)
 557   {
 558     fields = (const char* const *) item->fields;
 559     fields_num = item->fields_num;
 560   }
 561   else
 562   {
 563     fields = default_server_fields;
 564     fields_num = default_server_fields_num;
 565   }
 566
 567   assert (fields != NULL);
 568   assert (fields_num > 0);
 569
 570   /* 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, */
 571   dummy = buffer;
 572   saveptr = NULL;
 573   while ((key = strtok_r (dummy, ",", &saveptr)) != NULL)
 574   {
 575     int i;
 576
 577     dummy = NULL;
 578
 579     value = strchr (key, '=');
 580     if (value == NULL)
 581       break;
 582
 583     *value = '\0';
 584     value++;
 585
 586     if (value[0] == '\0')
 587       continue;
 588
 589     /* Check if this item was requested. */
 590     for (i = 0; i < fields_num; i++)
 591       if (strcasecmp (key, fields[i]) == 0)
 592         break;
 593     if (i >= fields_num)
 594       continue;
 595
 596     submit (item->instance, key, value);
 597   } /* while (strtok_r) */
 598
 599   sfree (buffer);
 600
 601   return (0);
 602 } /* }}} int powerdns_read_server */
 603
 604 /*
 605  * powerdns_update_recursor_command
 606  *
 607  * Creates a string that holds the command to be sent to the recursor. This
 608  * string is stores in the `command' member of the `list_item_t' passed to the
 609  * function. This function is called by `powerdns_read_recursor'.
 610  */
 611 static int powerdns_update_recursor_command (list_item_t *li) /* {{{ */
 612 {
 613   char buffer[4096];
 614   int status;
 615
 616   if (li == NULL)
 617     return (0);
 618
 619   if (li->fields_num < 1)
 620   {
 621     sstrncpy (buffer, RECURSOR_COMMAND, sizeof (buffer));
 622   }
 623   else
 624   {
 625     sstrncpy (buffer, "get ", sizeof (buffer));
 626     status = strjoin (&buffer[strlen("get ")], sizeof (buffer) - strlen ("get "),
 627         li->fields, li->fields_num,
 628         /* seperator = */ " ");
 629     if (status < 0)
 630     {
 631       ERROR ("powerdns plugin: strjoin failed.");
 632       return (-1);
 633     }
 634     buffer[sizeof (buffer) - 1] = 0;
 635     int i = strlen (buffer);
 636     if (i < sizeof (buffer) - 2)
 637     {
 638       buffer[i++] = ' ';
 639       buffer[i++] = '\n';
 640       buffer[i++] = '\0';
 641     }
 642   }
 643
 644   buffer[sizeof (buffer) - 1] = 0;
 645   li->command = strdup (buffer);
 646   if (li->command == NULL)
 647   {
 648     ERROR ("powerdns plugin: strdup failed.");
 649     return (-1);
 650   }
 651
 652   return (0);
 653 } /* }}} int powerdns_update_recursor_command */
 654
 655 static int powerdns_read_recursor (list_item_t *item) /* {{{ */
 656 {
 657   char *buffer = NULL;
 658   size_t buffer_size = 0;
 659   int status;
 660
 661   char *dummy;
 662
 663   char *keys_list;
 664   char *key;
 665   char *key_saveptr;
 666   char *value;
 667   char *value_saveptr;
 668
 669   if (item->command == NULL)
 670   {
 671     status = powerdns_update_recursor_command (item);
 672     if (status != 0)
 673     {
 674       ERROR ("powerdns plugin: powerdns_update_recursor_command failed.");
 675       return (-1);
 676     }
 677
 678     DEBUG ("powerdns plugin: powerdns_read_recursor: item->command = %s;",
 679         item->command);
 680   }
 681   assert (item->command != NULL);
 682
 683   status = powerdns_get_data (item, &buffer, &buffer_size);
 684   if (status != 0)
 685   {
 686     ERROR ("powerdns plugin: powerdns_get_data failed.");
 687     return (-1);
 688   }
 689
 690   keys_list = strdup (item->command);
 691   if (keys_list == NULL)
 692   {
 693     FUNC_ERROR ("strdup");
 694     sfree (buffer);
 695     return (-1);
 696   }
 697
 698   key_saveptr = NULL;
 699   value_saveptr = NULL;
 700
 701   /* Skip the `get' at the beginning */
 702   strtok_r (keys_list, " \t", &key_saveptr);
 703
 704   dummy = buffer;
 705   while ((value = strtok_r (dummy, " \t\n\r", &value_saveptr)) != NULL)
 706   {
 707     dummy = NULL;
 708
 709     key = strtok_r (NULL, " \t", &key_saveptr);
 710     if (key == NULL)
 711       break;
 712
 713     submit (item->instance, key, value);
 714   } /* while (strtok_r) */
 715
 716   sfree (buffer);
 717   sfree (keys_list);
 718
 719   return (0);
 720 } /* }}} int powerdns_read_recursor */
 721
 722 static int powerdns_config_add_string (const char *name, /* {{{ */
 723     char **dest,
 724     oconfig_item_t *ci)
 725 {
 726   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
 727   {
 728     WARNING ("powerdns plugin: `%s' needs exactly one string argument.",
 729         name);
 730     return (-1);
 731   }
 732
 733   sfree (*dest);
 734   *dest = strdup (ci->values[0].value.string);
 735   if (*dest == NULL)
 736     return (-1);
 737
 738   return (0);
 739 } /* }}} int powerdns_config_add_string */
 740
 741 static int powerdns_config_add_collect (list_item_t *li, /* {{{ */
 742     oconfig_item_t *ci)
 743 {
 744   int i;
 745   char **temp;
 746
 747   if (ci->values_num < 1)
 748   {
 749     WARNING ("powerdns plugin: The `Collect' option needs "
 750         "at least one argument.");
 751     return (-1);
 752   }
 753
 754   for (i = 0; i < ci->values_num; i++)
 755     if (ci->values[i].type != OCONFIG_TYPE_STRING)
 756     {
 757       WARNING ("powerdns plugin: Only string arguments are allowed to "
 758           "the `Collect' option.");
 759       return (-1);
 760     }
 761
 762   temp = (char **) realloc (li->fields,
 763       sizeof (char *) * (li->fields_num + ci->values_num));
 764   if (temp == NULL)
 765   {
 766     WARNING ("powerdns plugin: realloc failed.");
 767     return (-1);
 768   }
 769   li->fields = temp;
 770
 771   for (i = 0; i < ci->values_num; i++)
 772   {
 773     li->fields[li->fields_num] = strdup (ci->values[i].value.string);
 774     if (li->fields[li->fields_num] == NULL)
 775     {
 776       WARNING ("powerdns plugin: strdup failed.");
 777       continue;
 778     }
 779     li->fields_num++;
 780   }
 781
 782   /* Invalidate a previously computed command */
 783   sfree (li->command);
 784
 785   return (0);
 786 } /* }}} int powerdns_config_add_collect */
 787
 788 static int powerdns_config_add_server (oconfig_item_t *ci) /* {{{ */
 789 {
 790   char *socket_temp;
 791
 792   list_item_t *item;
 793   int status;
 794   int i;
 795
 796   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
 797   {
 798     WARNING ("powerdns plugin: `%s' needs exactly one string argument.",
 799         ci->key);
 800     return (-1);
 801   }
 802
 803   item = (list_item_t *) malloc (sizeof (list_item_t));
 804   if (item == NULL)
 805   {
 806     ERROR ("powerdns plugin: malloc failed.");
 807     return (-1);
 808   }
 809   memset (item, '\0', sizeof (list_item_t));
 810
 811   item->instance = strdup (ci->values[0].value.string);
 812   if (item->instance == NULL)
 813   {
 814     ERROR ("powerdns plugin: strdup failed.");
 815     sfree (item);
 816     return (-1);
 817   }
 818
 819   /*
 820    * Set default values for the members of list_item_t
 821    */
 822   if (strcasecmp ("Server", ci->key) == 0)
 823   {
 824     item->server_type = SRV_AUTHORITATIVE;
 825     item->func = powerdns_read_server;
 826     item->socktype = SOCK_STREAM;
 827     socket_temp = strdup (SERVER_SOCKET);
 828   }
 829   else if (strcasecmp ("Recursor", ci->key) == 0)
 830   {
 831     item->server_type = SRV_RECURSOR;
 832     item->func = powerdns_read_recursor;
 833     item->socktype = SOCK_DGRAM;
 834     socket_temp = strdup (RECURSOR_SOCKET);
 835   }
 836   else
 837   {
 838     /* We must never get here.. */
 839     assert (0);
 840     return (-1);
 841   }
 842
 843   status = 0;
 844   for (i = 0; i < ci->children_num; i++)
 845   {
 846     oconfig_item_t *option = ci->children + i;
 847
 848     if (strcasecmp ("Collect", option->key) == 0)
 849       status = powerdns_config_add_collect (item, option);
 850     else if (strcasecmp ("Socket", option->key) == 0)
 851       status = powerdns_config_add_string ("Socket", &socket_temp, option);
 852     else
 853     {
 854       ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
 855       status = -1;
 856     }
 857
 858     if (status != 0)
 859       break;
 860   }
 861
 862   while (status == 0)
 863   {
 864     llentry_t *e;
 865
 866     if (socket_temp == NULL)
 867     {
 868       ERROR ("powerdns plugin: socket_temp == NULL.");
 869       status = -1;
 870       break;
 871     }
 872
 873     item->sockaddr.sun_family = AF_UNIX;
 874     sstrncpy (item->sockaddr.sun_path, socket_temp,
 875       sizeof (item->sockaddr.sun_path));
 876
 877     e = llentry_create (item->instance, item);
 878     if (e == NULL)
 879     {
 880       ERROR ("powerdns plugin: llentry_create failed.");
 881       status = -1;
 882       break;
 883     }
 884     llist_append (list, e);
 885
 886     break;
 887   }
 888
 889   if (status != 0)
 890   {
 891     sfree (item);
 892     return (-1);
 893   }
 894
 895   DEBUG ("powerdns plugin: Add server: instance = %s;", item->instance);
 896
 897   return (0);
 898 } /* }}} int powerdns_config_add_server */
 899
 900 static int powerdns_config (oconfig_item_t *ci) /* {{{ */
 901 {
 902   int i;
 903
 904   DEBUG ("powerdns plugin: powerdns_config (ci = %p);", (void *) ci);
 905
 906   if (list == NULL)
 907   {
 908     list = llist_create ();
 909
 910     if (list == NULL)
 911     {
 912       ERROR ("powerdns plugin: `llist_create' failed.");
 913       return (-1);
 914     }
 915   }
 916
 917   for (i = 0; i < ci->children_num; i++)
 918   {
 919     oconfig_item_t *option = ci->children + i;
 920
 921     if ((strcasecmp ("Server", option->key) == 0)
 922         || (strcasecmp ("Recursor", option->key) == 0))
 923       powerdns_config_add_server (option);
 924     else if (strcasecmp ("LocalSocket", option->key) == 0)
 925     {
 926       if ((option->values_num != 1) || (option->values[0].type != OCONFIG_TYPE_STRING))
 927       {
 928         WARNING ("powerdns plugin: `%s' needs exactly one string argument.", option->key);
 929       }
 930       else
 931       {
 932         char *temp = strdup (option->values[0].value.string);
 933         if (temp == NULL)
 934           return (1);
 935         sfree (local_sockpath);
 936         local_sockpath = temp;
 937       }
 938     }
 939     else
 940     {
 941       ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
 942     }
 943   } /* for (i = 0; i < ci->children_num; i++) */
 944
 945   return (0);
 946 } /* }}} int powerdns_config */
 947
 948 static int powerdns_read (void)
 949 {
 950   llentry_t *e;
 951
 952   for (e = llist_head (list); e != NULL; e = e->next)
 953   {
 954     list_item_t *item = e->value;
 955     item->func (item);
 956   }
 957
 958   return (0);
 959 } /* static int powerdns_read */
 960
 961 static int powerdns_shutdown (void)
 962 {
 963   llentry_t *e;
 964
 965   if (list == NULL)
 966     return (0);
 967
 968   for (e = llist_head (list); e != NULL; e = e->next)
 969   {
 970     list_item_t *item = (list_item_t *) e->value;
 971     e->value = NULL;
 972
 973     sfree (item->instance);
 974     sfree (item->command);
 975     sfree (item);
 976   }
 977
 978   llist_destroy (list);
 979   list = NULL;
 980
 981   return (0);
 982 } /* static int powerdns_shutdown */
 983
 984 void module_register (void)
 985 {
 986   plugin_register_complex_config ("powerdns", powerdns_config);
 987   plugin_register_read ("powerdns", powerdns_read);
 988   plugin_register_shutdown ("powerdns", powerdns_shutdown );
 989 } /* void module_register */
 990
 991 /* vim: set sw=2 sts=2 ts=8 fdm=marker : */