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