2 * collectd - src/powerdns.c
3 * Copyright (C) 2007-2008 C-Ware, Inc.
4 * Copyright (C) 2008 Florian Forster
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.
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.
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
20 * Luke Heberling <lukeh at c-ware.com>
21 * Florian Forster <octo at collectd.org>
24 * Queries a PowerDNS control socket for statistics
31 #include "utils_llist.h"
38 #include <sys/types.h>
43 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *)0)->sun_path)
45 #define FUNC_ERROR(func) \
47 ERROR("powerdns plugin: %s failed: %s", func, STRERRNO); \
49 #define SOCK_ERROR(func, sockpath) \
51 ERROR("powerdns plugin: Socket `%s` %s failed: %s", sockpath, func, \
55 #define SERVER_SOCKET LOCALSTATEDIR "/run/pdns.controlsocket"
56 #define SERVER_COMMAND "SHOW * \n"
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"
65 typedef struct list_item_s list_item_t;
68 enum { SRV_AUTHORITATIVE, SRV_RECURSOR } server_type;
69 int (*func)(list_item_t *item);
76 struct sockaddr_un sockaddr;
80 struct statname_lookup_s {
83 const char *type_instance;
85 typedef struct statname_lookup_s statname_lookup_t;
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
93 answers10-100 counts the number of queries answered within 100
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
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
108 dont-outqueries number of outgoing queries dropped because of 'dont-query'
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
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
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
130 outgoing-timeouts counts the number of timeouts on outgoing UDP queries
132 over-capacity-drops questions dropped because over maximum concurrent query
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
146 servfail-answers counts the number of times it answered SERVFAIL since
148 spoof-prevents number of times PowerDNS considered itself spoofed, and
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
159 throttled-outqueries idem to throttled-out
160 unauthorized-tcp number of TCP questions denied because of allow-from
162 unauthorized-udp number of UDP questions denied because of allow-from
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
168 uptime number of seconds process has been running (since 3.1.5)
169 user-msec number of CPU milliseconds spent in 'user' mode
172 static const char *const default_server_fields[] = /* {{{ */
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",
179 static int default_server_fields_num = STATIC_ARRAY_SIZE(default_server_fields);
181 static statname_lookup_t lookup_table[] = /* {{{ */
183 /*********************
184 * Server statistics *
185 *********************/
187 {"recursing-questions", "dns_question", "recurse"},
188 {"tcp-queries", "dns_question", "tcp"},
189 {"udp-queries", "dns_question", "udp"},
190 {"rd-queries", "dns_question", "rd"},
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"},
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"},
215 {"latency", "latency", NULL},
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"},
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"},
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"},
248 /* CPU utilization */
249 {"sys-msec", "cpu", "system"},
250 {"user-msec", "cpu", "user"},
252 /* Question-to-answer latency */
253 {"qa-latency", "latency", NULL},
256 {"cache-entries", "cache_size", NULL},
257 {"cache-hits", "cache_result", "hit"},
258 {"cache-misses", "cache_result", "miss"},
260 /* Total number of questions.. */
261 {"questions", "dns_qtype", "total"},
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);
307 static llist_t *list;
309 #define PDNS_LOCAL_SOCKPATH LOCALSTATEDIR "/run/" PACKAGE_NAME "-powerdns"
310 static char *local_sockpath;
312 /* TODO: Do this before 4.4:
313 * - Update the collectd.conf(5) manpage.
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;
324 const char *type = NULL;
325 const char *type_instance = NULL;
326 const data_set_t *ds;
330 for (i = 0; i < lookup_table_length; i++)
331 if (strcmp(lookup_table[i].name, pdns_type) == 0)
334 if (i >= lookup_table_length) {
335 INFO("powerdns plugin: submit: Not found in lookup table: %s = %s;",
336 pdns_type, value_str);
340 if (lookup_table[i].type == NULL)
343 type = lookup_table[i].type;
344 type_instance = lookup_table[i].type_instance;
346 ds = plugin_get_ds(type);
348 ERROR("powerdns plugin: The lookup table returned type `%s', "
349 "but I cannot find it via `plugin_get_ds'.",
354 if (ds->ds_num != 1) {
355 ERROR("powerdns plugin: type `%s' has %" PRIsz " data sources, "
356 "but I can only handle one.",
361 if (0 != parse_value(value_str, &value, ds->ds[0].type)) {
367 sstrncpy(vl.plugin, "powerdns", sizeof(vl.plugin));
368 sstrncpy(vl.type, type, sizeof(vl.type));
369 if (type_instance != NULL)
370 sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
371 sstrncpy(vl.plugin_instance, plugin_instance, sizeof(vl.plugin_instance));
373 plugin_dispatch_values(&vl);
374 } /* }}} static void submit */
376 static int powerdns_get_data_dgram(list_item_t *item, char **ret_buffer) {
383 size_t buffer_size = 0;
385 struct sockaddr_un sa_unix = {0};
387 cdtime_t cdt_timeout;
389 sd = socket(PF_UNIX, item->socktype, 0);
391 FUNC_ERROR("socket");
395 sa_unix.sun_family = AF_UNIX;
396 sstrncpy(sa_unix.sun_path,
397 (local_sockpath != NULL) ? local_sockpath : PDNS_LOCAL_SOCKPATH,
398 sizeof(sa_unix.sun_path));
400 status = unlink(sa_unix.sun_path);
401 if ((status != 0) && (errno != ENOENT)) {
402 SOCK_ERROR("unlink", sa_unix.sun_path);
409 /* We need to bind to a specific path, because this is a datagram socket
410 * and otherwise the daemon cannot answer. */
411 status = bind(sd, (struct sockaddr *)&sa_unix, sizeof(sa_unix));
413 SOCK_ERROR("bind", sa_unix.sun_path);
417 /* Make the socket writeable by the daemon.. */
418 status = chmod(sa_unix.sun_path, 0666);
420 SOCK_ERROR("chmod", sa_unix.sun_path);
424 cdt_timeout = plugin_get_interval() * 3 / 4;
425 if (cdt_timeout < TIME_T_TO_CDTIME_T(2))
426 cdt_timeout = TIME_T_TO_CDTIME_T(2);
429 setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO,
430 &CDTIME_T_TO_TIMEVAL(cdt_timeout), sizeof(struct timeval));
432 SOCK_ERROR("setsockopt", sa_unix.sun_path);
437 connect(sd, (struct sockaddr *)&item->sockaddr, sizeof(item->sockaddr));
439 SOCK_ERROR("connect", sa_unix.sun_path);
443 status = send(sd, item->command, strlen(item->command), 0);
445 SOCK_ERROR("send", sa_unix.sun_path);
449 status = recv(sd, temp, sizeof(temp), /* flags = */ 0);
451 SOCK_ERROR("recv", sa_unix.sun_path);
454 buffer_size = status + 1;
459 unlink(sa_unix.sun_path);
464 assert(buffer_size > 0);
465 buffer = malloc(buffer_size);
466 if (buffer == NULL) {
467 FUNC_ERROR("malloc");
471 memcpy(buffer, temp, buffer_size - 1);
472 buffer[buffer_size - 1] = 0;
474 *ret_buffer = buffer;
476 } /* }}} int powerdns_get_data_dgram */
478 static int powerdns_get_data_stream(list_item_t *item, char **ret_buffer) {
485 size_t buffer_size = 0;
487 sd = socket(PF_UNIX, item->socktype, 0);
489 FUNC_ERROR("socket");
493 struct timeval timeout;
496 status = setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
498 FUNC_ERROR("setsockopt");
504 connect(sd, (struct sockaddr *)&item->sockaddr, sizeof(item->sockaddr));
506 SOCK_ERROR("connect", item->sockaddr.sun_path);
511 /* strlen + 1, because we need to send the terminating NULL byte, too. */
512 status = send(sd, item->command, strlen(item->command) + 1,
515 SOCK_ERROR("send", item->sockaddr.sun_path);
523 status = recv(sd, temp, sizeof(temp), /* flags = */ 0);
525 SOCK_ERROR("recv", item->sockaddr.sun_path);
527 } else if (status == 0) {
531 buffer_new = realloc(buffer, buffer_size + status + 1);
532 if (buffer_new == NULL) {
533 FUNC_ERROR("realloc");
539 memcpy(buffer + buffer_size, temp, status);
540 buffer_size += status;
541 buffer[buffer_size] = 0;
550 *ret_buffer = buffer;
552 } /* }}} int powerdns_get_data_stream */
554 static int powerdns_get_data(list_item_t *item, char **ret_buffer) {
555 if (item->socktype == SOCK_DGRAM)
556 return powerdns_get_data_dgram(item, ret_buffer);
557 else if (item->socktype == SOCK_STREAM)
558 return powerdns_get_data_stream(item, ret_buffer);
560 ERROR("powerdns plugin: Unknown socket type: %i", (int)item->socktype);
563 } /* int powerdns_get_data */
565 static int powerdns_read_server(list_item_t *item) /* {{{ */
567 if (item->command == NULL)
568 item->command = strdup(SERVER_COMMAND);
569 if (item->command == NULL) {
570 ERROR("powerdns plugin: strdup failed.");
575 int status = powerdns_get_data(item, &buffer);
577 ERROR("powerdns plugin: powerdns_get_data failed.");
580 if (buffer == NULL) {
584 const char *const *fields = default_server_fields;
585 int fields_num = default_server_fields_num;
586 if (item->fields_num != 0) {
587 fields = (const char *const *)item->fields;
588 fields_num = item->fields_num;
591 assert(fields != NULL);
592 assert(fields_num > 0);
594 /* 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,
596 char *dummy = buffer;
597 char *saveptr = NULL;
599 while ((key = strtok_r(dummy, ",", &saveptr)) != NULL) {
602 char *value = strchr(key, '=');
609 if (value[0] == '\0')
612 /* Check if this item was requested. */
614 for (i = 0; i < fields_num; i++)
615 if (strcasecmp(key, fields[i]) == 0)
620 submit(item->instance, key, value);
621 } /* while (strtok_r) */
626 } /* }}} int powerdns_read_server */
629 * powerdns_update_recursor_command
631 * Creates a string that holds the command to be sent to the recursor. This
632 * string is stores in the `command' member of the `list_item_t' passed to the
633 * function. This function is called by `powerdns_read_recursor'.
635 static int powerdns_update_recursor_command(list_item_t *li) /* {{{ */
643 if (li->fields_num < 1) {
644 sstrncpy(buffer, RECURSOR_COMMAND, sizeof(buffer));
646 sstrncpy(buffer, "get ", sizeof(buffer));
647 status = strjoin(&buffer[strlen("get ")], sizeof(buffer) - strlen("get "),
648 li->fields, li->fields_num,
649 /* seperator = */ " ");
651 ERROR("powerdns plugin: strjoin failed.");
654 buffer[sizeof(buffer) - 1] = 0;
655 size_t len = strlen(buffer);
656 if (len < sizeof(buffer) - 2) {
658 buffer[len++] = '\n';
659 buffer[len++] = '\0';
663 buffer[sizeof(buffer) - 1] = 0;
664 li->command = strdup(buffer);
665 if (li->command == NULL) {
666 ERROR("powerdns plugin: strdup failed.");
671 } /* }}} int powerdns_update_recursor_command */
673 static int powerdns_read_recursor(list_item_t *item) /* {{{ */
686 if (item->command == NULL) {
687 status = powerdns_update_recursor_command(item);
689 ERROR("powerdns plugin: powerdns_update_recursor_command failed.");
693 DEBUG("powerdns plugin: powerdns_read_recursor: item->command = %s;",
696 assert(item->command != NULL);
698 status = powerdns_get_data(item, &buffer);
700 ERROR("powerdns plugin: powerdns_get_data failed.");
704 keys_list = strdup(item->command);
705 if (keys_list == NULL) {
706 FUNC_ERROR("strdup");
712 value_saveptr = NULL;
714 /* Skip the `get' at the beginning */
715 strtok_r(keys_list, " \t", &key_saveptr);
718 while ((value = strtok_r(dummy, " \t\n\r", &value_saveptr)) != NULL) {
721 key = strtok_r(NULL, " \t", &key_saveptr);
725 submit(item->instance, key, value);
726 } /* while (strtok_r) */
732 } /* }}} int powerdns_read_recursor */
734 static int powerdns_config_add_collect(list_item_t *li, /* {{{ */
735 oconfig_item_t *ci) {
738 if (ci->values_num < 1) {
739 WARNING("powerdns plugin: The `Collect' option needs "
740 "at least one argument.");
744 for (int i = 0; i < ci->values_num; i++)
745 if (ci->values[i].type != OCONFIG_TYPE_STRING) {
746 WARNING("powerdns plugin: Only string arguments are allowed to "
747 "the `Collect' option.");
752 realloc(li->fields, sizeof(char *) * (li->fields_num + ci->values_num));
754 WARNING("powerdns plugin: realloc failed.");
759 for (int i = 0; i < ci->values_num; i++) {
760 li->fields[li->fields_num] = strdup(ci->values[i].value.string);
761 if (li->fields[li->fields_num] == NULL) {
762 WARNING("powerdns plugin: strdup failed.");
768 /* Invalidate a previously computed command */
772 } /* }}} int powerdns_config_add_collect */
774 static int powerdns_config_add_server(oconfig_item_t *ci) /* {{{ */
781 if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
782 WARNING("powerdns plugin: `%s' needs exactly one string argument.",
787 item = calloc(1, sizeof(*item));
789 ERROR("powerdns plugin: calloc failed.");
793 item->instance = strdup(ci->values[0].value.string);
794 if (item->instance == NULL) {
795 ERROR("powerdns plugin: strdup failed.");
801 * Set default values for the members of list_item_t
803 if (strcasecmp("Server", ci->key) == 0) {
804 item->server_type = SRV_AUTHORITATIVE;
805 item->func = powerdns_read_server;
806 item->socktype = SOCK_STREAM;
807 socket_temp = strdup(SERVER_SOCKET);
808 } else if (strcasecmp("Recursor", ci->key) == 0) {
809 item->server_type = SRV_RECURSOR;
810 item->func = powerdns_read_recursor;
811 item->socktype = SOCK_DGRAM;
812 socket_temp = strdup(RECURSOR_SOCKET);
814 /* We must never get here.. */
820 for (int i = 0; i < ci->children_num; i++) {
821 oconfig_item_t *option = ci->children + i;
823 if (strcasecmp("Collect", option->key) == 0)
824 status = powerdns_config_add_collect(item, option);
825 else if (strcasecmp("Socket", option->key) == 0)
826 status = cf_util_get_string(option, &socket_temp);
828 ERROR("powerdns plugin: Option `%s' not allowed here.", option->key);
836 while (status == 0) {
839 if (socket_temp == NULL) {
840 ERROR("powerdns plugin: socket_temp == NULL.");
845 item->sockaddr.sun_family = AF_UNIX;
846 sstrncpy(item->sockaddr.sun_path, socket_temp,
847 sizeof(item->sockaddr.sun_path));
849 e = llentry_create(item->instance, item);
851 ERROR("powerdns plugin: llentry_create failed.");
855 llist_append(list, e);
866 DEBUG("powerdns plugin: Add server: instance = %s;", item->instance);
870 } /* }}} int powerdns_config_add_server */
872 static int powerdns_config(oconfig_item_t *ci) /* {{{ */
874 DEBUG("powerdns plugin: powerdns_config (ci = %p);", (void *)ci);
877 list = llist_create();
880 ERROR("powerdns plugin: `llist_create' failed.");
885 for (int i = 0; i < ci->children_num; i++) {
886 oconfig_item_t *option = ci->children + i;
888 if ((strcasecmp("Server", option->key) == 0) ||
889 (strcasecmp("Recursor", option->key) == 0))
890 powerdns_config_add_server(option);
891 else if (strcasecmp("LocalSocket", option->key) == 0) {
892 if ((option->values_num != 1) ||
893 (option->values[0].type != OCONFIG_TYPE_STRING)) {
894 WARNING("powerdns plugin: `%s' needs exactly one string argument.",
897 char *temp = strdup(option->values[0].value.string);
900 sfree(local_sockpath);
901 local_sockpath = temp;
904 ERROR("powerdns plugin: Option `%s' not allowed here.", option->key);
906 } /* for (i = 0; i < ci->children_num; i++) */
909 } /* }}} int powerdns_config */
911 static int powerdns_read(void) {
912 for (llentry_t *e = llist_head(list); e != NULL; e = e->next) {
913 list_item_t *item = e->value;
918 } /* static int powerdns_read */
920 static int powerdns_shutdown(void) {
924 for (llentry_t *e = llist_head(list); e != NULL; e = e->next) {
925 list_item_t *item = (list_item_t *)e->value;
928 sfree(item->instance);
929 sfree(item->command);
937 } /* static int powerdns_shutdown */
939 void module_register(void) {
940 plugin_register_complex_config("powerdns", powerdns_config);
941 plugin_register_read("powerdns", powerdns_read);
942 plugin_register_shutdown("powerdns", powerdns_shutdown);
943 } /* void module_register */