?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Detect FPU by checking CPUID features.
[dragonfly.git] / contrib / bind-9.5.2 / bin / named / statschannel.c
blob8d65935ffe1546afa19b33ec924b972080cf56ca
1 /*
2 * Copyright (C) 2008, 2009 Internet Systems Consortium, Inc. ("ISC")
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
9 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
10 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
11 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
12 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
13 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
14 * PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 /* $Id: statschannel.c,v 1.2.2.19 2009/02/17 03:47:27 marka Exp $ */
18
19 /*! \file */
20
21 #include <config.h>
22
23 #include <isc/buffer.h>
24 #include <isc/httpd.h>
25 #include <isc/mem.h>
26 #include <isc/once.h>
27 #include <isc/print.h>
28 #include <isc/socket.h>
29 #include <isc/stats.h>
30 #include <isc/task.h>
31
32 #include <dns/db.h>
33 #include <dns/opcode.h>
34 #include <dns/resolver.h>
35 #include <dns/rdataclass.h>
36 #include <dns/rdatatype.h>
37 #include <dns/stats.h>
38 #include <dns/view.h>
39 #include <dns/zt.h>
40
41 #include <named/log.h>
42 #include <named/server.h>
43 #include <named/statschannel.h>
44
45 #include "bind9.xsl.h"
46
47 struct ns_statschannel {
48 /* Unlocked */
49 isc_httpdmgr_t *httpdmgr;
50 isc_sockaddr_t address;
51 isc_mem_t *mctx;
52
53 /*
54 * Locked by channel lock: can be referenced and modified by both
55 * the server task and the channel task.
56 */
57 isc_mutex_t lock;
58 dns_acl_t *acl;
59
60 /* Locked by server task */
61 ISC_LINK(struct ns_statschannel) link;
62 };
63
64 typedef enum { statsformat_file, statsformat_xml } statsformat_t;
65
66 typedef struct
67 stats_dumparg {
68 statsformat_t type;
69 void *arg; /* type dependent argument */
70 int ncounters; /* used for general statistics */
71 int *counterindices; /* used for general statistics */
72 isc_uint64_t *countervalues; /* used for general statistics */
73 } stats_dumparg_t;
74
75 static isc_once_t once = ISC_ONCE_INIT;
76
77 /*%
78 * Statistics descriptions. These could be statistically initialized at
79 * compile time, but we configure them run time in the init_desc() function
80 * below so that they'll be less susceptible to counter name changes.
81 */
82 static const char *nsstats_desc[dns_nsstatscounter_max];
83 static const char *resstats_desc[dns_resstatscounter_max];
84 static const char *zonestats_desc[dns_zonestatscounter_max];
85 static const char *sockstats_desc[isc_sockstatscounter_max];
86 #ifdef HAVE_LIBXML2
87 static const char *nsstats_xmldesc[dns_nsstatscounter_max];
88 static const char *resstats_xmldesc[dns_resstatscounter_max];
89 static const char *zonestats_xmldesc[dns_zonestatscounter_max];
90 static const char *sockstats_xmldesc[isc_sockstatscounter_max];
91 #else
92 #define nsstats_xmldesc NULL
93 #define resstats_xmldesc NULL
94 #define zonestats_xmldesc NULL
95 #define sockstats_xmldesc NULL
96 #endif /* HAVE_LIBXML2 */
97
98 /*%
99 * Mapping arrays to represent statistics counters in the order of our
100 * preference, regardless of the order of counter indices. For example,
101 * nsstats_desc[nsstats_index[0]] will be the description that is shown first.
102 */
103 static int nsstats_index[dns_nsstatscounter_max];
104 static int resstats_index[dns_resstatscounter_max];
105 static int zonestats_index[dns_zonestatscounter_max];
106 static int sockstats_index[isc_sockstatscounter_max];
107
108 static inline void
109 set_desc(int counter, int maxcounter, const char *fdesc, const char **fdescs,
110 const char *xdesc, const char **xdescs)
111 {
112 REQUIRE(counter < maxcounter);
113 REQUIRE(fdescs[counter] == NULL);
114 #ifdef HAVE_LIBXML2
115 REQUIRE(xdescs[counter] == NULL);
116 #endif
117
118 fdescs[counter] = fdesc;
119 #ifdef HAVE_LIBXML2
120 xdescs[counter] = xdesc;
121 #else
122 UNUSED(xdesc);
123 UNUSED(xdescs);
124 #endif
125 }
126
127 static void
128 init_desc(void) {
129 int i;
130
131 /* Initialize name server statistics */
132 memset((void *)nsstats_desc, 0,
133 dns_nsstatscounter_max * sizeof(nsstats_desc[0]));
134 #ifdef HAVE_LIBXML2
135 memset((void *)nsstats_xmldesc, 0,
136 dns_nsstatscounter_max * sizeof(nsstats_xmldesc[0]));
137 #endif
138
139 #define SET_NSSTATDESC(counterid, desc, xmldesc) \
140 do { \
141 set_desc(dns_nsstatscounter_ ## counterid, \
142 dns_nsstatscounter_max, \
143 desc, nsstats_desc, xmldesc, nsstats_xmldesc); \
144 nsstats_index[i++] = dns_nsstatscounter_ ## counterid; \
145 } while (0)
146
147 i = 0;
148 SET_NSSTATDESC(requestv4, "IPv4 requests received", "Requestv4");
149 SET_NSSTATDESC(requestv6, "IPv6 requests received", "Requestv6");
150 SET_NSSTATDESC(edns0in, "requests with EDNS(0) received", "ReqEdns0");
151 SET_NSSTATDESC(badednsver,
152 "requests with unsupported EDNS version received",
153 "ReqBadEDNSVer");
154 SET_NSSTATDESC(tsigin, "requests with TSIG received", "ReqTSIG");
155 SET_NSSTATDESC(sig0in, "requests with SIG(0) received", "ReqSIG0");
156 SET_NSSTATDESC(invalidsig, "requests with invalid signature",
157 "ReqBadSIG");
158 SET_NSSTATDESC(tcp, "TCP requests received", "ReqTCP");
159 SET_NSSTATDESC(authrej, "auth queries rejected", "AuthQryRej");
160 SET_NSSTATDESC(recurserej, "recursive queries rejected", "RecQryRej");
161 SET_NSSTATDESC(xfrrej, "transfer requests rejected", "XfrRej");
162 SET_NSSTATDESC(updaterej, "update requests rejected", "UpdateRej");
163 SET_NSSTATDESC(response, "responses sent", "Response");
164 SET_NSSTATDESC(truncatedresp, "truncated responses sent",
165 "TruncatedResp");
166 SET_NSSTATDESC(edns0out, "responses with EDNS(0) sent", "RespEDNS0");
167 SET_NSSTATDESC(tsigout, "responses with TSIG sent", "RespTSIG");
168 SET_NSSTATDESC(sig0out, "responses with SIG(0) sent", "RespSIG0");
169 SET_NSSTATDESC(success, "queries resulted in successful answer",
170 "QrySuccess");
171 SET_NSSTATDESC(authans, "queries resulted in authoritative answer",
172 "QryAuthAns");
173 SET_NSSTATDESC(nonauthans,
174 "queries resulted in non authoritative answer",
175 "QryNoauthAns");
176 SET_NSSTATDESC(referral, "queries resulted in referral answer",
177 "QryReferral");
178 SET_NSSTATDESC(nxrrset, "queries resulted in nxrrset", "QryNxrrset");
179 SET_NSSTATDESC(servfail, "queries resulted in SERVFAIL", "QrySERVFAIL");
180 SET_NSSTATDESC(formerr, "queries resulted in FORMERR", "QryFORMERR");
181 SET_NSSTATDESC(nxdomain, "queries resulted in NXDOMAIN", "QryNXDOMAIN");
182 SET_NSSTATDESC(recursion, "queries caused recursion","QryRecursion");
183 SET_NSSTATDESC(duplicate, "duplicate queries received", "QryDuplicate");
184 SET_NSSTATDESC(dropped, "queries dropped", "QryDropped");
185 SET_NSSTATDESC(failure, "other query failures", "QryFailure");
186 SET_NSSTATDESC(xfrdone, "requested transfers completed", "XfrReqDone");
187 SET_NSSTATDESC(updatereqfwd, "update requests forwarded",
188 "UpdateReqFwd");
189 SET_NSSTATDESC(updaterespfwd, "update responses forwarded",
190 "UpdateRespFwd");
191 SET_NSSTATDESC(updatefwdfail, "update forward failed", "UpdateFwdFail");
192 SET_NSSTATDESC(updatedone, "updates completed", "UpdateDone");
193 SET_NSSTATDESC(updatefail, "updates failed", "UpdateFail");
194 SET_NSSTATDESC(updatebadprereq,
195 "updates rejected due to prerequisite failure",
196 "UpdateBadPrereq");
197 INSIST(i == dns_nsstatscounter_max);
198
199 /* Initialize resolver statistics */
200 memset((void *)resstats_desc, 0,
201 dns_resstatscounter_max * sizeof(resstats_desc[0]));
202 #ifdef HAVE_LIBXML2
203 memset((void *)resstats_xmldesc, 0,
204 dns_resstatscounter_max * sizeof(resstats_xmldesc[0]));
205 #endif
206
207 #define SET_RESSTATDESC(counterid, desc, xmldesc) \
208 do { \
209 set_desc(dns_resstatscounter_ ## counterid, \
210 dns_resstatscounter_max, \
211 desc, resstats_desc, xmldesc, resstats_xmldesc); \
212 resstats_index[i++] = dns_resstatscounter_ ## counterid; \
213 } while (0)
214
215 i = 0;
216 SET_RESSTATDESC(queryv4, "IPv4 queries sent", "Queryv4");
217 SET_RESSTATDESC(queryv6, "IPv6 queries sent", "Queryv6");
218 SET_RESSTATDESC(responsev4, "IPv4 responses received", "Responsev4");
219 SET_RESSTATDESC(responsev6, "IPv6 responses received", "Responsev6");
220 SET_RESSTATDESC(nxdomain, "NXDOMAIN received", "NXDOMAIN");
221 SET_RESSTATDESC(servfail, "SERVFAIL received", "SERVFAIL");
222 SET_RESSTATDESC(formerr, "FORMERR received", "FORMERR");
223 SET_RESSTATDESC(othererror, "other errors received", "OtherError");
224 SET_RESSTATDESC(edns0fail, "EDNS(0) query failures", "EDNS0Fail");
225 SET_RESSTATDESC(mismatch, "mismatch responses received", "Mismatch");
226 SET_RESSTATDESC(truncated, "truncated responses received", "Truncated");
227 SET_RESSTATDESC(lame, "lame delegations received", "Lame");
228 SET_RESSTATDESC(retry, "query retries", "Retry");
229 SET_RESSTATDESC(dispabort, "queries aborted due to quota",
230 "QueryAbort");
231 SET_RESSTATDESC(dispsockfail, "failures in opening query sockets",
232 "QuerySockFail");
233 SET_RESSTATDESC(querytimeout, "query timeouts", "QueryTimeout");
234 SET_RESSTATDESC(gluefetchv4, "IPv4 NS address fetches", "GlueFetchv4");
235 SET_RESSTATDESC(gluefetchv6, "IPv6 NS address fetches", "GlueFetchv6");
236 SET_RESSTATDESC(gluefetchv4fail, "IPv4 NS address fetch failed",
237 "GlueFetchv4Fail");
238 SET_RESSTATDESC(gluefetchv6fail, "IPv6 NS address fetch failed",
239 "GlueFetchv6Fail");
240 SET_RESSTATDESC(val, "DNSSEC validation attempted", "ValAttempt");
241 SET_RESSTATDESC(valsuccess, "DNSSEC validation succeeded", "ValOk");
242 SET_RESSTATDESC(valnegsuccess, "DNSSEC NX validation succeeded",
243 "ValNegOk");
244 SET_RESSTATDESC(valfail, "DNSSEC validation failed", "ValFail");
245 SET_RESSTATDESC(queryrtt0, "queries with RTT < "
246 DNS_RESOLVER_QRYRTTCLASS0STR "ms",
247 "QryRTT" DNS_RESOLVER_QRYRTTCLASS0STR);
248 SET_RESSTATDESC(queryrtt1, "queries with RTT "
249 DNS_RESOLVER_QRYRTTCLASS0STR "-"
250 DNS_RESOLVER_QRYRTTCLASS1STR "ms",
251 "QryRTT" DNS_RESOLVER_QRYRTTCLASS1STR);
252 SET_RESSTATDESC(queryrtt2, "queries with RTT "
253 DNS_RESOLVER_QRYRTTCLASS1STR "-"
254 DNS_RESOLVER_QRYRTTCLASS2STR "ms",
255 "QryRTT" DNS_RESOLVER_QRYRTTCLASS2STR);
256 SET_RESSTATDESC(queryrtt3, "queries with RTT "
257 DNS_RESOLVER_QRYRTTCLASS2STR "-"
258 DNS_RESOLVER_QRYRTTCLASS3STR "ms",
259 "QryRTT" DNS_RESOLVER_QRYRTTCLASS3STR);
260 SET_RESSTATDESC(queryrtt4, "queries with RTT "
261 DNS_RESOLVER_QRYRTTCLASS3STR "-"
262 DNS_RESOLVER_QRYRTTCLASS4STR "ms",
263 "QryRTT" DNS_RESOLVER_QRYRTTCLASS4STR);
264 SET_RESSTATDESC(queryrtt5, "queries with RTT > "
265 DNS_RESOLVER_QRYRTTCLASS4STR "ms",
266 "QryRTT" DNS_RESOLVER_QRYRTTCLASS4STR "+");
267 INSIST(i == dns_resstatscounter_max);
268
269 /* Initialize zone statistics */
270 memset((void *)zonestats_desc, 0,
271 dns_zonestatscounter_max * sizeof(zonestats_desc[0]));
272 #ifdef HAVE_LIBXML2
273 memset((void *)zonestats_xmldesc, 0,
274 dns_zonestatscounter_max * sizeof(zonestats_xmldesc[0]));
275 #endif
276
277 #define SET_ZONESTATDESC(counterid, desc, xmldesc) \
278 do { \
279 set_desc(dns_zonestatscounter_ ## counterid, \
280 dns_zonestatscounter_max, \
281 desc, zonestats_desc, xmldesc, zonestats_xmldesc); \
282 zonestats_index[i++] = dns_zonestatscounter_ ## counterid; \
283 } while (0)
284
285 i = 0;
286 SET_ZONESTATDESC(notifyoutv4, "IPv4 notifies sent", "NotifyOutv4");
287 SET_ZONESTATDESC(notifyoutv6, "IPv6 notifies sent", "NotifyOutv6");
288 SET_ZONESTATDESC(notifyinv4, "IPv4 notifies received", "NotifyInv4");
289 SET_ZONESTATDESC(notifyinv6, "IPv6 notifies received", "NotifyInv6");
290 SET_ZONESTATDESC(notifyrej, "notifies rejected", "NotifyRej");
291 SET_ZONESTATDESC(soaoutv4, "IPv4 SOA queries sent", "SOAOutv4");
292 SET_ZONESTATDESC(soaoutv6, "IPv6 SOA queries sent", "SOAOutv6");
293 SET_ZONESTATDESC(axfrreqv4, "IPv4 AXFR requested", "AXFRReqv4");
294 SET_ZONESTATDESC(axfrreqv6, "IPv6 AXFR requested", "AXFRReqv6");
295 SET_ZONESTATDESC(ixfrreqv4, "IPv4 IXFR requested", "IXFRReqv4");
296 SET_ZONESTATDESC(ixfrreqv6, "IPv6 IXFR requested", "IXFRReqv6");
297 SET_ZONESTATDESC(xfrsuccess, "transfer requests succeeded","XfrSuccess");
298 SET_ZONESTATDESC(xfrfail, "transfer requests failed", "XfrFail");
299 INSIST(i == dns_zonestatscounter_max);
300
301 /* Initialize socket statistics */
302 memset((void *)sockstats_desc, 0,
303 isc_sockstatscounter_max * sizeof(sockstats_desc[0]));
304 #ifdef HAVE_LIBXML2
305 memset((void *)sockstats_xmldesc, 0,
306 isc_sockstatscounter_max * sizeof(sockstats_xmldesc[0]));
307 #endif
308
309 #define SET_SOCKSTATDESC(counterid, desc, xmldesc) \
310 do { \
311 set_desc(isc_sockstatscounter_ ## counterid, \
312 isc_sockstatscounter_max, \
313 desc, sockstats_desc, xmldesc, sockstats_xmldesc); \
314 sockstats_index[i++] = isc_sockstatscounter_ ## counterid; \
315 } while (0)
316
317 i = 0;
318 SET_SOCKSTATDESC(udp4open, "UDP/IPv4 sockets opened", "UDP4Open");
319 SET_SOCKSTATDESC(udp6open, "UDP/IPv6 sockets opened", "UDP6Open");
320 SET_SOCKSTATDESC(tcp4open, "TCP/IPv4 sockets opened", "TCP4Open");
321 SET_SOCKSTATDESC(tcp6open, "TCP/IPv6 sockets opened", "TCP6Open");
322 SET_SOCKSTATDESC(unixopen, "Unix domain sockets opened", "UnixOpen");
323 SET_SOCKSTATDESC(udp4openfail, "UDP/IPv4 socket open failures",
324 "UDP4OpenFail");
325 SET_SOCKSTATDESC(udp6openfail, "UDP/IPv6 socket open failures",
326 "UDP6OpenFail");
327 SET_SOCKSTATDESC(tcp4openfail, "TCP/IPv4 socket open failures",
328 "TCP4OpenFail");
329 SET_SOCKSTATDESC(tcp6openfail, "TCP/IPv6 socket open failures",
330 "TCP6OpenFail");
331 SET_SOCKSTATDESC(unixopenfail, "Unix domain socket open failures",
332 "UnixOpenFail");
333 SET_SOCKSTATDESC(udp4close, "UDP/IPv4 sockets closed", "UDP4Close");
334 SET_SOCKSTATDESC(udp6close, "UDP/IPv6 sockets closed", "UDP6Close");
335 SET_SOCKSTATDESC(tcp4close, "TCP/IPv4 sockets closed", "TCP4Close");
336 SET_SOCKSTATDESC(tcp6close, "TCP/IPv6 sockets closed", "TCP6Close");
337 SET_SOCKSTATDESC(unixclose, "Unix domain sockets closed", "UnixClose");
338 SET_SOCKSTATDESC(fdwatchclose, "FDwatch sockets closed",
339 "FDWatchClose");
340 SET_SOCKSTATDESC(udp4bindfail, "UDP/IPv4 socket bind failures",
341 "UDP4BindFail");
342 SET_SOCKSTATDESC(udp6bindfail, "UDP/IPv6 socket bind failures",
343 "UDP6BindFail");
344 SET_SOCKSTATDESC(tcp4bindfail, "TCP/IPv4 socket bind failures",
345 "TCP4BindFail");
346 SET_SOCKSTATDESC(tcp6bindfail, "TCP/IPv6 socket bind failures",
347 "TCP6BindFail");
348 SET_SOCKSTATDESC(unixbindfail, "Unix domain socket bind failures",
349 "UnixBindFail");
350 SET_SOCKSTATDESC(fdwatchbindfail, "FDwatch socket bind failures",
351 "FdwatchBindFail");
352 SET_SOCKSTATDESC(udp4connectfail, "UDP/IPv4 socket connect failures",
353 "UDP4ConnFail");
354 SET_SOCKSTATDESC(udp6connectfail, "UDP/IPv6 socket connect failures",
355 "UDP6ConnFail");
356 SET_SOCKSTATDESC(tcp4connectfail, "TCP/IPv4 socket connect failures",
357 "TCP4ConnFail");
358 SET_SOCKSTATDESC(tcp6connectfail, "TCP/IPv6 socket connect failures",
359 "TCP6ConnFail");
360 SET_SOCKSTATDESC(unixconnectfail, "Unix domain socket connect failures",
361 "UnixConnFail");
362 SET_SOCKSTATDESC(fdwatchconnectfail, "FDwatch socket connect failures",
363 "FDwatchConnFail");
364 SET_SOCKSTATDESC(udp4connect, "UDP/IPv4 connections established",
365 "UDP4Conn");
366 SET_SOCKSTATDESC(udp6connect, "UDP/IPv6 connections established",
367 "UDP6Conn");
368 SET_SOCKSTATDESC(tcp4connect, "TCP/IPv4 connections established",
369 "TCP4Conn");
370 SET_SOCKSTATDESC(tcp6connect, "TCP/IPv6 connections established",
371 "TCP6Conn");
372 SET_SOCKSTATDESC(unixconnect, "Unix domain connections established",
373 "UnixConn");
374 SET_SOCKSTATDESC(fdwatchconnect,
375 "FDwatch domain connections established",
376 "FDwatchConn");
377 SET_SOCKSTATDESC(tcp4acceptfail, "TCP/IPv4 connection accept failures",
378 "TCP4AcceptFail");
379 SET_SOCKSTATDESC(tcp6acceptfail, "TCP/IPv6 connection accept failures",
380 "TCP6AcceptFail");
381 SET_SOCKSTATDESC(unixacceptfail,
382 "Unix domain connection accept failures",
383 "UnixAcceptFail");
384 SET_SOCKSTATDESC(tcp4accept, "TCP/IPv4 connections accepted",
385 "TCP4Accept");
386 SET_SOCKSTATDESC(tcp6accept, "TCP/IPv6 connections accepted",
387 "TCP6Accept");
388 SET_SOCKSTATDESC(unixaccept, "Unix domain connections accepted",
389 "UnixAccept");
390 SET_SOCKSTATDESC(udp4sendfail, "UDP/IPv4 send errors", "UDP4SendErr");
391 SET_SOCKSTATDESC(udp6sendfail, "UDP/IPv6 send errors", "UDP6SendErr");
392 SET_SOCKSTATDESC(tcp4sendfail, "TCP/IPv4 send errors", "TCP4SendErr");
393 SET_SOCKSTATDESC(tcp6sendfail, "TCP/IPv6 send errors", "TCP6SendErr");
394 SET_SOCKSTATDESC(unixsendfail, "Unix domain send errors",
395 "UnixSendErr");
396 SET_SOCKSTATDESC(fdwatchsendfail, "FDwatch send errors",
397 "FDwatchSendErr");
398 SET_SOCKSTATDESC(udp4recvfail, "UDP/IPv4 recv errors", "UDP4RecvErr");
399 SET_SOCKSTATDESC(udp6recvfail, "UDP/IPv6 recv errors", "UDP6RecvErr");
400 SET_SOCKSTATDESC(tcp4recvfail, "TCP/IPv4 recv errors", "TCP4RecvErr");
401 SET_SOCKSTATDESC(tcp6recvfail, "TCP/IPv6 recv errors", "TCP6RecvErr");
402 SET_SOCKSTATDESC(unixrecvfail, "Unix domain recv errors",
403 "UnixRecvErr");
404 SET_SOCKSTATDESC(fdwatchrecvfail, "FDwatch recv errors",
405 "FDwatchRecvErr");
406 INSIST(i == isc_sockstatscounter_max);
407
408 /* Sanity check */
409 for (i = 0; i < dns_nsstatscounter_max; i++)
410 INSIST(nsstats_desc[i] != NULL);
411 for (i = 0; i < dns_resstatscounter_max; i++)
412 INSIST(resstats_desc[i] != NULL);
413 for (i = 0; i < dns_zonestatscounter_max; i++)
414 INSIST(zonestats_desc[i] != NULL);
415 for (i = 0; i < isc_sockstatscounter_max; i++)
416 INSIST(sockstats_desc[i] != NULL);
417 #ifdef HAVE_LIBXML2
418 for (i = 0; i < dns_nsstatscounter_max; i++)
419 INSIST(nsstats_xmldesc[i] != NULL);
420 for (i = 0; i < dns_resstatscounter_max; i++)
421 INSIST(resstats_xmldesc[i] != NULL);
422 for (i = 0; i < dns_zonestatscounter_max; i++)
423 INSIST(zonestats_xmldesc[i] != NULL);
424 for (i = 0; i < isc_sockstatscounter_max; i++)
425 INSIST(sockstats_xmldesc[i] != NULL);
426 #endif
427 }
428
429 /*%
430 * Dump callback functions.
431 */
432 static void
433 generalstat_dump(isc_statscounter_t counter, isc_uint64_t val, void *arg) {
434 stats_dumparg_t *dumparg = arg;
435
436 REQUIRE(counter < dumparg->ncounters);
437 dumparg->countervalues[counter] = val;
438 }
439
440 static void
441 dump_counters(isc_stats_t *stats, statsformat_t type, void *arg,
442 const char *category, const char **desc, int ncounters,
443 int *indices, isc_uint64_t *values, int options)
444 {
445 int i, index;
446 isc_uint64_t value;
447 stats_dumparg_t dumparg;
448 FILE *fp;
449 #ifdef HAVE_LIBXML2
450 xmlTextWriterPtr writer;
451 #endif
452
453 #ifndef HAVE_LIBXML2
454 UNUSED(category);
455 #endif
456
457 dumparg.type = type;
458 dumparg.ncounters = ncounters;
459 dumparg.counterindices = indices;
460 dumparg.countervalues = values;
461
462 memset(values, 0, sizeof(values[0]) * ncounters);
463 isc_stats_dump(stats, generalstat_dump, &dumparg, options);
464
465 for (i = 0; i < ncounters; i++) {
466 index = indices[i];
467 value = values[index];
468
469 if (value == 0 && (options & ISC_STATSDUMP_VERBOSE) == 0)
470 continue;
471
472 switch (dumparg.type) {
473 case statsformat_file:
474 fp = arg;
475 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n",
476 value, desc[index]);
477 break;
478 case statsformat_xml:
479 #ifdef HAVE_LIBXML2
480 writer = arg;
481
482 if (category != NULL) {
483 xmlTextWriterStartElement(writer,
484 ISC_XMLCHAR
485 category);
486 xmlTextWriterStartElement(writer,
487 ISC_XMLCHAR "name");
488 xmlTextWriterWriteString(writer, ISC_XMLCHAR
489 desc[index]);
490 xmlTextWriterEndElement(writer); /* name */
491
492 xmlTextWriterStartElement(writer, ISC_XMLCHAR
493 "counter");
494 } else {
495 xmlTextWriterStartElement(writer, ISC_XMLCHAR
496 desc[index]);
497 }
498 xmlTextWriterWriteFormatString(writer,
499 "%" ISC_PRINT_QUADFORMAT
500 "u", value);
501 xmlTextWriterEndElement(writer); /* counter */
502 if (category != NULL)
503 xmlTextWriterEndElement(writer); /* category */
504 #endif
505 break;
506 }
507 }
508 }
509
510 static void
511 rdtypestat_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
512 char typebuf[64];
513 const char *typestr;
514 stats_dumparg_t *dumparg = arg;
515 FILE *fp;
516 #ifdef HAVE_LIBXML2
517 xmlTextWriterPtr writer;
518 #endif
519
520 if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_OTHERTYPE)
521 == 0) {
522 dns_rdatatype_format(DNS_RDATASTATSTYPE_BASE(type), typebuf,
523 sizeof(typebuf));
524 typestr = typebuf;
525 } else
526 typestr = "Others";
527
528 switch (dumparg->type) {
529 case statsformat_file:
530 fp = dumparg->arg;
531 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, typestr);
532 break;
533 case statsformat_xml:
534 #ifdef HAVE_LIBXML2
535 writer = dumparg->arg;
536
537 xmlTextWriterStartElement(writer, ISC_XMLCHAR "rdtype");
538
539 xmlTextWriterStartElement(writer, ISC_XMLCHAR "name");
540 xmlTextWriterWriteString(writer, ISC_XMLCHAR typestr);
541 xmlTextWriterEndElement(writer); /* name */
542
543 xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter");
544 xmlTextWriterWriteFormatString(writer,
545 "%" ISC_PRINT_QUADFORMAT "u",
546 val);
547 xmlTextWriterEndElement(writer); /* counter */
548
549 xmlTextWriterEndElement(writer); /* rdtype */
550 #endif
551 break;
552 }
553 }
554
555 static void
556 rdatasetstats_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
557 stats_dumparg_t *dumparg = arg;
558 FILE *fp;
559 char typebuf[64];
560 const char *typestr;
561 isc_boolean_t nxrrset = ISC_FALSE;
562 #ifdef HAVE_LIBXML2
563 xmlTextWriterPtr writer;
564 #endif
565
566 if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_NXDOMAIN)
567 != 0) {
568 typestr = "NXDOMAIN";
569 } else if ((DNS_RDATASTATSTYPE_ATTR(type) &
570 DNS_RDATASTATSTYPE_ATTR_OTHERTYPE) != 0) {
571 typestr = "Others";
572 } else {
573 dns_rdatatype_format(DNS_RDATASTATSTYPE_BASE(type), typebuf,
574 sizeof(typebuf));
575 typestr = typebuf;
576 }
577
578 if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_NXRRSET)
579 != 0)
580 nxrrset = ISC_TRUE;
581
582 switch (dumparg->type) {
583 case statsformat_file:
584 fp = dumparg->arg;
585 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s%s\n", val,
586 nxrrset ? "!" : "", typestr);
587 break;
588 case statsformat_xml:
589 #ifdef HAVE_LIBXML2
590 writer = dumparg->arg;
591
592 xmlTextWriterStartElement(writer, ISC_XMLCHAR "rrset");
593 xmlTextWriterStartElement(writer, ISC_XMLCHAR "name");
594 xmlTextWriterWriteFormatString(writer, "%s%s",
595 nxrrset ? "!" : "", typestr);
596 xmlTextWriterEndElement(writer); /* name */
597
598 xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter");
599 xmlTextWriterWriteFormatString(writer,
600 "%" ISC_PRINT_QUADFORMAT "u",
601 val);
602 xmlTextWriterEndElement(writer); /* counter */
603
604 xmlTextWriterEndElement(writer); /* rrset */
605 #endif
606 break;
607 }
608 }
609
610 static void
611 opcodestat_dump(dns_opcode_t code, isc_uint64_t val, void *arg) {
612 FILE *fp = arg;
613 isc_buffer_t b;
614 char codebuf[64];
615 stats_dumparg_t *dumparg = arg;
616 #ifdef HAVE_LIBXML2
617 xmlTextWriterPtr writer;
618 #endif
619
620 isc_buffer_init(&b, codebuf, sizeof(codebuf) - 1);
621 dns_opcode_totext(code, &b);
622 codebuf[isc_buffer_usedlength(&b)] = '\0';
623
624 switch (dumparg->type) {
625 case statsformat_file:
626 fp = dumparg->arg;
627 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, codebuf);
628 break;
629 case statsformat_xml:
630 #ifdef HAVE_LIBXML2
631 writer = dumparg->arg;
632
633 xmlTextWriterStartElement(writer, ISC_XMLCHAR "opcode");
634
635 xmlTextWriterStartElement(writer, ISC_XMLCHAR "name");
636 xmlTextWriterWriteString(writer, ISC_XMLCHAR codebuf);
637 xmlTextWriterEndElement(writer); /* name */
638
639 xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter");
640 xmlTextWriterWriteFormatString(writer,
641 "%" ISC_PRINT_QUADFORMAT "u",
642 val);
643 xmlTextWriterEndElement(writer); /* counter */
644
645 xmlTextWriterEndElement(writer); /* opcode */
646 #endif
647 break;
648 }
649 }
650
651 #ifdef HAVE_LIBXML2
652
653 /* XXXMLG below here sucks. */
654
655 #define TRY(a) do { result = (a); INSIST(result == ISC_R_SUCCESS); } while(0);
656 #define TRY0(a) do { xmlrc = (a); INSIST(xmlrc >= 0); } while(0);
657
658 static isc_result_t
659 zone_xmlrender(dns_zone_t *zone, void *arg) {
660 char buf[1024 + 32]; /* sufficiently large for zone name and class */
661 dns_rdataclass_t rdclass;
662 isc_uint32_t serial;
663 xmlTextWriterPtr writer = arg;
664 isc_stats_t *zonestats;
665 isc_uint64_t nsstat_values[dns_nsstatscounter_max];
666
667 xmlTextWriterStartElement(writer, ISC_XMLCHAR "zone");
668
669 dns_zone_name(zone, buf, sizeof(buf));
670 xmlTextWriterStartElement(writer, ISC_XMLCHAR "name");
671 xmlTextWriterWriteString(writer, ISC_XMLCHAR buf);
672 xmlTextWriterEndElement(writer);
673
674 rdclass = dns_zone_getclass(zone);
675 dns_rdataclass_format(rdclass, buf, sizeof(buf));
676 xmlTextWriterStartElement(writer, ISC_XMLCHAR "rdataclass");
677 xmlTextWriterWriteString(writer, ISC_XMLCHAR buf);
678 xmlTextWriterEndElement(writer);
679
680 serial = dns_zone_getserial(zone);
681 xmlTextWriterStartElement(writer, ISC_XMLCHAR "serial");
682 xmlTextWriterWriteFormatString(writer, "%u", serial);
683 xmlTextWriterEndElement(writer);
684
685 zonestats = dns_zone_getrequeststats(zone);
686 if (zonestats != NULL) {
687 xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters");
688 dump_counters(zonestats, statsformat_xml, writer, NULL,
689 nsstats_xmldesc, dns_nsstatscounter_max,
690 nsstats_index, nsstat_values,
691 ISC_STATSDUMP_VERBOSE);
692 xmlTextWriterEndElement(writer); /* counters */
693 }
694
695 xmlTextWriterEndElement(writer); /* zone */
696
697 return (ISC_R_SUCCESS);
698 }
699
700 static void
701 generatexml(ns_server_t *server, int *buflen, xmlChar **buf) {
702 char boottime[sizeof "yyyy-mm-ddThh:mm:ssZ"];
703 char nowstr[sizeof "yyyy-mm-ddThh:mm:ssZ"];
704 isc_time_t now;
705 xmlTextWriterPtr writer;
706 xmlDocPtr doc;
707 int xmlrc;
708 dns_view_t *view;
709 stats_dumparg_t dumparg;
710 dns_stats_t *cachestats;
711 isc_uint64_t nsstat_values[dns_nsstatscounter_max];
712 isc_uint64_t resstat_values[dns_resstatscounter_max];
713 isc_uint64_t zonestat_values[dns_zonestatscounter_max];
714 isc_uint64_t sockstat_values[isc_sockstatscounter_max];
715
716 isc_time_now(&now);
717 isc_time_formatISO8601(&ns_g_boottime, boottime, sizeof boottime);
718 isc_time_formatISO8601(&now, nowstr, sizeof nowstr);
719
720 writer = xmlNewTextWriterDoc(&doc, 0);
721 TRY0(xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL));
722 TRY0(xmlTextWriterWritePI(writer, ISC_XMLCHAR "xml-stylesheet",
723 ISC_XMLCHAR "type=\"text/xsl\" href=\"/bind9.xsl\""));
724 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "isc"));
725 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "version",
726 ISC_XMLCHAR "1.0"));
727
728 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "bind"));
729 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "statistics"));
730 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "version",
731 ISC_XMLCHAR "2.0"));
732
733 /* Set common fields for statistics dump */
734 dumparg.type = statsformat_xml;
735 dumparg.arg = writer;
736
737 /*
738 * Start by rendering the views we know of here. For each view we
739 * know of, call its rendering function.
740 */
741 view = ISC_LIST_HEAD(server->viewlist);
742 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "views"));
743 while (view != NULL) {
744 xmlTextWriterStartElement(writer, ISC_XMLCHAR "view");
745
746 xmlTextWriterStartElement(writer, ISC_XMLCHAR "name");
747 xmlTextWriterWriteString(writer, ISC_XMLCHAR view->name);
748 xmlTextWriterEndElement(writer);
749
750 xmlTextWriterStartElement(writer, ISC_XMLCHAR "zones");
751 dns_zt_apply(view->zonetable, ISC_FALSE, zone_xmlrender,
752 writer);
753 xmlTextWriterEndElement(writer);
754
755 if (view->resquerystats != NULL) {
756 dns_rdatatypestats_dump(view->resquerystats,
757 rdtypestat_dump, &dumparg, 0);
758 }
759
760 if (view->resstats != NULL) {
761 dump_counters(view->resstats, statsformat_xml, writer,
762 "resstat", resstats_xmldesc,
763 dns_resstatscounter_max, resstats_index,
764 resstat_values, ISC_STATSDUMP_VERBOSE);
765 }
766
767 cachestats = dns_db_getrrsetstats(view->cachedb);
768 if (cachestats != NULL) {
769 xmlTextWriterStartElement(writer,
770 ISC_XMLCHAR "cache");
771 dns_rdatasetstats_dump(cachestats, rdatasetstats_dump,
772 &dumparg, 0);
773 xmlTextWriterEndElement(writer); /* cache */
774 }
775
776 xmlTextWriterEndElement(writer); /* view */
777
778 view = ISC_LIST_NEXT(view, link);
779 }
780 TRY0(xmlTextWriterEndElement(writer)); /* views */
781
782 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "socketmgr"));
783 isc_socketmgr_renderxml(ns_g_socketmgr, writer);
784 TRY0(xmlTextWriterEndElement(writer)); /* socketmgr */
785
786 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "taskmgr"));
787 isc_taskmgr_renderxml(ns_g_taskmgr, writer);
788 TRY0(xmlTextWriterEndElement(writer)); /* taskmgr */
789
790 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "server"));
791 xmlTextWriterStartElement(writer, ISC_XMLCHAR "boot-time");
792 xmlTextWriterWriteString(writer, ISC_XMLCHAR boottime);
793 xmlTextWriterEndElement(writer);
794 xmlTextWriterStartElement(writer, ISC_XMLCHAR "current-time");
795 xmlTextWriterWriteString(writer, ISC_XMLCHAR nowstr);
796 xmlTextWriterEndElement(writer);
797
798 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "requests"));
799 dns_opcodestats_dump(server->opcodestats, opcodestat_dump, &dumparg,
800 0);
801 xmlTextWriterEndElement(writer); /* requests */
802
803 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "queries-in"));
804 dns_rdatatypestats_dump(server->rcvquerystats, rdtypestat_dump,
805 &dumparg, 0);
806 xmlTextWriterEndElement(writer); /* queries-in */
807
808 dump_counters(server->nsstats, statsformat_xml, writer,
809 "nsstat", nsstats_xmldesc, dns_nsstatscounter_max,
810 nsstats_index, nsstat_values, ISC_STATSDUMP_VERBOSE);
811
812 dump_counters(server->zonestats, statsformat_xml, writer, "zonestat",
813 zonestats_xmldesc, dns_zonestatscounter_max,
814 zonestats_index, zonestat_values, ISC_STATSDUMP_VERBOSE);
815
816 /*
817 * Most of the common resolver statistics entries are 0, so we don't
818 * use the verbose dump here.
819 */
820 dump_counters(server->resolverstats, statsformat_xml, writer, "resstat",
821 resstats_xmldesc, dns_resstatscounter_max, resstats_index,
822 resstat_values, 0);
823
824 dump_counters(server->sockstats, statsformat_xml, writer, "sockstat",
825 sockstats_xmldesc, isc_sockstatscounter_max,
826 sockstats_index, sockstat_values, ISC_STATSDUMP_VERBOSE);
827
828 xmlTextWriterEndElement(writer); /* server */
829
830 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "memory"));
831 isc_mem_renderxml(writer);
832 TRY0(xmlTextWriterEndElement(writer)); /* memory */
833
834 TRY0(xmlTextWriterEndElement(writer)); /* statistics */
835 TRY0(xmlTextWriterEndElement(writer)); /* bind */
836 TRY0(xmlTextWriterEndElement(writer)); /* isc */
837
838 TRY0(xmlTextWriterEndDocument(writer));
839
840 xmlFreeTextWriter(writer);
841
842 xmlDocDumpFormatMemoryEnc(doc, buf, buflen, "UTF-8", 1);
843 xmlFreeDoc(doc);
844 }
845
846 static void
847 wrap_xmlfree(isc_buffer_t *buffer, void *arg) {
848 UNUSED(arg);
849
850 xmlFree(isc_buffer_base(buffer));
851 }
852
853 static isc_result_t
854 render_index(const char *url, const char *querystring, void *arg,
855 unsigned int *retcode, const char **retmsg, const char **mimetype,
856 isc_buffer_t *b, isc_httpdfree_t **freecb,
857 void **freecb_args)
858 {
859 unsigned char *msg;
860 int msglen;
861 ns_server_t *server = arg;
862
863 UNUSED(url);
864 UNUSED(querystring);
865
866 generatexml(server, &msglen, &msg);
867
868 *retcode = 200;
869 *retmsg = "OK";
870 *mimetype = "text/xml";
871 isc_buffer_reinit(b, msg, msglen);
872 isc_buffer_add(b, msglen);
873 *freecb = wrap_xmlfree;
874 *freecb_args = NULL;
875
876 return (ISC_R_SUCCESS);
877 }
878
879 #endif /* HAVE_LIBXML2 */
880
881 static isc_result_t
882 render_xsl(const char *url, const char *querystring, void *args,
883 unsigned int *retcode, const char **retmsg, const char **mimetype,
884 isc_buffer_t *b, isc_httpdfree_t **freecb,
885 void **freecb_args)
886 {
887 UNUSED(url);
888 UNUSED(querystring);
889 UNUSED(args);
890
891 *retcode = 200;
892 *retmsg = "OK";
893 *mimetype = "text/xslt+xml";
894 isc_buffer_reinit(b, xslmsg, strlen(xslmsg));
895 isc_buffer_add(b, strlen(xslmsg));
896 *freecb = NULL;
897 *freecb_args = NULL;
898
899 return (ISC_R_SUCCESS);
900 }
901
902 static void
903 shutdown_listener(ns_statschannel_t *listener) {
904 char socktext[ISC_SOCKADDR_FORMATSIZE];
905 isc_sockaddr_format(&listener->address, socktext, sizeof(socktext));
906 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,NS_LOGMODULE_SERVER,
907 ISC_LOG_NOTICE, "stopping statistics channel on %s",
908 socktext);
909
910 isc_httpdmgr_shutdown(&listener->httpdmgr);
911 }
912
913 static isc_boolean_t
914 client_ok(const isc_sockaddr_t *fromaddr, void *arg) {
915 ns_statschannel_t *listener = arg;
916 isc_netaddr_t netaddr;
917 char socktext[ISC_SOCKADDR_FORMATSIZE];
918 int match;
919
920 REQUIRE(listener != NULL);
921
922 isc_netaddr_fromsockaddr(&netaddr, fromaddr);
923
924 LOCK(&listener->lock);
925 if (dns_acl_match(&netaddr, NULL, listener->acl, &ns_g_server->aclenv,
926 &match, NULL) == ISC_R_SUCCESS && match > 0) {
927 UNLOCK(&listener->lock);
928 return (ISC_TRUE);
929 }
930 UNLOCK(&listener->lock);
931
932 isc_sockaddr_format(fromaddr, socktext, sizeof(socktext));
933 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
934 NS_LOGMODULE_SERVER, ISC_LOG_WARNING,
935 "rejected statistics connection from %s", socktext);
936
937 return (ISC_FALSE);
938 }
939
940 static void
941 destroy_listener(void *arg) {
942 ns_statschannel_t *listener = arg;
943
944 REQUIRE(listener != NULL);
945 REQUIRE(!ISC_LINK_LINKED(listener, link));
946
947 /* We don't have to acquire the lock here since it's already unlinked */
948 dns_acl_detach(&listener->acl);
949
950 DESTROYLOCK(&listener->lock);
951 isc_mem_putanddetach(&listener->mctx, listener, sizeof(*listener));
952 }
953
954 static isc_result_t
955 add_listener(ns_server_t *server, ns_statschannel_t **listenerp,
956 const cfg_obj_t *listen_params, const cfg_obj_t *config,
957 isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
958 const char *socktext)
959 {
960 isc_result_t result;
961 ns_statschannel_t *listener;
962 isc_task_t *task = NULL;
963 isc_socket_t *sock = NULL;
964 const cfg_obj_t *allow;
965 dns_acl_t *new_acl = NULL;
966
967 listener = isc_mem_get(server->mctx, sizeof(*listener));
968 if (listener == NULL)
969 return (ISC_R_NOMEMORY);
970
971 listener->httpdmgr = NULL;
972 listener->address = *addr;
973 listener->acl = NULL;
974 listener->mctx = NULL;
975 ISC_LINK_INIT(listener, link);
976
977 result = isc_mutex_init(&listener->lock);
978 if (result != ISC_R_SUCCESS) {
979 isc_mem_put(server->mctx, listener, sizeof(*listener));
980 return (ISC_R_FAILURE);
981 }
982
983 isc_mem_attach(server->mctx, &listener->mctx);
984
985 allow = cfg_tuple_get(listen_params, "allow");
986 if (allow != NULL && cfg_obj_islist(allow)) {
987 result = cfg_acl_fromconfig(allow, config, ns_g_lctx,
988 aclconfctx, listener->mctx, 0,
989 &new_acl);
990 } else
991 result = dns_acl_any(listener->mctx, &new_acl);
992 if (result != ISC_R_SUCCESS)
993 goto cleanup;
994 dns_acl_attach(new_acl, &listener->acl);
995 dns_acl_detach(&new_acl);
996
997 result = isc_task_create(ns_g_taskmgr, 0, &task);
998 if (result != ISC_R_SUCCESS)
999 goto cleanup;
1000 isc_task_setname(task, "statchannel", NULL);
1001
1002 result = isc_socket_create(ns_g_socketmgr, isc_sockaddr_pf(addr),
1003 isc_sockettype_tcp, &sock);
1004 if (result != ISC_R_SUCCESS)
1005 goto cleanup;
1006 isc_socket_setname(sock, "statchannel", NULL);
1007
1008 #ifndef ISC_ALLOW_MAPPED
1009 isc_socket_ipv6only(sock, ISC_TRUE);
1010 #endif
1011
1012 result = isc_socket_bind(sock, addr, ISC_SOCKET_REUSEADDRESS);
1013 if (result != ISC_R_SUCCESS)
1014 goto cleanup;
1015
1016 result = isc_httpdmgr_create(server->mctx, sock, task, client_ok,
1017 destroy_listener, listener, ns_g_timermgr,
1018 &listener->httpdmgr);
1019 if (result != ISC_R_SUCCESS)
1020 goto cleanup;
1021
1022 #ifdef HAVE_LIBXML2
1023 isc_httpdmgr_addurl(listener->httpdmgr, "/", render_index, server);
1024 #endif
1025 isc_httpdmgr_addurl(listener->httpdmgr, "/bind9.xsl", render_xsl,
1026 server);
1027
1028 *listenerp = listener;
1029 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
1030 NS_LOGMODULE_SERVER, ISC_LOG_NOTICE,
1031 "statistics channel listening on %s", socktext);
1032
1033 cleanup:
1034 if (result != ISC_R_SUCCESS) {
1035 if (listener->acl != NULL)
1036 dns_acl_detach(&listener->acl);
1037 DESTROYLOCK(&listener->lock);
1038 isc_mem_putanddetach(&listener->mctx, listener,
1039 sizeof(*listener));
1040 }
1041 if (task != NULL)
1042 isc_task_detach(&task);
1043 if (sock != NULL)
1044 isc_socket_detach(&sock);
1045
1046 return (result);
1047 }
1048
1049 static void
1050 update_listener(ns_server_t *server, ns_statschannel_t **listenerp,
1051 const cfg_obj_t *listen_params, const cfg_obj_t *config,
1052 isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
1053 const char *socktext)
1054 {
1055 ns_statschannel_t *listener;
1056 const cfg_obj_t *allow = NULL;
1057 dns_acl_t *new_acl = NULL;
1058 isc_result_t result = ISC_R_SUCCESS;
1059
1060 for (listener = ISC_LIST_HEAD(server->statschannels);
1061 listener != NULL;
1062 listener = ISC_LIST_NEXT(listener, link))
1063 if (isc_sockaddr_equal(addr, &listener->address))
1064 break;
1065
1066 if (listener == NULL) {
1067 *listenerp = NULL;
1068 return;
1069 }
1070
1071 /*
1072 * Now, keep the old access list unless a new one can be made.
1073 */
1074 allow = cfg_tuple_get(listen_params, "allow");
1075 if (allow != NULL && cfg_obj_islist(allow)) {
1076 result = cfg_acl_fromconfig(allow, config, ns_g_lctx,
1077 aclconfctx, listener->mctx, 0,
1078 &new_acl);
1079 } else
1080 result = dns_acl_any(listener->mctx, &new_acl);
1081
1082 if (result == ISC_R_SUCCESS) {
1083 LOCK(&listener->lock);
1084
1085 dns_acl_detach(&listener->acl);
1086 dns_acl_attach(new_acl, &listener->acl);
1087 dns_acl_detach(&new_acl);
1088
1089 UNLOCK(&listener->lock);
1090 } else {
1091 cfg_obj_log(listen_params, ns_g_lctx, ISC_LOG_WARNING,
1092 "couldn't install new acl for "
1093 "statistics channel %s: %s",
1094 socktext, isc_result_totext(result));
1095 }
1096
1097 *listenerp = listener;
1098 }
1099
1100 isc_result_t
1101 ns_statschannels_configure(ns_server_t *server, const cfg_obj_t *config,
1102 cfg_aclconfctx_t *aclconfctx)
1103 {
1104 ns_statschannel_t *listener, *listener_next;
1105 ns_statschannellist_t new_listeners;
1106 const cfg_obj_t *statschannellist = NULL;
1107 const cfg_listelt_t *element, *element2;
1108 char socktext[ISC_SOCKADDR_FORMATSIZE];
1109
1110 RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS);
1111
1112 ISC_LIST_INIT(new_listeners);
1113
1114 /*
1115 * Get the list of named.conf 'statistics-channels' statements.
1116 */
1117 (void)cfg_map_get(config, "statistics-channels", &statschannellist);
1118
1119 /*
1120 * Run through the new address/port list, noting sockets that are
1121 * already being listened on and moving them to the new list.
1122 *
1123 * Identifying duplicate addr/port combinations is left to either
1124 * the underlying config code, or to the bind attempt getting an
1125 * address-in-use error.
1126 */
1127 if (statschannellist != NULL) {
1128 #ifndef HAVE_LIBXML2
1129 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
1130 NS_LOGMODULE_SERVER, ISC_LOG_WARNING,
1131 "statistics-channels specified but not effective "
1132 "due to missing XML library");
1133 #endif
1134
1135 for (element = cfg_list_first(statschannellist);
1136 element != NULL;
1137 element = cfg_list_next(element)) {
1138 const cfg_obj_t *statschannel;
1139 const cfg_obj_t *listenercfg = NULL;
1140
1141 statschannel = cfg_listelt_value(element);
1142 (void)cfg_map_get(statschannel, "inet",
1143 &listenercfg);
1144 if (listenercfg == NULL)
1145 continue;
1146
1147 for (element2 = cfg_list_first(listenercfg);
1148 element2 != NULL;
1149 element2 = cfg_list_next(element2)) {
1150 const cfg_obj_t *listen_params;
1151 const cfg_obj_t *obj;
1152 isc_sockaddr_t addr;
1153
1154 listen_params = cfg_listelt_value(element2);
1155
1156 obj = cfg_tuple_get(listen_params, "address");
1157 addr = *cfg_obj_assockaddr(obj);
1158 if (isc_sockaddr_getport(&addr) == 0)
1159 isc_sockaddr_setport(&addr, NS_STATSCHANNEL_HTTPPORT);
1160
1161 isc_sockaddr_format(&addr, socktext,
1162 sizeof(socktext));
1163
1164 isc_log_write(ns_g_lctx,
1165 NS_LOGCATEGORY_GENERAL,
1166 NS_LOGMODULE_SERVER,
1167 ISC_LOG_DEBUG(9),
1168 "processing statistics "
1169 "channel %s",
1170 socktext);
1171
1172 update_listener(server, &listener,
1173 listen_params, config, &addr,
1174 aclconfctx, socktext);
1175
1176 if (listener != NULL) {
1177 /*
1178 * Remove the listener from the old
1179 * list, so it won't be shut down.
1180 */
1181 ISC_LIST_UNLINK(server->statschannels,
1182 listener, link);
1183 } else {
1184 /*
1185 * This is a new listener.
1186 */
1187 isc_result_t r;
1188
1189 r = add_listener(server, &listener,
1190 listen_params, config,
1191 &addr, aclconfctx,
1192 socktext);
1193 if (r != ISC_R_SUCCESS) {
1194 cfg_obj_log(listen_params,
1195 ns_g_lctx,
1196 ISC_LOG_WARNING,
1197 "couldn't allocate "
1198 "statistics channel"
1199 " %s: %s",
1200 socktext,
1201 isc_result_totext(r));
1202 }
1203 }
1204
1205 if (listener != NULL)
1206 ISC_LIST_APPEND(new_listeners, listener,
1207 link);
1208 }
1209 }
1210 }
1211
1212 for (listener = ISC_LIST_HEAD(server->statschannels);
1213 listener != NULL;
1214 listener = listener_next) {
1215 listener_next = ISC_LIST_NEXT(listener, link);
1216 ISC_LIST_UNLINK(server->statschannels, listener, link);
1217 shutdown_listener(listener);
1218 }
1219
1220 ISC_LIST_APPENDLIST(server->statschannels, new_listeners, link);
1221 return (ISC_R_SUCCESS);
1222 }
1223
1224 void
1225 ns_statschannels_shutdown(ns_server_t *server) {
1226 ns_statschannel_t *listener;
1227
1228 while ((listener = ISC_LIST_HEAD(server->statschannels)) != NULL) {
1229 ISC_LIST_UNLINK(server->statschannels, listener, link);
1230 shutdown_listener(listener);
1231 }
1232 }
1233
1234 isc_result_t
1235 ns_stats_dump(ns_server_t *server, FILE *fp) {
1236 isc_stdtime_t now;
1237 isc_result_t result;
1238 dns_view_t *view;
1239 dns_zone_t *zone, *next;
1240 stats_dumparg_t dumparg;
1241 isc_uint64_t nsstat_values[dns_nsstatscounter_max];
1242 isc_uint64_t resstat_values[dns_resstatscounter_max];
1243 isc_uint64_t zonestat_values[dns_zonestatscounter_max];
1244 isc_uint64_t sockstat_values[isc_sockstatscounter_max];
1245
1246 RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS);
1247
1248 /* Set common fields */
1249 dumparg.type = statsformat_file;
1250 dumparg.arg = fp;
1251
1252 isc_stdtime_get(&now);
1253 fprintf(fp, "+++ Statistics Dump +++ (%lu)\n", (unsigned long)now);
1254
1255 fprintf(fp, "++ Incoming Requests ++\n");
1256 dns_opcodestats_dump(server->opcodestats, opcodestat_dump, &dumparg, 0);
1257
1258 fprintf(fp, "++ Incoming Queries ++\n");
1259 dns_rdatatypestats_dump(server->rcvquerystats, rdtypestat_dump,
1260 &dumparg, 0);
1261
1262 fprintf(fp, "++ Outgoing Queries ++\n");
1263 for (view = ISC_LIST_HEAD(server->viewlist);
1264 view != NULL;
1265 view = ISC_LIST_NEXT(view, link)) {
1266 if (view->resquerystats == NULL)
1267 continue;
1268 if (strcmp(view->name, "_default") == 0)
1269 fprintf(fp, "[View: default]\n");
1270 else
1271 fprintf(fp, "[View: %s]\n", view->name);
1272 dns_rdatatypestats_dump(view->resquerystats, rdtypestat_dump,
1273 &dumparg, 0);
1274 }
1275
1276 fprintf(fp, "++ Name Server Statistics ++\n");
1277 dump_counters(server->nsstats, statsformat_file, fp, NULL,
1278 nsstats_desc, dns_nsstatscounter_max, nsstats_index,
1279 nsstat_values, 0);
1280
1281 fprintf(fp, "++ Zone Maintenance Statistics ++\n");
1282 dump_counters(server->zonestats, statsformat_file, fp, NULL,
1283 zonestats_desc, dns_zonestatscounter_max,
1284 zonestats_index, zonestat_values, 0);
1285
1286 fprintf(fp, "++ Resolver Statistics ++\n");
1287 fprintf(fp, "[Common]\n");
1288 dump_counters(server->resolverstats, statsformat_file, fp, NULL,
1289 resstats_desc, dns_resstatscounter_max, resstats_index,
1290 resstat_values, 0);
1291 for (view = ISC_LIST_HEAD(server->viewlist);
1292 view != NULL;
1293 view = ISC_LIST_NEXT(view, link)) {
1294 if (view->resstats == NULL)
1295 continue;
1296 if (strcmp(view->name, "_default") == 0)
1297 fprintf(fp, "[View: default]\n");
1298 else
1299 fprintf(fp, "[View: %s]\n", view->name);
1300 dump_counters(view->resstats, statsformat_file, fp, NULL,
1301 resstats_desc, dns_resstatscounter_max,
1302 resstats_index, resstat_values, 0);
1303 }
1304
1305 fprintf(fp, "++ Cache DB RRsets ++\n");
1306 for (view = ISC_LIST_HEAD(server->viewlist);
1307 view != NULL;
1308 view = ISC_LIST_NEXT(view, link)) {
1309 dns_stats_t *cachestats;
1310
1311 cachestats = dns_db_getrrsetstats(view->cachedb);
1312 if (cachestats == NULL)
1313 continue;
1314 if (strcmp(view->name, "_default") == 0)
1315 fprintf(fp, "[View: default]\n");
1316 else
1317 fprintf(fp, "[View: %s]\n", view->name);
1318 dns_rdatasetstats_dump(cachestats, rdatasetstats_dump, &dumparg,
1319 0);
1320 }
1321
1322 fprintf(fp, "++ Socket I/O Statistics ++\n");
1323 dump_counters(server->sockstats, statsformat_file, fp, NULL,
1324 sockstats_desc, isc_sockstatscounter_max, sockstats_index,
1325 sockstat_values, 0);
1326
1327 fprintf(fp, "++ Per Zone Query Statistics ++\n");
1328 zone = NULL;
1329 for (result = dns_zone_first(server->zonemgr, &zone);
1330 result == ISC_R_SUCCESS;
1331 next = NULL, result = dns_zone_next(zone, &next), zone = next)
1332 {
1333 isc_stats_t *zonestats = dns_zone_getrequeststats(zone);
1334 if (zonestats != NULL) {
1335 char zonename[DNS_NAME_FORMATSIZE];
1336
1337 dns_name_format(dns_zone_getorigin(zone),
1338 zonename, sizeof(zonename));
1339 view = dns_zone_getview(zone);
1340
1341 fprintf(fp, "[%s", zonename);
1342 if (strcmp(view->name, "_default") != 0)
1343 fprintf(fp, " (view: %s)", view->name);
1344 fprintf(fp, "]\n");
1345
1346 dump_counters(zonestats, statsformat_file, fp, NULL,
1347 nsstats_desc, dns_nsstatscounter_max,
1348 nsstats_index, nsstat_values, 0);
1349 }
1350 }
1351
1352 fprintf(fp, "--- Statistics Dump --- (%lu)\n", (unsigned long)now);
1353
1354 return (ISC_R_SUCCESS); /* this function currently always succeeds */
1355 }
DragonFly BSD