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