Code

dpdkstat: use portable format strings
[collectd.git] / src / bind.c
1 /**
2  * collectd - src/bind.c
3  * Copyright (C) 2009       Bruno PrĂ©mont
4  * Copyright (C) 2009,2010  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  * Authors:
20  *   Bruno PrĂ©mont <bonbons at linux-vserver.org>
21  *   Florian Forster <octo at collectd.org>
22  **/
24 #include "config.h"
26 #if STRPTIME_NEEDS_STANDARDS
27 #ifndef _ISOC99_SOURCE
28 #define _ISOC99_SOURCE 1
29 #endif
30 #ifndef _POSIX_C_SOURCE
31 #define _POSIX_C_SOURCE 200112L
32 #endif
33 #ifndef _XOPEN_SOURCE
34 #define _XOPEN_SOURCE 500
35 #endif
36 #endif /* STRPTIME_NEEDS_STANDARDS */
38 #include "collectd.h"
40 #include "common.h"
41 #include "plugin.h"
43 /* Some versions of libcurl don't include this themselves and then don't have
44  * fd_set available. */
45 #if HAVE_SYS_SELECT_H
46 #include <sys/select.h>
47 #endif
49 #include <curl/curl.h>
50 #include <libxml/parser.h>
51 #include <libxml/xpath.h>
53 #ifndef BIND_DEFAULT_URL
54 #define BIND_DEFAULT_URL "http://localhost:8053/"
55 #endif
57 /*
58  * Some types used for the callback functions. `translation_table_ptr_t' and
59  * `list_info_ptr_t' are passed to the callbacks in the `void *user_data'
60  * pointer.
61  */
62 typedef int (*list_callback_t)(const char *name, value_t value,
63                                time_t current_time, void *user_data);
65 struct cb_view_s {
66   char *name;
68   int qtypes;
69   int resolver_stats;
70   int cacherrsets;
72   char **zones;
73   size_t zones_num;
74 };
75 typedef struct cb_view_s cb_view_t;
77 struct translation_info_s {
78   const char *xml_name;
79   const char *type;
80   const char *type_instance;
81 };
82 typedef struct translation_info_s translation_info_t;
84 struct translation_table_ptr_s {
85   const translation_info_t *table;
86   size_t table_length;
87   const char *plugin_instance;
88 };
89 typedef struct translation_table_ptr_s translation_table_ptr_t;
91 struct list_info_ptr_s {
92   const char *plugin_instance;
93   const char *type;
94 };
95 typedef struct list_info_ptr_s list_info_ptr_t;
97 /* FIXME: Enabled by default for backwards compatibility. */
98 /* TODO: Remove time parsing code. */
99 static _Bool config_parse_time = 1;
101 static char *url = NULL;
102 static int global_opcodes = 1;
103 static int global_qtypes = 1;
104 static int global_server_stats = 1;
105 static int global_zone_maint_stats = 1;
106 static int global_resolver_stats = 0;
107 static int global_memory_stats = 1;
108 static int timeout = -1;
110 static cb_view_t *views = NULL;
111 static size_t views_num = 0;
113 static CURL *curl = NULL;
115 static char *bind_buffer = NULL;
116 static size_t bind_buffer_size = 0;
117 static size_t bind_buffer_fill = 0;
118 static char bind_curl_error[CURL_ERROR_SIZE];
120 /* Translation table for the `nsstats' values. */
121 static const translation_info_t nsstats_translation_table[] = /* {{{ */
122     {
123         /* Requests */
124         {"Requestv4", "dns_request", "IPv4"},
125         {"Requestv6", "dns_request", "IPv6"},
126         {"ReqEdns0", "dns_request", "EDNS0"},
127         {"ReqBadEDNSVer", "dns_request", "BadEDNSVer"},
128         {"ReqTSIG", "dns_request", "TSIG"},
129         {"ReqSIG0", "dns_request", "SIG0"},
130         {"ReqBadSIG", "dns_request", "BadSIG"},
131         {"ReqTCP", "dns_request", "TCP"},
132         /* Rejects */
133         {"AuthQryRej", "dns_reject", "authoritative"},
134         {"RecQryRej", "dns_reject", "recursive"},
135         {"XfrRej", "dns_reject", "transfer"},
136         {"UpdateRej", "dns_reject", "update"},
137         /* Responses */
138         {"Response", "dns_response", "normal"},
139         {"TruncatedResp", "dns_response", "truncated"},
140         {"RespEDNS0", "dns_response", "EDNS0"},
141         {"RespTSIG", "dns_response", "TSIG"},
142         {"RespSIG0", "dns_response", "SIG0"},
143         /* Queries */
144         {"QryAuthAns", "dns_query", "authoritative"},
145         {"QryNoauthAns", "dns_query", "nonauth"},
146         {"QryReferral", "dns_query", "referral"},
147         {"QryRecursion", "dns_query", "recursion"},
148         {"QryDuplicate", "dns_query", "duplicate"},
149         {"QryDropped", "dns_query", "dropped"},
150         {"QryFailure", "dns_query", "failure"},
151         /* Response codes */
152         {"QrySuccess", "dns_rcode", "tx-NOERROR"},
153         {"QryNxrrset", "dns_rcode", "tx-NXRRSET"},
154         {"QrySERVFAIL", "dns_rcode", "tx-SERVFAIL"},
155         {"QryFORMERR", "dns_rcode", "tx-FORMERR"},
156         {"QryNXDOMAIN", "dns_rcode", "tx-NXDOMAIN"}
157 #if 0
158   { "XfrReqDone",      "type",         "type_instance" },
159   { "UpdateReqFwd",    "type",         "type_instance" },
160   { "UpdateRespFwd",   "type",         "type_instance" },
161   { "UpdateFwdFail",   "type",         "type_instance" },
162   { "UpdateDone",      "type",         "type_instance" },
163   { "UpdateFail",      "type",         "type_instance" },
164   { "UpdateBadPrereq", "type",         "type_instance" },
165 #endif
166 };
167 static int nsstats_translation_table_length =
168     STATIC_ARRAY_SIZE(nsstats_translation_table);
169 /* }}} */
171 /* Translation table for the `zonestats' values. */
172 static const translation_info_t zonestats_translation_table[] = /* {{{ */
173     {
174         /* Notify's */
175         {"NotifyOutv4", "dns_notify", "tx-IPv4"},
176         {"NotifyOutv6", "dns_notify", "tx-IPv6"},
177         {"NotifyInv4", "dns_notify", "rx-IPv4"},
178         {"NotifyInv6", "dns_notify", "rx-IPv6"},
179         {"NotifyRej", "dns_notify", "rejected"},
180         /* SOA/AXFS/IXFS requests */
181         {"SOAOutv4", "dns_opcode", "SOA-IPv4"},
182         {"SOAOutv6", "dns_opcode", "SOA-IPv6"},
183         {"AXFRReqv4", "dns_opcode", "AXFR-IPv4"},
184         {"AXFRReqv6", "dns_opcode", "AXFR-IPv6"},
185         {"IXFRReqv4", "dns_opcode", "IXFR-IPv4"},
186         {"IXFRReqv6", "dns_opcode", "IXFR-IPv6"},
187         /* Domain transfers */
188         {"XfrSuccess", "dns_transfer", "success"},
189         {"XfrFail", "dns_transfer", "failure"}};
190 static int zonestats_translation_table_length =
191     STATIC_ARRAY_SIZE(zonestats_translation_table);
192 /* }}} */
194 /* Translation table for the `resstats' values. */
195 static const translation_info_t resstats_translation_table[] = /* {{{ */
196     {
197         /* Generic resolver information */
198         {"Queryv4", "dns_query", "IPv4"},
199         {"Queryv6", "dns_query", "IPv6"},
200         {"Responsev4", "dns_response", "IPv4"},
201         {"Responsev6", "dns_response", "IPv6"},
202         /* Received response codes */
203         {"NXDOMAIN", "dns_rcode", "rx-NXDOMAIN"},
204         {"SERVFAIL", "dns_rcode", "rx-SERVFAIL"},
205         {"FORMERR", "dns_rcode", "rx-FORMERR"},
206         {"OtherError", "dns_rcode", "rx-OTHER"},
207         {"EDNS0Fail", "dns_rcode", "rx-EDNS0Fail"},
208         /* Received responses */
209         {"Mismatch", "dns_response", "mismatch"},
210         {"Truncated", "dns_response", "truncated"},
211         {"Lame", "dns_response", "lame"},
212         {"Retry", "dns_query", "retry"},
213 #if 0
214   { "GlueFetchv4",     "type", "type_instance" },
215   { "GlueFetchv6",     "type", "type_instance" },
216   { "GlueFetchv4Fail", "type", "type_instance" },
217   { "GlueFetchv6Fail", "type", "type_instance" },
218 #endif
219         /* DNSSEC information */
220         {"ValAttempt", "dns_resolver", "DNSSEC-attempt"},
221         {"ValOk", "dns_resolver", "DNSSEC-okay"},
222         {"ValNegOk", "dns_resolver", "DNSSEC-negokay"},
223         {"ValFail", "dns_resolver", "DNSSEC-fail"}};
224 static int resstats_translation_table_length =
225     STATIC_ARRAY_SIZE(resstats_translation_table);
226 /* }}} */
228 /* Translation table for the `memory/summary' values. */
229 static const translation_info_t memsummary_translation_table[] = /* {{{ */
230     {{"TotalUse", "memory", "TotalUse"},
231      {"InUse", "memory", "InUse"},
232      {"BlockSize", "memory", "BlockSize"},
233      {"ContextSize", "memory", "ContextSize"},
234      {"Lost", "memory", "Lost"}};
235 static int memsummary_translation_table_length =
236     STATIC_ARRAY_SIZE(memsummary_translation_table);
237 /* }}} */
239 static void submit(time_t ts, const char *plugin_instance, /* {{{ */
240                    const char *type, const char *type_instance, value_t value) {
241   value_list_t vl = VALUE_LIST_INIT;
243   vl.values = &value;
244   vl.values_len = 1;
245   if (config_parse_time)
246     vl.time = TIME_T_TO_CDTIME_T(ts);
247   sstrncpy(vl.plugin, "bind", sizeof(vl.plugin));
248   if (plugin_instance) {
249     sstrncpy(vl.plugin_instance, plugin_instance, sizeof(vl.plugin_instance));
250     replace_special(vl.plugin_instance, sizeof(vl.plugin_instance));
251   }
252   sstrncpy(vl.type, type, sizeof(vl.type));
253   if (type_instance) {
254     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
255     replace_special(vl.type_instance, sizeof(vl.type_instance));
256   }
257   plugin_dispatch_values(&vl);
258 } /* }}} void submit */
260 static size_t bind_curl_callback(void *buf, size_t size, /* {{{ */
261                                  size_t nmemb,
262                                  void __attribute__((unused)) * stream) {
263   size_t len = size * nmemb;
265   if (len == 0)
266     return (len);
268   if ((bind_buffer_fill + len) >= bind_buffer_size) {
269     char *temp;
271     temp = realloc(bind_buffer, bind_buffer_fill + len + 1);
272     if (temp == NULL) {
273       ERROR("bind plugin: realloc failed.");
274       return (0);
275     }
276     bind_buffer = temp;
277     bind_buffer_size = bind_buffer_fill + len + 1;
278   }
280   memcpy(bind_buffer + bind_buffer_fill, (char *)buf, len);
281   bind_buffer_fill += len;
282   bind_buffer[bind_buffer_fill] = 0;
284   return (len);
285 } /* }}} size_t bind_curl_callback */
287 /*
288  * Callback, that's called with a translation table.
289  * (Plugin instance is fixed, type and type instance come from lookup table.)
290  */
291 static int bind_xml_table_callback(const char *name, value_t value, /* {{{ */
292                                    time_t current_time, void *user_data) {
293   translation_table_ptr_t *table = (translation_table_ptr_t *)user_data;
295   if (table == NULL)
296     return (-1);
298   for (size_t i = 0; i < table->table_length; i++) {
299     if (strcmp(table->table[i].xml_name, name) != 0)
300       continue;
302     submit(current_time, table->plugin_instance, table->table[i].type,
303            table->table[i].type_instance, value);
304     break;
305   }
307   return (0);
308 } /* }}} int bind_xml_table_callback */
310 /*
311  * Callback, that's used for lists.
312  * (Plugin instance and type are fixed, xml name is used as type instance.)
313  */
314 static int bind_xml_list_callback(const char *name, /* {{{ */
315                                   value_t value, time_t current_time,
316                                   void *user_data) {
317   list_info_ptr_t *list_info = (list_info_ptr_t *)user_data;
319   if (list_info == NULL)
320     return (-1);
322   submit(current_time, list_info->plugin_instance, list_info->type,
323          /* type instance = */ name, value);
325   return (0);
326 } /* }}} int bind_xml_list_callback */
328 static int bind_xml_read_derive(xmlDoc *doc, xmlNode *node, /* {{{ */
329                                 derive_t *ret_value) {
330   char *str_ptr;
331   value_t value;
332   int status;
334   str_ptr = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
335   if (str_ptr == NULL) {
336     ERROR("bind plugin: bind_xml_read_derive: xmlNodeListGetString failed.");
337     return (-1);
338   }
340   status = parse_value(str_ptr, &value, DS_TYPE_DERIVE);
341   if (status != 0) {
342     ERROR("bind plugin: Parsing string \"%s\" to derive value failed.",
343           str_ptr);
344     xmlFree(str_ptr);
345     return (-1);
346   }
348   xmlFree(str_ptr);
349   *ret_value = value.derive;
350   return (0);
351 } /* }}} int bind_xml_read_derive */
353 static int bind_xml_read_gauge(xmlDoc *doc, xmlNode *node, /* {{{ */
354                                gauge_t *ret_value) {
355   char *str_ptr, *end_ptr;
356   double value;
358   str_ptr = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
359   if (str_ptr == NULL) {
360     ERROR("bind plugin: bind_xml_read_gauge: xmlNodeListGetString failed.");
361     return (-1);
362   }
364   errno = 0;
365   value = strtod(str_ptr, &end_ptr);
366   xmlFree(str_ptr);
367   if (str_ptr == end_ptr || errno) {
368     if (errno && (value < 0))
369       ERROR("bind plugin: bind_xml_read_gauge: strtod failed with underflow.");
370     else if (errno && (value > 0))
371       ERROR("bind plugin: bind_xml_read_gauge: strtod failed with overflow.");
372     else
373       ERROR("bind plugin: bind_xml_read_gauge: strtod failed.");
374     return (-1);
375   }
377   *ret_value = (gauge_t)value;
378   return (0);
379 } /* }}} int bind_xml_read_gauge */
381 static int bind_xml_read_timestamp(const char *xpath_expression, /* {{{ */
382                                    xmlDoc *doc, xmlXPathContext *xpathCtx,
383                                    time_t *ret_value) {
384   xmlXPathObject *xpathObj = NULL;
385   xmlNode *node;
386   char *str_ptr;
387   char *tmp;
388   struct tm tm = {0};
390   xpathObj = xmlXPathEvalExpression(BAD_CAST xpath_expression, xpathCtx);
391   if (xpathObj == NULL) {
392     ERROR("bind plugin: Unable to evaluate XPath expression `%s'.",
393           xpath_expression);
394     return (-1);
395   }
397   if ((xpathObj->nodesetval == NULL) || (xpathObj->nodesetval->nodeNr < 1)) {
398     xmlXPathFreeObject(xpathObj);
399     return (-1);
400   }
402   if (xpathObj->nodesetval->nodeNr != 1) {
403     NOTICE("bind plugin: Evaluating the XPath expression `%s' returned "
404            "%i nodes. Only handling the first one.",
405            xpath_expression, xpathObj->nodesetval->nodeNr);
406   }
408   node = xpathObj->nodesetval->nodeTab[0];
410   if (node->xmlChildrenNode == NULL) {
411     ERROR("bind plugin: bind_xml_read_timestamp: "
412           "node->xmlChildrenNode == NULL");
413     xmlXPathFreeObject(xpathObj);
414     return (-1);
415   }
417   str_ptr = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
418   if (str_ptr == NULL) {
419     ERROR("bind plugin: bind_xml_read_timestamp: xmlNodeListGetString failed.");
420     xmlXPathFreeObject(xpathObj);
421     return (-1);
422   }
424   tmp = strptime(str_ptr, "%Y-%m-%dT%T", &tm);
425   xmlFree(str_ptr);
426   if (tmp == NULL) {
427     ERROR("bind plugin: bind_xml_read_timestamp: strptime failed.");
428     xmlXPathFreeObject(xpathObj);
429     return (-1);
430   }
432   *ret_value = mktime(&tm);
434   xmlXPathFreeObject(xpathObj);
435   return (0);
436 } /* }}} int bind_xml_read_timestamp */
438 /*
439  * bind_parse_generic_name_value
440  *
441  * Reads statistics in the form:
442  * <foo>
443  *   <name>QUERY</name>
444  *   <counter>123</counter>
445  * </foo>
446  */
447 static int bind_parse_generic_name_value(const char *xpath_expression, /* {{{ */
448                                          list_callback_t list_callback,
449                                          void *user_data, xmlDoc *doc,
450                                          xmlXPathContext *xpathCtx,
451                                          time_t current_time, int ds_type) {
452   xmlXPathObject *xpathObj = NULL;
453   int num_entries;
455   xpathObj = xmlXPathEvalExpression(BAD_CAST xpath_expression, xpathCtx);
456   if (xpathObj == NULL) {
457     ERROR("bind plugin: Unable to evaluate XPath expression `%s'.",
458           xpath_expression);
459     return (-1);
460   }
462   num_entries = 0;
463   /* Iterate over all matching nodes. */
464   for (int i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr);
465        i++) {
466     xmlNode *name_node = NULL;
467     xmlNode *counter = NULL;
468     xmlNode *parent;
470     parent = xpathObj->nodesetval->nodeTab[i];
471     DEBUG("bind plugin: bind_parse_generic_name_value: parent->name = %s;",
472           (char *)parent->name);
474     /* Iterate over all child nodes. */
475     for (xmlNode *child = parent->xmlChildrenNode; child != NULL;
476          child = child->next) {
477       if (child->type != XML_ELEMENT_NODE)
478         continue;
480       if (xmlStrcmp(BAD_CAST "name", child->name) == 0)
481         name_node = child;
482       else if (xmlStrcmp(BAD_CAST "counter", child->name) == 0)
483         counter = child;
484     }
486     if ((name_node != NULL) && (counter != NULL)) {
487       char *name =
488           (char *)xmlNodeListGetString(doc, name_node->xmlChildrenNode, 1);
489       value_t value;
490       int status;
492       if (ds_type == DS_TYPE_GAUGE)
493         status = bind_xml_read_gauge(doc, counter, &value.gauge);
494       else
495         status = bind_xml_read_derive(doc, counter, &value.derive);
496       if (status != 0)
497         continue;
499       status = (*list_callback)(name, value, current_time, user_data);
500       if (status == 0)
501         num_entries++;
503       xmlFree(name);
504     }
505   }
507   DEBUG("bind plugin: Found %d %s for XPath expression `%s'", num_entries,
508         (num_entries == 1) ? "entry" : "entries", xpath_expression);
510   xmlXPathFreeObject(xpathObj);
512   return (0);
513 } /* }}} int bind_parse_generic_name_value */
515 /*
516  * bind_parse_generic_value_list
517  *
518  * Reads statistics in the form:
519  * <foo>
520  *   <name0>123</name0>
521  *   <name1>234</name1>
522  *   <name2>345</name2>
523  *   :
524  * </foo>
525  */
526 static int bind_parse_generic_value_list(const char *xpath_expression, /* {{{ */
527                                          list_callback_t list_callback,
528                                          void *user_data, xmlDoc *doc,
529                                          xmlXPathContext *xpathCtx,
530                                          time_t current_time, int ds_type) {
531   xmlXPathObject *xpathObj = NULL;
532   int num_entries;
534   xpathObj = xmlXPathEvalExpression(BAD_CAST xpath_expression, xpathCtx);
535   if (xpathObj == NULL) {
536     ERROR("bind plugin: Unable to evaluate XPath expression `%s'.",
537           xpath_expression);
538     return (-1);
539   }
541   num_entries = 0;
542   /* Iterate over all matching nodes. */
543   for (int i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr);
544        i++) {
545     /* Iterate over all child nodes. */
546     for (xmlNode *child = xpathObj->nodesetval->nodeTab[i]->xmlChildrenNode;
547          child != NULL; child = child->next) {
548       char *node_name;
549       value_t value;
550       int status;
552       if (child->type != XML_ELEMENT_NODE)
553         continue;
555       node_name = (char *)child->name;
557       if (ds_type == DS_TYPE_GAUGE)
558         status = bind_xml_read_gauge(doc, child, &value.gauge);
559       else
560         status = bind_xml_read_derive(doc, child, &value.derive);
561       if (status != 0)
562         continue;
564       status = (*list_callback)(node_name, value, current_time, user_data);
565       if (status == 0)
566         num_entries++;
567     }
568   }
570   DEBUG("bind plugin: Found %d %s for XPath expression `%s'", num_entries,
571         (num_entries == 1) ? "entry" : "entries", xpath_expression);
573   xmlXPathFreeObject(xpathObj);
575   return (0);
576 } /* }}} int bind_parse_generic_value_list */
578 /*
579  * bind_parse_generic_name_attr_value_list
580  *
581  * Reads statistics in the form:
582  * <foo>
583  *   <counter name="name0">123</counter>
584  *   <counter name="name1">234</counter>
585  *   <counter name="name2">345</counter>
586  *   :
587  * </foo>
588  */
589 static int bind_parse_generic_name_attr_value_list(
590     const char *xpath_expression, /* {{{ */
591     list_callback_t list_callback, void *user_data, xmlDoc *doc,
592     xmlXPathContext *xpathCtx, time_t current_time, int ds_type) {
593   xmlXPathObject *xpathObj = NULL;
594   int num_entries;
596   xpathObj = xmlXPathEvalExpression(BAD_CAST xpath_expression, xpathCtx);
597   if (xpathObj == NULL) {
598     ERROR("bind plugin: Unable to evaluate XPath expression `%s'.",
599           xpath_expression);
600     return (-1);
601   }
603   num_entries = 0;
604   /* Iterate over all matching nodes. */
605   for (int i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr);
606        i++) {
607     /* Iterate over all child nodes. */
608     for (xmlNode *child = xpathObj->nodesetval->nodeTab[i]->xmlChildrenNode;
609          child != NULL; child = child->next) {
610       if (child->type != XML_ELEMENT_NODE)
611         continue;
613       if (strncmp("counter", (char *)child->name, strlen("counter")) != 0)
614         continue;
616       char *attr_name;
617       value_t value;
618       int status;
620       attr_name = (char *)xmlGetProp(child, BAD_CAST "name");
621       if (attr_name == NULL) {
622         DEBUG("bind plugin: found <counter> without name.");
623         continue;
624       }
625       if (ds_type == DS_TYPE_GAUGE)
626         status = bind_xml_read_gauge(doc, child, &value.gauge);
627       else
628         status = bind_xml_read_derive(doc, child, &value.derive);
629       if (status != 0)
630         continue;
632       status = (*list_callback)(attr_name, value, current_time, user_data);
633       if (status == 0)
634         num_entries++;
635     }
636   }
638   DEBUG("bind plugin: Found %d %s for XPath expression `%s'", num_entries,
639         (num_entries == 1) ? "entry" : "entries", xpath_expression);
641   xmlXPathFreeObject(xpathObj);
643   return (0);
644 } /* }}} int bind_parse_generic_name_attr_value_list */
646 static int bind_xml_stats_handle_zone(int version, xmlDoc *doc, /* {{{ */
647                                       xmlXPathContext *path_ctx, xmlNode *node,
648                                       cb_view_t *view, time_t current_time) {
649   xmlXPathObject *path_obj;
650   char *zone_name = NULL;
651   size_t j;
653   if (version >= 3) {
654     char *n = (char *)xmlGetProp(node, BAD_CAST "name");
655     char *c = (char *)xmlGetProp(node, BAD_CAST "rdataclass");
656     if (n && c) {
657       zone_name = (char *)xmlMalloc(strlen(n) + strlen(c) + 2);
658       snprintf(zone_name, strlen(n) + strlen(c) + 2, "%s/%s", n, c);
659     }
660     xmlFree(n);
661     xmlFree(c);
662   } else {
663     path_obj = xmlXPathEvalExpression(BAD_CAST "name", path_ctx);
664     if (path_obj == NULL) {
665       ERROR("bind plugin: xmlXPathEvalExpression failed.");
666       return (-1);
667     }
669     for (int i = 0; path_obj->nodesetval && (i < path_obj->nodesetval->nodeNr);
670          i++) {
671       zone_name = (char *)xmlNodeListGetString(
672           doc, path_obj->nodesetval->nodeTab[i]->xmlChildrenNode, 1);
673       if (zone_name != NULL)
674         break;
675     }
676     xmlXPathFreeObject(path_obj);
677   }
679   if (zone_name == NULL) {
680     ERROR("bind plugin: Could not determine zone name.");
681     return (-1);
682   }
684   for (j = 0; j < view->zones_num; j++) {
685     if (strcasecmp(zone_name, view->zones[j]) == 0)
686       break;
687   }
689   xmlFree(zone_name);
690   zone_name = NULL;
692   if (j >= view->zones_num)
693     return (0);
695   zone_name = view->zones[j];
697   DEBUG("bind plugin: bind_xml_stats_handle_zone: Found zone `%s'.", zone_name);
699   { /* Parse the <counters> tag {{{ */
700     char plugin_instance[DATA_MAX_NAME_LEN];
701     translation_table_ptr_t table_ptr = {nsstats_translation_table,
702                                          nsstats_translation_table_length,
703                                          plugin_instance};
705     ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-zone-%s",
706               view->name, zone_name);
708     if (version == 3) {
709       list_info_ptr_t list_info = {plugin_instance,
710                                    /* type = */ "dns_qtype"};
711       bind_parse_generic_name_attr_value_list(
712           /* xpath = */ "counters[@type='rcode']",
713           /* callback = */ bind_xml_table_callback,
714           /* user_data = */ &table_ptr, doc, path_ctx, current_time,
715           DS_TYPE_COUNTER);
716       bind_parse_generic_name_attr_value_list(
717           /* xpath = */ "counters[@type='qtype']",
718           /* callback = */ bind_xml_list_callback,
719           /* user_data = */ &list_info, doc, path_ctx, current_time,
720           DS_TYPE_COUNTER);
721     } else {
722       bind_parse_generic_value_list(/* xpath = */ "counters",
723                                     /* callback = */ bind_xml_table_callback,
724                                     /* user_data = */ &table_ptr, doc, path_ctx,
725                                     current_time, DS_TYPE_COUNTER);
726     }
727   } /* }}} */
729   return (0);
730 } /* }}} int bind_xml_stats_handle_zone */
732 static int bind_xml_stats_search_zones(int version, xmlDoc *doc, /* {{{ */
733                                        xmlXPathContext *path_ctx, xmlNode *node,
734                                        cb_view_t *view, time_t current_time) {
735   xmlXPathObject *zone_nodes = NULL;
736   xmlXPathContext *zone_path_context;
738   zone_path_context = xmlXPathNewContext(doc);
739   if (zone_path_context == NULL) {
740     ERROR("bind plugin: xmlXPathNewContext failed.");
741     return (-1);
742   }
744   zone_nodes = xmlXPathEvalExpression(BAD_CAST "zones/zone", path_ctx);
745   if (zone_nodes == NULL) {
746     ERROR("bind plugin: Cannot find any <view> tags.");
747     xmlXPathFreeContext(zone_path_context);
748     return (-1);
749   }
751   for (int i = 0; i < zone_nodes->nodesetval->nodeNr; i++) {
752     node = zone_nodes->nodesetval->nodeTab[i];
753     assert(node != NULL);
755     zone_path_context->node = node;
757     bind_xml_stats_handle_zone(version, doc, zone_path_context, node, view,
758                                current_time);
759   }
761   xmlXPathFreeObject(zone_nodes);
762   xmlXPathFreeContext(zone_path_context);
763   return (0);
764 } /* }}} int bind_xml_stats_search_zones */
766 static int bind_xml_stats_handle_view(int version, xmlDoc *doc, /* {{{ */
767                                       xmlXPathContext *path_ctx, xmlNode *node,
768                                       time_t current_time) {
769   char *view_name = NULL;
770   cb_view_t *view;
771   size_t j;
773   if (version == 3) {
774     view_name = (char *)xmlGetProp(node, BAD_CAST "name");
776     if (view_name == NULL) {
777       ERROR("bind plugin: Could not determine view name.");
778       return (-1);
779     }
781     for (j = 0; j < views_num; j++) {
782       if (strcasecmp(view_name, views[j].name) == 0)
783         break;
784     }
786     xmlFree(view_name);
787     view_name = NULL;
788   } else {
789     xmlXPathObject *path_obj;
790     path_obj = xmlXPathEvalExpression(BAD_CAST "name", path_ctx);
791     if (path_obj == NULL) {
792       ERROR("bind plugin: xmlXPathEvalExpression failed.");
793       return (-1);
794     }
796     for (int i = 0; path_obj->nodesetval && (i < path_obj->nodesetval->nodeNr);
797          i++) {
798       view_name = (char *)xmlNodeListGetString(
799           doc, path_obj->nodesetval->nodeTab[i]->xmlChildrenNode, 1);
800       if (view_name != NULL)
801         break;
802     }
804     if (view_name == NULL) {
805       ERROR("bind plugin: Could not determine view name.");
806       xmlXPathFreeObject(path_obj);
807       return (-1);
808     }
810     for (j = 0; j < views_num; j++) {
811       if (strcasecmp(view_name, views[j].name) == 0)
812         break;
813     }
815     xmlFree(view_name);
816     xmlXPathFreeObject(path_obj);
818     view_name = NULL;
819     path_obj = NULL;
820   }
822   if (j >= views_num)
823     return (0);
825   view = views + j;
827   DEBUG("bind plugin: bind_xml_stats_handle_view: Found view `%s'.",
828         view->name);
830   if (view->qtypes != 0) /* {{{ */
831   {
832     char plugin_instance[DATA_MAX_NAME_LEN];
833     list_info_ptr_t list_info = {plugin_instance,
834                                  /* type = */ "dns_qtype"};
836     ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-qtypes",
837               view->name);
838     if (version == 3) {
839       bind_parse_generic_name_attr_value_list(
840           /* xpath = */ "counters[@type='resqtype']",
841           /* callback = */ bind_xml_list_callback,
842           /* user_data = */ &list_info, doc, path_ctx, current_time,
843           DS_TYPE_COUNTER);
844     } else {
845       bind_parse_generic_name_value(/* xpath = */ "rdtype",
846                                     /* callback = */ bind_xml_list_callback,
847                                     /* user_data = */ &list_info, doc, path_ctx,
848                                     current_time, DS_TYPE_COUNTER);
849     }
850   } /* }}} */
852   if (view->resolver_stats != 0) /* {{{ */
853   {
854     char plugin_instance[DATA_MAX_NAME_LEN];
855     translation_table_ptr_t table_ptr = {resstats_translation_table,
856                                          resstats_translation_table_length,
857                                          plugin_instance};
859     ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-resolver_stats",
860               view->name);
861     if (version == 3) {
862       bind_parse_generic_name_attr_value_list(
863           "counters[@type='resstats']",
864           /* callback = */ bind_xml_table_callback,
865           /* user_data = */ &table_ptr, doc, path_ctx, current_time,
866           DS_TYPE_COUNTER);
867     } else {
868       bind_parse_generic_name_value("resstat",
869                                     /* callback = */ bind_xml_table_callback,
870                                     /* user_data = */ &table_ptr, doc, path_ctx,
871                                     current_time, DS_TYPE_COUNTER);
872     }
873   } /* }}} */
875   /* Record types in the cache */
876   if (view->cacherrsets != 0) /* {{{ */
877   {
878     char plugin_instance[DATA_MAX_NAME_LEN];
879     list_info_ptr_t list_info = {plugin_instance,
880                                  /* type = */ "dns_qtype_cached"};
882     ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-cache_rr_sets",
883               view->name);
885     bind_parse_generic_name_value(/* xpath = */ "cache/rrset",
886                                   /* callback = */ bind_xml_list_callback,
887                                   /* user_data = */ &list_info, doc, path_ctx,
888                                   current_time, DS_TYPE_GAUGE);
889   } /* }}} */
891   if (view->zones_num > 0)
892     bind_xml_stats_search_zones(version, doc, path_ctx, node, view,
893                                 current_time);
895   return (0);
896 } /* }}} int bind_xml_stats_handle_view */
898 static int bind_xml_stats_search_views(int version, xmlDoc *doc, /* {{{ */
899                                        xmlXPathContext *xpathCtx,
900                                        xmlNode *statsnode,
901                                        time_t current_time) {
902   xmlXPathObject *view_nodes = NULL;
903   xmlXPathContext *view_path_context;
905   view_path_context = xmlXPathNewContext(doc);
906   if (view_path_context == NULL) {
907     ERROR("bind plugin: xmlXPathNewContext failed.");
908     return (-1);
909   }
911   view_nodes = xmlXPathEvalExpression(BAD_CAST "views/view", xpathCtx);
912   if (view_nodes == NULL) {
913     ERROR("bind plugin: Cannot find any <view> tags.");
914     xmlXPathFreeContext(view_path_context);
915     return (-1);
916   }
918   for (int i = 0; i < view_nodes->nodesetval->nodeNr; i++) {
919     xmlNode *node;
921     node = view_nodes->nodesetval->nodeTab[i];
922     assert(node != NULL);
924     view_path_context->node = node;
926     bind_xml_stats_handle_view(version, doc, view_path_context, node,
927                                current_time);
928   }
930   xmlXPathFreeObject(view_nodes);
931   xmlXPathFreeContext(view_path_context);
932   return (0);
933 } /* }}} int bind_xml_stats_search_views */
935 static void bind_xml_stats_v3(xmlDoc *doc, /* {{{ */
936                               xmlXPathContext *xpathCtx, xmlNode *statsnode,
937                               time_t current_time) {
938   /* XPath:     server/counters[@type='opcode']
939    * Variables: QUERY, IQUERY, NOTIFY, UPDATE, ...
940    * Layout v3:
941    *   <counters type="opcode">
942    *     <counter name="A">1</counter>
943    *     :
944    *   </counters>
945    */
946   if (global_opcodes != 0) {
947     list_info_ptr_t list_info = {/* plugin instance = */ "global-opcodes",
948                                  /* type = */ "dns_opcode"};
949     bind_parse_generic_name_attr_value_list(
950         /* xpath = */ "server/counters[@type='opcode']",
951         /* callback = */ bind_xml_list_callback,
952         /* user_data = */ &list_info, doc, xpathCtx, current_time,
953         DS_TYPE_COUNTER);
954   }
956   /* XPath:     server/counters[@type='qtype']
957    * Variables: RESERVED0, A, NS, CNAME, SOA, MR, PTR, HINFO, MX, TXT, RP,
958    *            X25, PX, AAAA, LOC, SRV, NAPTR, A6, DS, RRSIG, NSEC, DNSKEY,
959    *            SPF, TKEY, IXFR, AXFR, ANY, ..., Others
960    * Layout v3:
961    *   <counters type="opcode">
962    *     <counter name="A">1</counter>
963    *     :
964    *   </counters>
965    */
966   if (global_qtypes != 0) {
967     list_info_ptr_t list_info = {/* plugin instance = */ "global-qtypes",
968                                  /* type = */ "dns_qtype"};
970     bind_parse_generic_name_attr_value_list(
971         /* xpath = */ "server/counters[@type='qtype']",
972         /* callback = */ bind_xml_list_callback,
973         /* user_data = */ &list_info, doc, xpathCtx, current_time,
974         DS_TYPE_COUNTER);
975   }
977   /* XPath:     server/counters[@type='nsstat']
978    * Variables: Requestv4, Requestv6, ReqEdns0, ReqBadEDNSVer, ReqTSIG,
979    *            ReqSIG0, ReqBadSIG, ReqTCP, AuthQryRej, RecQryRej, XfrRej,
980    *            UpdateRej, Response, TruncatedResp, RespEDNS0, RespTSIG,
981    *            RespSIG0, QrySuccess, QryAuthAns, QryNoauthAns, QryReferral,
982    *            QryNxrrset, QrySERVFAIL, QryFORMERR, QryNXDOMAIN, QryRecursion,
983    *            QryDuplicate, QryDropped, QryFailure, XfrReqDone, UpdateReqFwd,
984    *            UpdateRespFwd, UpdateFwdFail, UpdateDone, UpdateFail,
985    *            UpdateBadPrereq
986    * Layout v3:
987    *   <counters type="nsstat"
988    *     <counter name="Requestv4">1</counter>
989    *     <counter name="Requestv6">0</counter>
990    *     :
991    *   </counter>
992    */
993   if (global_server_stats) {
994     translation_table_ptr_t table_ptr = {
995         nsstats_translation_table, nsstats_translation_table_length,
996         /* plugin_instance = */ "global-server_stats"};
998     bind_parse_generic_name_attr_value_list(
999         "server/counters[@type='nsstat']",
1000         /* callback = */ bind_xml_table_callback,
1001         /* user_data = */ &table_ptr, doc, xpathCtx, current_time,
1002         DS_TYPE_COUNTER);
1003   }
1005   /* XPath:     server/zonestats, server/zonestat,
1006    * server/counters[@type='zonestat']
1007    * Variables: NotifyOutv4, NotifyOutv6, NotifyInv4, NotifyInv6, NotifyRej,
1008    *            SOAOutv4, SOAOutv6, AXFRReqv4, AXFRReqv6, IXFRReqv4, IXFRReqv6,
1009    *            XfrSuccess, XfrFail
1010    * Layout v3:
1011    *   <counters type="zonestat"
1012    *     <counter name="NotifyOutv4">0</counter>
1013    *     <counter name="NotifyOutv6">0</counter>
1014    *     :
1015    *   </counter>
1016    */
1017   if (global_zone_maint_stats) {
1018     translation_table_ptr_t table_ptr = {
1019         zonestats_translation_table, zonestats_translation_table_length,
1020         /* plugin_instance = */ "global-zone_maint_stats"};
1022     bind_parse_generic_name_attr_value_list(
1023         "server/counters[@type='zonestat']",
1024         /* callback = */ bind_xml_table_callback,
1025         /* user_data = */ &table_ptr, doc, xpathCtx, current_time,
1026         DS_TYPE_COUNTER);
1027   }
1029   /* XPath:     server/resstats, server/counters[@type='resstat']
1030    * Variables: Queryv4, Queryv6, Responsev4, Responsev6, NXDOMAIN, SERVFAIL,
1031    *            FORMERR, OtherError, EDNS0Fail, Mismatch, Truncated, Lame,
1032    *            Retry, GlueFetchv4, GlueFetchv6, GlueFetchv4Fail,
1033    *            GlueFetchv6Fail, ValAttempt, ValOk, ValNegOk, ValFail
1034    * Layout v3:
1035    *   <counters type="resstat"
1036    *     <counter name="Queryv4">0</counter>
1037    *     <counter name="Queryv6">0</counter>
1038    *     :
1039    *   </counter>
1040    */
1041   if (global_resolver_stats != 0) {
1042     translation_table_ptr_t table_ptr = {
1043         resstats_translation_table, resstats_translation_table_length,
1044         /* plugin_instance = */ "global-resolver_stats"};
1046     bind_parse_generic_name_attr_value_list(
1047         "server/counters[@type='resstat']",
1048         /* callback = */ bind_xml_table_callback,
1049         /* user_data = */ &table_ptr, doc, xpathCtx, current_time,
1050         DS_TYPE_COUNTER);
1051   }
1052 } /* }}} bind_xml_stats_v3 */
1054 static void bind_xml_stats_v1_v2(int version, xmlDoc *doc, /* {{{ */
1055                                  xmlXPathContext *xpathCtx, xmlNode *statsnode,
1056                                  time_t current_time) {
1057   /* XPath:     server/requests/opcode, server/counters[@type='opcode']
1058    * Variables: QUERY, IQUERY, NOTIFY, UPDATE, ...
1059    * Layout V1 and V2:
1060    *   <opcode>
1061    *     <name>A</name>
1062    *     <counter>1</counter>
1063    *   </opcode>
1064    *   :
1065    */
1066   if (global_opcodes != 0) {
1067     list_info_ptr_t list_info = {/* plugin instance = */ "global-opcodes",
1068                                  /* type = */ "dns_opcode"};
1070     bind_parse_generic_name_value(/* xpath = */ "server/requests/opcode",
1071                                   /* callback = */ bind_xml_list_callback,
1072                                   /* user_data = */ &list_info, doc, xpathCtx,
1073                                   current_time, DS_TYPE_COUNTER);
1074   }
1076   /* XPath:     server/queries-in/rdtype, server/counters[@type='qtype']
1077    * Variables: RESERVED0, A, NS, CNAME, SOA, MR, PTR, HINFO, MX, TXT, RP,
1078    *            X25, PX, AAAA, LOC, SRV, NAPTR, A6, DS, RRSIG, NSEC, DNSKEY,
1079    *            SPF, TKEY, IXFR, AXFR, ANY, ..., Others
1080    * Layout v1 or v2:
1081    *   <rdtype>
1082    *     <name>A</name>
1083    *     <counter>1</counter>
1084    *   </rdtype>
1085    *   :
1086    */
1087   if (global_qtypes != 0) {
1088     list_info_ptr_t list_info = {/* plugin instance = */ "global-qtypes",
1089                                  /* type = */ "dns_qtype"};
1091     bind_parse_generic_name_value(/* xpath = */ "server/queries-in/rdtype",
1092                                   /* callback = */ bind_xml_list_callback,
1093                                   /* user_data = */ &list_info, doc, xpathCtx,
1094                                   current_time, DS_TYPE_COUNTER);
1095   }
1097   /* XPath:     server/nsstats, server/nsstat, server/counters[@type='nsstat']
1098    * Variables: Requestv4, Requestv6, ReqEdns0, ReqBadEDNSVer, ReqTSIG,
1099    *            ReqSIG0, ReqBadSIG, ReqTCP, AuthQryRej, RecQryRej, XfrRej,
1100    *            UpdateRej, Response, TruncatedResp, RespEDNS0, RespTSIG,
1101    *            RespSIG0, QrySuccess, QryAuthAns, QryNoauthAns, QryReferral,
1102    *            QryNxrrset, QrySERVFAIL, QryFORMERR, QryNXDOMAIN, QryRecursion,
1103    *            QryDuplicate, QryDropped, QryFailure, XfrReqDone, UpdateReqFwd,
1104    *            UpdateRespFwd, UpdateFwdFail, UpdateDone, UpdateFail,
1105    *            UpdateBadPrereq
1106    * Layout v1:
1107    *   <nsstats>
1108    *     <Requestv4>1</Requestv4>
1109    *     <Requestv6>0</Requestv6>
1110    *     :
1111    *   </nsstats>
1112    * Layout v2:
1113    *   <nsstat>
1114    *     <name>Requestv4</name>
1115    *     <counter>1</counter>
1116    *   </nsstat>
1117    *   <nsstat>
1118    *     <name>Requestv6</name>
1119    *     <counter>0</counter>
1120    *   </nsstat>
1121    *   :
1122    */
1123   if (global_server_stats) {
1124     translation_table_ptr_t table_ptr = {
1125         nsstats_translation_table, nsstats_translation_table_length,
1126         /* plugin_instance = */ "global-server_stats"};
1128     if (version == 1) {
1129       bind_parse_generic_value_list("server/nsstats",
1130                                     /* callback = */ bind_xml_table_callback,
1131                                     /* user_data = */ &table_ptr, doc, xpathCtx,
1132                                     current_time, DS_TYPE_COUNTER);
1133     } else {
1134       bind_parse_generic_name_value("server/nsstat",
1135                                     /* callback = */ bind_xml_table_callback,
1136                                     /* user_data = */ &table_ptr, doc, xpathCtx,
1137                                     current_time, DS_TYPE_COUNTER);
1138     }
1139   }
1141   /* XPath:     server/zonestats, server/zonestat,
1142    * server/counters[@type='zonestat']
1143    * Variables: NotifyOutv4, NotifyOutv6, NotifyInv4, NotifyInv6, NotifyRej,
1144    *            SOAOutv4, SOAOutv6, AXFRReqv4, AXFRReqv6, IXFRReqv4, IXFRReqv6,
1145    *            XfrSuccess, XfrFail
1146    * Layout v1:
1147    *   <zonestats>
1148    *     <NotifyOutv4>0</NotifyOutv4>
1149    *     <NotifyOutv6>0</NotifyOutv6>
1150    *     :
1151    *   </zonestats>
1152    * Layout v2:
1153    *   <zonestat>
1154    *     <name>NotifyOutv4</name>
1155    *     <counter>0</counter>
1156    *   </zonestat>
1157    *   <zonestat>
1158    *     <name>NotifyOutv6</name>
1159    *     <counter>0</counter>
1160    *   </zonestat>
1161    *   :
1162    */
1163   if (global_zone_maint_stats) {
1164     translation_table_ptr_t table_ptr = {
1165         zonestats_translation_table, zonestats_translation_table_length,
1166         /* plugin_instance = */ "global-zone_maint_stats"};
1168     if (version == 1) {
1169       bind_parse_generic_value_list("server/zonestats",
1170                                     /* callback = */ bind_xml_table_callback,
1171                                     /* user_data = */ &table_ptr, doc, xpathCtx,
1172                                     current_time, DS_TYPE_COUNTER);
1173     } else {
1174       bind_parse_generic_name_value("server/zonestat",
1175                                     /* callback = */ bind_xml_table_callback,
1176                                     /* user_data = */ &table_ptr, doc, xpathCtx,
1177                                     current_time, DS_TYPE_COUNTER);
1178     }
1179   }
1181   /* XPath:     server/resstats, server/counters[@type='resstat']
1182    * Variables: Queryv4, Queryv6, Responsev4, Responsev6, NXDOMAIN, SERVFAIL,
1183    *            FORMERR, OtherError, EDNS0Fail, Mismatch, Truncated, Lame,
1184    *            Retry, GlueFetchv4, GlueFetchv6, GlueFetchv4Fail,
1185    *            GlueFetchv6Fail, ValAttempt, ValOk, ValNegOk, ValFail
1186    * Layout v1:
1187    *   <resstats>
1188    *     <Queryv4>0</Queryv4>
1189    *     <Queryv6>0</Queryv6>
1190    *     :
1191    *   </resstats>
1192    * Layout v2:
1193    *   <resstat>
1194    *     <name>Queryv4</name>
1195    *     <counter>0</counter>
1196    *   </resstat>
1197    *   <resstat>
1198    *     <name>Queryv6</name>
1199    *     <counter>0</counter>
1200    *   </resstat>
1201    *   :
1202    */
1203   if (global_resolver_stats != 0) {
1204     translation_table_ptr_t table_ptr = {
1205         resstats_translation_table, resstats_translation_table_length,
1206         /* plugin_instance = */ "global-resolver_stats"};
1208     if (version == 1) {
1209       bind_parse_generic_value_list("server/resstats",
1210                                     /* callback = */ bind_xml_table_callback,
1211                                     /* user_data = */ &table_ptr, doc, xpathCtx,
1212                                     current_time, DS_TYPE_COUNTER);
1213     } else {
1214       bind_parse_generic_name_value("server/resstat",
1215                                     /* callback = */ bind_xml_table_callback,
1216                                     /* user_data = */ &table_ptr, doc, xpathCtx,
1217                                     current_time, DS_TYPE_COUNTER);
1218     }
1219   }
1220 } /* }}} bind_xml_stats_v1_v2 */
1222 static int bind_xml_stats(int version, xmlDoc *doc, /* {{{ */
1223                           xmlXPathContext *xpathCtx, xmlNode *statsnode) {
1224   time_t current_time = 0;
1225   int status;
1227   xpathCtx->node = statsnode;
1229   /* TODO: Check `server/boot-time' to recognize server restarts. */
1231   status = bind_xml_read_timestamp("server/current-time", doc, xpathCtx,
1232                                    &current_time);
1233   if (status != 0) {
1234     ERROR("bind plugin: Reading `server/current-time' failed.");
1235     return (-1);
1236   }
1237   DEBUG("bind plugin: Current server time is %i.", (int)current_time);
1239   if (version == 3) {
1240     bind_xml_stats_v3(doc, xpathCtx, statsnode, current_time);
1241   } else {
1242     bind_xml_stats_v1_v2(version, doc, xpathCtx, statsnode, current_time);
1243   }
1245   /* XPath:  memory/summary
1246    * Variables: TotalUse, InUse, BlockSize, ContextSize, Lost
1247    * Layout: v2 and v3:
1248    *   <summary>
1249    *     <TotalUse>6587096</TotalUse>
1250    *     <InUse>1345424</InUse>
1251    *     <BlockSize>5505024</BlockSize>
1252    *     <ContextSize>3732456</ContextSize>
1253    *     <Lost>0</Lost>
1254    *   </summary>
1255    */
1256   if (global_memory_stats != 0) {
1257     translation_table_ptr_t table_ptr = {
1258         memsummary_translation_table, memsummary_translation_table_length,
1259         /* plugin_instance = */ "global-memory_stats"};
1261     bind_parse_generic_value_list("memory/summary",
1262                                   /* callback = */ bind_xml_table_callback,
1263                                   /* user_data = */ &table_ptr, doc, xpathCtx,
1264                                   current_time, DS_TYPE_GAUGE);
1265   }
1267   if (views_num > 0)
1268     bind_xml_stats_search_views(version, doc, xpathCtx, statsnode,
1269                                 current_time);
1271   return 0;
1272 } /* }}} int bind_xml_stats */
1274 static int bind_xml(const char *data) /* {{{ */
1276   xmlDoc *doc = NULL;
1277   xmlXPathContext *xpathCtx = NULL;
1278   xmlXPathObject *xpathObj = NULL;
1279   int ret = -1;
1281   doc = xmlParseMemory(data, strlen(data));
1282   if (doc == NULL) {
1283     ERROR("bind plugin: xmlParseMemory failed.");
1284     return (-1);
1285   }
1287   xpathCtx = xmlXPathNewContext(doc);
1288   if (xpathCtx == NULL) {
1289     ERROR("bind plugin: xmlXPathNewContext failed.");
1290     xmlFreeDoc(doc);
1291     return (-1);
1292   }
1294   //
1295   // version 3.* of statistics XML (since BIND9.9)
1296   //
1298   xpathObj = xmlXPathEvalExpression(BAD_CAST "/statistics", xpathCtx);
1299   if (xpathObj == NULL || xpathObj->nodesetval == NULL ||
1300       xpathObj->nodesetval->nodeNr == 0) {
1301     DEBUG("bind plugin: Statistics appears not to be v3");
1302     // we will fallback to v1 or v2 detection
1303     if (xpathObj != NULL) {
1304       xmlXPathFreeObject(xpathObj);
1305     }
1306   } else {
1307     for (int i = 0; i < xpathObj->nodesetval->nodeNr; i++) {
1308       xmlNode *node;
1309       char *attr_version;
1311       node = xpathObj->nodesetval->nodeTab[i];
1312       assert(node != NULL);
1314       attr_version = (char *)xmlGetProp(node, BAD_CAST "version");
1315       if (attr_version == NULL) {
1316         NOTICE("bind plugin: Found <statistics> tag doesn't have a "
1317                "`version' attribute.");
1318         continue;
1319       }
1320       DEBUG("bind plugin: Found: <statistics version=\"%s\">", attr_version);
1322       if (strncmp("3.", attr_version, strlen("3.")) != 0) {
1323         /* TODO: Use the complaint mechanism here. */
1324         NOTICE("bind plugin: Found <statistics> tag with version `%s'. "
1325                "Unfortunately I have no clue how to parse that. "
1326                "Please open a bug report for this.",
1327                attr_version);
1328         xmlFree(attr_version);
1329         continue;
1330       }
1331       ret = bind_xml_stats(3, doc, xpathCtx, node);
1333       xmlFree(attr_version);
1334       /* One <statistics> node ought to be enough. */
1335       break;
1336     }
1338     // we are finished, early-return
1339     xmlXPathFreeObject(xpathObj);
1340     xmlXPathFreeContext(xpathCtx);
1341     xmlFreeDoc(doc);
1343     return (ret);
1344   }
1346   //
1347   // versions 1.* or 2.* of statistics XML
1348   //
1350   xpathObj = xmlXPathEvalExpression(BAD_CAST "/isc/bind/statistics", xpathCtx);
1351   if (xpathObj == NULL) {
1352     ERROR("bind plugin: Cannot find the <statistics> tag.");
1353     xmlXPathFreeContext(xpathCtx);
1354     xmlFreeDoc(doc);
1355     return (-1);
1356   } else if (xpathObj->nodesetval == NULL) {
1357     ERROR("bind plugin: xmlXPathEvalExpression failed.");
1358     xmlXPathFreeObject(xpathObj);
1359     xmlXPathFreeContext(xpathCtx);
1360     xmlFreeDoc(doc);
1361     return (-1);
1362   }
1364   for (int i = 0; i < xpathObj->nodesetval->nodeNr; i++) {
1365     xmlNode *node;
1366     char *attr_version;
1367     int parsed_version = 0;
1369     node = xpathObj->nodesetval->nodeTab[i];
1370     assert(node != NULL);
1372     attr_version = (char *)xmlGetProp(node, BAD_CAST "version");
1373     if (attr_version == NULL) {
1374       NOTICE("bind plugin: Found <statistics> tag doesn't have a "
1375              "`version' attribute.");
1376       continue;
1377     }
1378     DEBUG("bind plugin: Found: <statistics version=\"%s\">", attr_version);
1380     /* At the time this plugin was written, version "1.0" was used by
1381      * BIND 9.5.0, version "2.0" was used by BIND 9.5.1 and 9.6.0. We assume
1382      * that "1.*" and "2.*" don't introduce structural changes, so we just
1383      * check for the first two characters here. */
1384     if (strncmp("1.", attr_version, strlen("1.")) == 0)
1385       parsed_version = 1;
1386     else if (strncmp("2.", attr_version, strlen("2.")) == 0)
1387       parsed_version = 2;
1388     else {
1389       /* TODO: Use the complaint mechanism here. */
1390       NOTICE("bind plugin: Found <statistics> tag with version `%s'. "
1391              "Unfortunately I have no clue how to parse that. "
1392              "Please open a bug report for this.",
1393              attr_version);
1394       xmlFree(attr_version);
1395       continue;
1396     }
1398     ret = bind_xml_stats(parsed_version, doc, xpathCtx, node);
1400     xmlFree(attr_version);
1401     /* One <statistics> node ought to be enough. */
1402     break;
1403   }
1405   xmlXPathFreeObject(xpathObj);
1406   xmlXPathFreeContext(xpathCtx);
1407   xmlFreeDoc(doc);
1409   return (ret);
1410 } /* }}} int bind_xml */
1412 static int bind_config_set_bool(const char *name, int *var, /* {{{ */
1413                                 oconfig_item_t *ci) {
1414   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) {
1415     WARNING("bind plugin: The `%s' option needs "
1416             "exactly one boolean argument.",
1417             name);
1418     return (-1);
1419   }
1421   if (ci->values[0].value.boolean)
1422     *var = 1;
1423   else
1424     *var = 0;
1425   return 0;
1426 } /* }}} int bind_config_set_bool */
1428 static int bind_config_add_view_zone(cb_view_t *view, /* {{{ */
1429                                      oconfig_item_t *ci) {
1430   char **tmp;
1432   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
1433     WARNING("bind plugin: The `Zone' option needs "
1434             "exactly one string argument.");
1435     return (-1);
1436   }
1438   tmp = realloc(view->zones, sizeof(char *) * (view->zones_num + 1));
1439   if (tmp == NULL) {
1440     ERROR("bind plugin: realloc failed.");
1441     return (-1);
1442   }
1443   view->zones = tmp;
1445   view->zones[view->zones_num] = strdup(ci->values[0].value.string);
1446   if (view->zones[view->zones_num] == NULL) {
1447     ERROR("bind plugin: strdup failed.");
1448     return (-1);
1449   }
1450   view->zones_num++;
1452   return (0);
1453 } /* }}} int bind_config_add_view_zone */
1455 static int bind_config_add_view(oconfig_item_t *ci) /* {{{ */
1457   cb_view_t *tmp;
1459   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
1460     WARNING("bind plugin: `View' blocks need exactly one string argument.");
1461     return (-1);
1462   }
1464   tmp = realloc(views, sizeof(*views) * (views_num + 1));
1465   if (tmp == NULL) {
1466     ERROR("bind plugin: realloc failed.");
1467     return (-1);
1468   }
1469   views = tmp;
1470   tmp = views + views_num;
1472   memset(tmp, 0, sizeof(*tmp));
1473   tmp->qtypes = 1;
1474   tmp->resolver_stats = 1;
1475   tmp->cacherrsets = 1;
1476   tmp->zones = NULL;
1477   tmp->zones_num = 0;
1479   tmp->name = strdup(ci->values[0].value.string);
1480   if (tmp->name == NULL) {
1481     ERROR("bind plugin: strdup failed.");
1482     sfree(views);
1483     return (-1);
1484   }
1486   for (int i = 0; i < ci->children_num; i++) {
1487     oconfig_item_t *child = ci->children + i;
1489     if (strcasecmp("QTypes", child->key) == 0)
1490       bind_config_set_bool("QTypes", &tmp->qtypes, child);
1491     else if (strcasecmp("ResolverStats", child->key) == 0)
1492       bind_config_set_bool("ResolverStats", &tmp->resolver_stats, child);
1493     else if (strcasecmp("CacheRRSets", child->key) == 0)
1494       bind_config_set_bool("CacheRRSets", &tmp->cacherrsets, child);
1495     else if (strcasecmp("Zone", child->key) == 0)
1496       bind_config_add_view_zone(tmp, child);
1497     else {
1498       WARNING("bind plugin: Unknown configuration option "
1499               "`%s' in view `%s' will be ignored.",
1500               child->key, tmp->name);
1501     }
1502   } /* for (i = 0; i < ci->children_num; i++) */
1504   views_num++;
1505   return (0);
1506 } /* }}} int bind_config_add_view */
1508 static int bind_config(oconfig_item_t *ci) /* {{{ */
1510   for (int i = 0; i < ci->children_num; i++) {
1511     oconfig_item_t *child = ci->children + i;
1513     if (strcasecmp("Url", child->key) == 0) {
1514       if ((child->values_num != 1) ||
1515           (child->values[0].type != OCONFIG_TYPE_STRING)) {
1516         WARNING("bind plugin: The `Url' option needs "
1517                 "exactly one string argument.");
1518         return (-1);
1519       }
1521       sfree(url);
1522       url = strdup(child->values[0].value.string);
1523     } else if (strcasecmp("OpCodes", child->key) == 0)
1524       bind_config_set_bool("OpCodes", &global_opcodes, child);
1525     else if (strcasecmp("QTypes", child->key) == 0)
1526       bind_config_set_bool("QTypes", &global_qtypes, child);
1527     else if (strcasecmp("ServerStats", child->key) == 0)
1528       bind_config_set_bool("ServerStats", &global_server_stats, child);
1529     else if (strcasecmp("ZoneMaintStats", child->key) == 0)
1530       bind_config_set_bool("ZoneMaintStats", &global_zone_maint_stats, child);
1531     else if (strcasecmp("ResolverStats", child->key) == 0)
1532       bind_config_set_bool("ResolverStats", &global_resolver_stats, child);
1533     else if (strcasecmp("MemoryStats", child->key) == 0)
1534       bind_config_set_bool("MemoryStats", &global_memory_stats, child);
1535     else if (strcasecmp("View", child->key) == 0)
1536       bind_config_add_view(child);
1537     else if (strcasecmp("ParseTime", child->key) == 0)
1538       cf_util_get_boolean(child, &config_parse_time);
1539     else if (strcasecmp("Timeout", child->key) == 0)
1540       cf_util_get_int(child, &timeout);
1541     else {
1542       WARNING("bind plugin: Unknown configuration option "
1543               "`%s' will be ignored.",
1544               child->key);
1545     }
1546   }
1548   return (0);
1549 } /* }}} int bind_config */
1551 static int bind_init(void) /* {{{ */
1553   if (curl != NULL)
1554     return (0);
1556   curl = curl_easy_init();
1557   if (curl == NULL) {
1558     ERROR("bind plugin: bind_init: curl_easy_init failed.");
1559     return (-1);
1560   }
1562   curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
1563   curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, bind_curl_callback);
1564   curl_easy_setopt(curl, CURLOPT_USERAGENT, COLLECTD_USERAGENT);
1565   curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, bind_curl_error);
1566   curl_easy_setopt(curl, CURLOPT_URL, (url != NULL) ? url : BIND_DEFAULT_URL);
1567   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
1568   curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
1569 #ifdef HAVE_CURLOPT_TIMEOUT_MS
1570   curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS,
1571                    (timeout >= 0) ? (long)timeout : (long)CDTIME_T_TO_MS(
1572                                                         plugin_get_interval()));
1573 #endif
1575   return (0);
1576 } /* }}} int bind_init */
1578 static int bind_read(void) /* {{{ */
1580   int status;
1582   if (curl == NULL) {
1583     ERROR("bind plugin: I don't have a CURL object.");
1584     return (-1);
1585   }
1587   bind_buffer_fill = 0;
1588   if (curl_easy_perform(curl) != CURLE_OK) {
1589     ERROR("bind plugin: curl_easy_perform failed: %s", bind_curl_error);
1590     return (-1);
1591   }
1593   status = bind_xml(bind_buffer);
1594   if (status != 0)
1595     return (-1);
1596   else
1597     return (0);
1598 } /* }}} int bind_read */
1600 static int bind_shutdown(void) /* {{{ */
1602   if (curl != NULL) {
1603     curl_easy_cleanup(curl);
1604     curl = NULL;
1605   }
1607   return (0);
1608 } /* }}} int bind_shutdown */
1610 void module_register(void) {
1611   plugin_register_complex_config("bind", bind_config);
1612   plugin_register_init("bind", bind_init);
1613   plugin_register_read("bind", bind_read);
1614   plugin_register_shutdown("bind", bind_shutdown);
1615 } /* void module_register */
1617 /* vim: set sw=2 sts=2 ts=8 et fdm=marker : */