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  "/var/run/pdns.controlsocket"
  49 #define SERVER_COMMAND "SHOW *"
  50
  51 #define RECURSOR_SOCKET  "/var/run/pdns_recursor.controlsocket"
  52 #define RECURSOR_COMMAND "get all-outqueries answers0-1 " /* {{{ */ \
  53   "answers100-1000 answers10-100 answers1-10 answers-slow cache-entries " \
  54   "cache-hits cache-misses chain-resends client-parse-errors " \
  55   "concurrent-queries dlg-only-drops ipv6-outqueries negcache-entries " \
  56   "noerror-answers nsset-invalidations nsspeeds-entries nxdomain-answers " \
  57   "outgoing-timeouts qa-latency questions resource-limits " \
  58   "server-parse-errors servfail-answers spoof-prevents sys-msec " \
  59   "tcp-client-overflow tcp-outqueries tcp-questions throttled-out " \
  60   "throttled-outqueries throttle-entries unauthorized-tcp unauthorized-udp " \
  61   "unexpected-packets unreachables user-msec" /* }}} */
  62
  63 struct list_item_s;
  64 typedef struct list_item_s list_item_t;
  65
  66 struct list_item_s
  67 {
  68   int (*func) (list_item_t *item);
  69   char *instance;
  70   char *command;
  71   struct sockaddr_un sockaddr;
  72   int socktype;
  73 };
  74
  75 struct statname_lookup_s
  76 {
  77   char *name;
  78   char *type;
  79   char *type_instance;
  80 };
  81 typedef struct statname_lookup_s statname_lookup_t;
  82
  83 /* Description of statistics returned by the recursor: {{{
  84 all-outqueries      counts the number of outgoing UDP queries since starting
  85 answers0-1          counts the number of queries answered within 1 milisecond
  86 answers100-1000     counts the number of queries answered within 1 second
  87 answers10-100       counts the number of queries answered within 100 miliseconds
  88 answers1-10         counts the number of queries answered within 10 miliseconds
  89 answers-slow        counts the number of queries answered after 1 second
  90 cache-entries       shows the number of entries in the cache
  91 cache-hits          counts the number of cache hits since starting
  92 cache-misses        counts the number of cache misses since starting
  93 chain-resends       number of queries chained to existing outstanding query
  94 client-parse-errors counts number of client packets that could not be parsed
  95 concurrent-queries  shows the number of MThreads currently running
  96 dlg-only-drops      number of records dropped because of delegation only setting
  97 negcache-entries    shows the number of entries in the Negative answer cache
  98 noerror-answers     counts the number of times it answered NOERROR since starting
  99 nsspeeds-entries    shows the number of entries in the NS speeds map
 100 nsset-invalidations number of times an nsset was dropped because it no longer worked
 101 nxdomain-answers    counts the number of times it answered NXDOMAIN since starting
 102 outgoing-timeouts   counts the number of timeouts on outgoing UDP queries since starting
 103 qa-latency          shows the current latency average
 104 questions           counts all End-user initiated queries with the RD bit set
 105 resource-limits     counts number of queries that could not be performed because of resource limits
 106 server-parse-errors counts number of server replied packets that could not be parsed
 107 servfail-answers    counts the number of times it answered SERVFAIL since starting
 108 spoof-prevents      number of times PowerDNS considered itself spoofed, and dropped the data
 109 sys-msec            number of CPU milliseconds spent in 'system' mode
 110 tcp-client-overflow number of times an IP address was denied TCP access because it already had too many connections
 111 tcp-outqueries      counts the number of outgoing TCP queries since starting
 112 tcp-questions       counts all incoming TCP queries (since starting)
 113 throttled-out       counts the number of throttled outgoing UDP queries since starting
 114 throttle-entries    shows the number of entries in the throttle map
 115 unauthorized-tcp    number of TCP questions denied because of allow-from restrictions
 116 unauthorized-udp    number of UDP questions denied because of allow-from restrictions
 117 unexpected-packets  number of answers from remote servers that were unexpected (might point to spoofing)
 118 uptime              number of seconds process has been running (since 3.1.5)
 119 user-msec           number of CPU milliseconds spent in 'user' mode
 120 }}} */
 121
 122 statname_lookup_t lookup_table[] = /* {{{ */
 123 {
 124   /*
 125    * Recursor statistics
 126    */
 127   /*
 128    * corrupt-packets
 129    * deferred-cache-inserts
 130    * deferred-cache-lookup
 131    * qsize-q
 132    * servfail-packets
 133    * timedout-packets
 134    * udp4-answers
 135    * udp4-queries
 136    * udp6-answers
 137    * udp6-queries
 138    */
 139   /* Questions */
 140   {"recursing-questions", "dns_question", "recurse"},
 141   {"tcp-queries",         "dns_question", "tcp"},
 142   {"udp-queries",         "dns_question", "udp"},
 143
 144   /* Answers */
 145   {"recursing-answers",   "dns_answer",   "recurse"},
 146   {"tcp-answers",         "dns_answer",   "tcp"},
 147   {"udp-answers",         "dns_answer",   "udp"},
 148
 149   /* Cache stuff */
 150   {"packetcache-hit",     "cache_result", "packet-hit"},
 151   {"packetcache-miss",    "cache_result", "packet-miss"},
 152   {"packetcache-size",    "cache_size",   "packet"},
 153   {"query-cache-hit",     "cache_result", "query-hit"},
 154   {"query-cache-miss",    "cache_result", "query-miss"},
 155
 156   /* Latency */
 157   {"latency",             "latency",      NULL},
 158
 159   /*
 160    * Recursor statistics
 161    */
 162   /* Answers by return code */
 163   {"noerror-answers",     "dns_rcode",    "NOERROR"},
 164   {"nxdomain-answers",    "dns_rcode",    "NXDOMAIN"},
 165   {"servfail-answers",    "dns_rcode",    "SERVFAIL"},
 166
 167   /* CPU utilization */
 168   {"sys-msec",            "cpu",          "system"},
 169   {"user-msec",           "cpu",          "user"},
 170
 171   /* Question-to-answer latency */
 172   {"qa-latency",          "latency",      NULL},
 173
 174   /* Cache */
 175   {"cache-entries",       "cache_size",   NULL},
 176   {"cache-hits",          "cache_result", "hit"},
 177   {"cache-misses",        "cache_result", "miss"},
 178
 179   /* Total number of questions.. */
 180   {"questions",           "dns_qtype",    "total"}
 181 }; /* }}} */
 182 int lookup_table_length = STATIC_ARRAY_SIZE (lookup_table);
 183
 184 static llist_t *list = NULL;
 185
 186 #define PDNS_LOCAL_SOCKPATH LOCALSTATEDIR"/run/"PACKAGE_NAME"-powerdns"
 187 static char *local_sockpath = NULL;
 188
 189 /* <http://doc.powerdns.com/recursor-stats.html> */
 190 static void submit (const char *plugin_instance, /* {{{ */
 191     const char *pdns_type, const char *value)
 192 {
 193   value_list_t vl = VALUE_LIST_INIT;
 194   value_t values[1];
 195
 196   const char *type = NULL;
 197   const char *type_instance = NULL;
 198   const data_set_t *ds;
 199
 200   int i;
 201
 202   for (i = 0; i < lookup_table_length; i++)
 203     if (strcmp (lookup_table[i].name, pdns_type) == 0)
 204       break;
 205
 206   if (lookup_table[i].type == NULL)
 207     return;
 208
 209   if (i >= lookup_table_length)
 210   {
 211     DEBUG ("powerdns plugin: submit: Not found in lookup table: %s = %s;",
 212         pdns_type, value);
 213     return;
 214   }
 215
 216   type = lookup_table[i].type;
 217   type_instance = lookup_table[i].type_instance;
 218
 219   ds = plugin_get_ds (type);
 220   if (ds == NULL)
 221   {
 222     ERROR ("powerdns plugin: The lookup table returned type `%s', "
 223         "but I cannot find it via `plugin_get_ds'.",
 224         type);
 225     return;
 226   }
 227
 228   if (ds->ds_num != 1)
 229   {
 230     ERROR ("powerdns plugin: type `%s' has %i data sources, "
 231         "but I can only handle one.",
 232         type, ds->ds_num);
 233     return;
 234   }
 235
 236   if (ds->ds[0].type == DS_TYPE_GAUGE)
 237   {
 238     char *endptr = NULL;
 239
 240     values[0].gauge = strtod (value, &endptr);
 241
 242     if (endptr == value)
 243     {
 244       ERROR ("powerdns plugin: Cannot convert `%s' "
 245           "to a floating point number.", value);
 246       return;
 247     }
 248   }
 249   else
 250   {
 251     char *endptr = NULL;
 252
 253     values[0].counter = strtoll (value, &endptr, 0);
 254     if (endptr == value)
 255     {
 256       ERROR ("powerdns plugin: Cannot convert `%s' "
 257           "to an integer number.", value);
 258       return;
 259     }
 260   }
 261
 262   vl.values = values;
 263   vl.values_len = 1;
 264   vl.time = time (NULL);
 265   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 266   sstrncpy (vl.plugin, "powerdns", sizeof (vl.plugin));
 267   sstrncpy (vl.type, type, sizeof (vl.type));
 268   if (type_instance != NULL)
 269     sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 270   sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
 271
 272   plugin_dispatch_values (&vl);
 273 } /* }}} static void submit */
 274
 275 static int powerdns_get_data_dgram (list_item_t *item, /* {{{ */
 276     char **ret_buffer,
 277     size_t *ret_buffer_size)
 278 {
 279   int sd;
 280   int status;
 281
 282   char temp[4096];
 283   char *buffer = NULL;
 284   size_t buffer_size = 0;
 285
 286   struct sockaddr_un sa_unix;
 287
 288   sd = socket (PF_UNIX, item->socktype, 0);
 289   if (sd < 0)
 290   {
 291     FUNC_ERROR ("socket");
 292     return (-1);
 293   }
 294
 295   memset (&sa_unix, 0, sizeof (sa_unix));
 296   sa_unix.sun_family = AF_UNIX;
 297   strncpy (sa_unix.sun_path,
 298       (local_sockpath != NULL) ? local_sockpath : PDNS_LOCAL_SOCKPATH,
 299       sizeof (sa_unix.sun_path));
 300   sa_unix.sun_path[sizeof (sa_unix.sun_path) - 1] = 0;
 301
 302   status = unlink (sa_unix.sun_path);
 303   if ((status != 0) && (errno != ENOENT))
 304   {
 305     FUNC_ERROR ("unlink");
 306     close (sd);
 307     return (-1);
 308   }
 309
 310   do /* while (0) */
 311   {
 312     /* We need to bind to a specific path, because this is a datagram socket
 313      * and otherwise the daemon cannot answer. */
 314     status = bind (sd, (struct sockaddr *) &sa_unix, sizeof (sa_unix));
 315     if (status != 0)
 316     {
 317       FUNC_ERROR ("bind");
 318       break;
 319     }
 320
 321     /* Make the socket writeable by the daemon.. */
 322     status = chmod (sa_unix.sun_path, 0666);
 323     if (status != 0)
 324     {
 325       FUNC_ERROR ("chmod");
 326       break;
 327     }
 328
 329     status = connect (sd, (struct sockaddr *) &item->sockaddr,
 330         sizeof (item->sockaddr));
 331     if (status != 0)
 332     {
 333       FUNC_ERROR ("connect");
 334       break;
 335     }
 336
 337     status = send (sd, item->command, strlen (item->command), 0);
 338     if (status < 0)
 339     {
 340       FUNC_ERROR ("send");
 341       break;
 342     }
 343
 344     status = recv (sd, temp, sizeof (temp), /* flags = */ 0);
 345     if (status < 0)
 346     {
 347       FUNC_ERROR ("recv");
 348       break;
 349     }
 350     status = 0;
 351   } while (0);
 352
 353   close (sd);
 354   unlink (sa_unix.sun_path);
 355
 356   if (status != 0)
 357     return (-1);
 358
 359   buffer_size = status + 1;
 360   buffer = (char *) malloc (buffer_size);
 361   if (buffer == NULL)
 362   {
 363     FUNC_ERROR ("malloc");
 364     return (-1);
 365   }
 366
 367   memcpy (buffer, temp, status);
 368   buffer[status] = 0;
 369
 370   *ret_buffer = buffer;
 371   *ret_buffer_size = buffer_size;
 372
 373   return (0);
 374 } /* }}} int powerdns_get_data_dgram */
 375
 376 static int powerdns_get_data_stream (list_item_t *item, /* {{{ */
 377     char **ret_buffer,
 378     size_t *ret_buffer_size)
 379 {
 380   int sd;
 381   int status;
 382
 383   char temp[4096];
 384   char *buffer = NULL;
 385   size_t buffer_size = 0;
 386
 387   sd = socket (PF_UNIX, item->socktype, 0);
 388   if (sd < 0)
 389   {
 390     FUNC_ERROR ("socket");
 391     return (-1);
 392   }
 393
 394   status = connect (sd, (struct sockaddr *) &item->sockaddr,
 395       sizeof (item->sockaddr));
 396   if (status != 0)
 397   {
 398     FUNC_ERROR ("connect");
 399     close (sd);
 400     return (-1);
 401   }
 402
 403   /* strlen + 1, because we need to send the terminating NULL byte, too. */
 404   status = send (sd, item->command, strlen (item->command) + 1,
 405       /* flags = */ 0);
 406   if (status < 0)
 407   {
 408     FUNC_ERROR ("send");
 409     close (sd);
 410     return (-1);
 411   }
 412
 413   while (42)
 414   {
 415     char *buffer_new;
 416
 417     status = recv (sd, temp, sizeof (temp), /* flags = */ 0);
 418     if (status < 0)
 419     {
 420       FUNC_ERROR ("recv");
 421       break;
 422     }
 423     else if (status == 0)
 424       break;
 425
 426     buffer_new = (char *) realloc (buffer, buffer_size + status + 1);
 427     if (buffer_new == NULL)
 428     {
 429       FUNC_ERROR ("realloc");
 430       status = -1;
 431       break;
 432     }
 433     buffer = buffer_new;
 434
 435     memcpy (buffer + buffer_size, temp, status);
 436     buffer_size += status;
 437     buffer[buffer_size] = 0;
 438   } /* while (42) */
 439   close (sd);
 440   sd = -1;
 441
 442   if (status < 0)
 443   {
 444     sfree (buffer);
 445   }
 446   else
 447   {
 448     assert (status == 0);
 449     *ret_buffer = buffer;
 450     *ret_buffer_size = buffer_size;
 451   }
 452
 453   return (status);
 454 } /* }}} int powerdns_get_data_stream */
 455
 456 static int powerdns_get_data (list_item_t *item, char **ret_buffer,
 457     size_t *ret_buffer_size)
 458 {
 459   if (item->socktype == SOCK_DGRAM)
 460     return (powerdns_get_data_dgram (item, ret_buffer, ret_buffer_size));
 461   else if (item->socktype == SOCK_STREAM)
 462     return (powerdns_get_data_stream (item, ret_buffer, ret_buffer_size));
 463   else
 464   {
 465     ERROR ("powerdns plugin: Unknown socket type: %i", (int) item->socktype);
 466     return (-1);
 467   }
 468 } /* int powerdns_get_data */
 469
 470 static int powerdns_read_server (list_item_t *item) /* {{{ */
 471 {
 472   char *buffer = NULL;
 473   size_t buffer_size = 0;
 474   int status;
 475
 476   char *dummy;
 477   char *saveptr;
 478
 479   char *key;
 480   char *value;
 481
 482   status = powerdns_get_data (item, &buffer, &buffer_size);
 483   if (status != 0)
 484     return (-1);
 485
 486   /* 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, */
 487   dummy = buffer;
 488   saveptr = NULL;
 489   while ((key = strtok_r (dummy, ",", &saveptr)) != NULL)
 490   {
 491     dummy = NULL;
 492
 493     value = strchr (key, '=');
 494     if (value == NULL)
 495       break;
 496
 497     *value = '\0';
 498     value++;
 499
 500     if (value[0] == '\0')
 501       continue;
 502
 503     submit (item->instance, key, value);
 504   } /* while (strtok_r) */
 505
 506   sfree (buffer);
 507
 508   return (0);
 509 } /* }}} int powerdns_read_server */
 510
 511 static int powerdns_read_recursor (list_item_t *item) /* {{{ */
 512 {
 513   char *buffer = NULL;
 514   size_t buffer_size = 0;
 515   int status;
 516
 517   char *dummy;
 518
 519   char *keys_list;
 520   char *key;
 521   char *key_saveptr;
 522   char *value;
 523   char *value_saveptr;
 524
 525   status = powerdns_get_data (item, &buffer, &buffer_size);
 526   if (status != 0)
 527     return (-1);
 528
 529   keys_list = strdup (item->command);
 530   if (keys_list == NULL)
 531   {
 532     FUNC_ERROR ("strdup");
 533     sfree (buffer);
 534     return (-1);
 535   }
 536
 537   key_saveptr = NULL;
 538   value_saveptr = NULL;
 539
 540   /* Skip the `get' at the beginning */
 541   strtok_r (keys_list, " \t", &key_saveptr);
 542
 543   dummy = buffer;
 544   while ((value = strtok_r (dummy, " \t\n\r", &value_saveptr)) != NULL)
 545   {
 546     dummy = NULL;
 547
 548     key = strtok_r (NULL, " \t", &key_saveptr);
 549     if (key == NULL)
 550       break;
 551
 552     submit (item->instance, key, value);
 553   } /* while (strtok_r) */
 554
 555   sfree (buffer);
 556   sfree (keys_list);
 557
 558   return (0);
 559 } /* }}} int powerdns_read_recursor */
 560
 561 static int powerdns_config_add_string (const char *name, /* {{{ */
 562     char **dest,
 563     oconfig_item_t *ci)
 564 {
 565   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
 566   {
 567     WARNING ("powerdns plugin: `%s' needs exactly one string argument.",
 568         name);
 569     return (-1);
 570   }
 571
 572   sfree (*dest);
 573   *dest = strdup (ci->values[0].value.string);
 574   if (*dest == NULL)
 575     return (-1);
 576
 577   return (0);
 578 } /* }}} int ctail_config_add_string */
 579
 580 static int powerdns_config_add_server (oconfig_item_t *ci) /* {{{ */
 581 {
 582   char *socket_temp;
 583
 584   list_item_t *item;
 585   int status;
 586   int i;
 587
 588   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
 589   {
 590     WARNING ("powerdns plugin: `%s' needs exactly one string argument.",
 591         ci->key);
 592     return (-1);
 593   }
 594
 595   item = (list_item_t *) malloc (sizeof (list_item_t));
 596   if (item == NULL)
 597   {
 598     ERROR ("powerdns plugin: malloc failed.");
 599     return (-1);
 600   }
 601   memset (item, '\0', sizeof (list_item_t));
 602
 603   item->instance = strdup (ci->values[0].value.string);
 604   if (item->instance == NULL)
 605   {
 606     ERROR ("powerdns plugin: strdup failed.");
 607     sfree (item);
 608     return (-1);
 609   }
 610
 611   /*
 612    * Set default values for the members of list_item_t
 613    */
 614   if (strcasecmp ("Server", ci->key) == 0)
 615   {
 616     item->func = powerdns_read_server;
 617     item->command = strdup (SERVER_COMMAND);
 618     item->socktype = SOCK_STREAM;
 619     socket_temp = strdup (SERVER_SOCKET);
 620   }
 621   else if (strcasecmp ("Recursor", ci->key) == 0)
 622   {
 623     item->func = powerdns_read_recursor;
 624     item->command = strdup (RECURSOR_COMMAND);
 625     item->socktype = SOCK_DGRAM;
 626     socket_temp = strdup (RECURSOR_SOCKET);
 627   }
 628
 629   status = 0;
 630   for (i = 0; i < ci->children_num; i++)
 631   {
 632     oconfig_item_t *option = ci->children + i;
 633
 634     if (strcasecmp ("Command", option->key) == 0)
 635       status = powerdns_config_add_string ("Command", &item->command, option);
 636     else if (strcasecmp ("Socket", option->key) == 0)
 637       status = powerdns_config_add_string ("Socket", &socket_temp, option);
 638     else
 639     {
 640       ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
 641       status = -1;
 642     }
 643
 644     if (status != 0)
 645       break;
 646   }
 647
 648   while (status == 0)
 649   {
 650     llentry_t *e;
 651
 652     if (socket_temp == NULL)
 653     {
 654       ERROR ("powerdns plugin: socket_temp == NULL.");
 655       status = -1;
 656       break;
 657     }
 658
 659     if (item->command == NULL)
 660     {
 661       ERROR ("powerdns plugin: item->command == NULL.");
 662       status = -1;
 663       break;
 664     }
 665
 666     item->sockaddr.sun_family = AF_UNIX;
 667     sstrncpy (item->sockaddr.sun_path, socket_temp, UNIX_PATH_MAX);
 668
 669     e = llentry_create (item->instance, item);
 670     if (e == NULL)
 671     {
 672       ERROR ("powerdns plugin: llentry_create failed.");
 673       status = -1;
 674       break;
 675     }
 676     llist_append (list, e);
 677
 678     break;
 679   }
 680
 681   if (status != 0)
 682   {
 683     sfree (item);
 684     return (-1);
 685   }
 686
 687   DEBUG ("powerdns plugin: Add server: instance = %s;", item->instance);
 688
 689   return (0);
 690 } /* }}} int powerdns_config_add_server */
 691
 692 static int powerdns_config (oconfig_item_t *ci) /* {{{ */
 693 {
 694   int i;
 695
 696   DEBUG ("powerdns plugin: powerdns_config (ci = %p);", (void *) ci);
 697
 698   if (list == NULL)
 699   {
 700     list = llist_create ();
 701
 702     if (list == NULL)
 703     {
 704       ERROR ("powerdns plugin: `llist_create' failed.");
 705       return (-1);
 706     }
 707   }
 708
 709   for (i = 0; i < ci->children_num; i++)
 710   {
 711     oconfig_item_t *option = ci->children + i;
 712
 713     if ((strcasecmp ("Server", option->key) == 0)
 714         || (strcasecmp ("Recursor", option->key) == 0))
 715       powerdns_config_add_server (option);
 716     if (strcasecmp ("LocalSocket", option->key) == 0)
 717     {
 718       char *temp = strdup (option->key);
 719       if (temp == NULL)
 720         return (1);
 721       sfree (local_sockpath);
 722       local_sockpath = temp;
 723     }
 724     else
 725     {
 726       ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
 727     }
 728   } /* for (i = 0; i < ci->children_num; i++) */
 729
 730   return (0);
 731 } /* }}} int powerdns_config */
 732
 733 static int powerdns_read (void)
 734 {
 735   llentry_t *e;
 736
 737   for (e = llist_head (list); e != NULL; e = e->next)
 738   {
 739     list_item_t *item = e->value;
 740     item->func (item);
 741   }
 742
 743   return (0);
 744 } /* static int powerdns_read */
 745
 746 static int powerdns_shutdown (void)
 747 {
 748   llentry_t *e;
 749
 750   if (list == NULL)
 751     return (0);
 752
 753   for (e = llist_head (list); e != NULL; e = e->next)
 754   {
 755     list_item_t *item = (list_item_t *) e->value;
 756     e->value = NULL;
 757
 758     sfree (item->instance);
 759     sfree (item->command);
 760     sfree (item);
 761   }
 762
 763   llist_destroy (list);
 764   list = NULL;
 765
 766   return (0);
 767 } /* static int powerdns_shutdown */
 768
 769 void module_register (void)
 770 {
 771   plugin_register_complex_config ("powerdns", powerdns_config);
 772   plugin_register_read ("powerdns", powerdns_read);
 773   plugin_register_shutdown ("powerdns", powerdns_shutdown );
 774 } /* void module_register */
 775
 776 /* vim: set sw=2 sts=2 ts=8 fdm=marker : */