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