contrib/bind9/bin/named/statschannel.c

   1 /*
   2  * Copyright (C) 2008-2013  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.28 2011/03/12 04:59:46 tbox 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/cache.h>
  33 #include <dns/db.h>
  34 #include <dns/opcode.h>
  35 #include <dns/resolver.h>
  36 #include <dns/rdataclass.h>
  37 #include <dns/rdatatype.h>
  38 #include <dns/stats.h>
  39 #include <dns/view.h>
  40 #include <dns/zt.h>
  41
  42 #include <named/log.h>
  43 #include <named/server.h>
  44 #include <named/statschannel.h>
  45
  46 #ifdef NEWSTATS
  47         #include "bind9.ver3.xsl.h"
  48 #else /* OLDSTATS */
  49         #include "bind9.xsl.h"
  50 #endif /* NEWSTATS */
  51
  52 struct ns_statschannel {
  53         /* Unlocked */
  54         isc_httpdmgr_t                          *httpdmgr;
  55         isc_sockaddr_t                          address;
  56         isc_mem_t                               *mctx;
  57
  58         /*
  59          * Locked by channel lock: can be referenced and modified by both
  60          * the server task and the channel task.
  61          */
  62         isc_mutex_t                             lock;
  63         dns_acl_t                               *acl;
  64
  65         /* Locked by server task */
  66         ISC_LINK(struct ns_statschannel)        link;
  67 };
  68
  69 typedef enum { statsformat_file, statsformat_xml } statsformat_t;
  70
  71 typedef struct
  72 stats_dumparg {
  73         statsformat_t   type;
  74         void            *arg;           /* type dependent argument */
  75         int             ncounters;      /* used for general statistics */
  76         int             *counterindices; /* used for general statistics */
  77         isc_uint64_t    *countervalues;  /* used for general statistics */
  78         isc_result_t    result;
  79 } stats_dumparg_t;
  80
  81 static isc_once_t once = ISC_ONCE_INIT;
  82
  83 /*%
  84  * Statistics descriptions.  These could be statistically initialized at
  85  * compile time, but we configure them run time in the init_desc() function
  86  * below so that they'll be less susceptible to counter name changes.
  87  */
  88 static const char *nsstats_desc[dns_nsstatscounter_max];
  89 static const char *resstats_desc[dns_resstatscounter_max];
  90 static const char *zonestats_desc[dns_zonestatscounter_max];
  91 static const char *sockstats_desc[isc_sockstatscounter_max];
  92 static const char *dnssecstats_desc[dns_dnssecstats_max];
  93 #ifdef HAVE_LIBXML2
  94 static const char *nsstats_xmldesc[dns_nsstatscounter_max];
  95 static const char *resstats_xmldesc[dns_resstatscounter_max];
  96 static const char *zonestats_xmldesc[dns_zonestatscounter_max];
  97 static const char *sockstats_xmldesc[isc_sockstatscounter_max];
  98 static const char *dnssecstats_xmldesc[dns_dnssecstats_max];
  99 #else
 100 #define nsstats_xmldesc NULL
 101 #define resstats_xmldesc NULL
 102 #define zonestats_xmldesc NULL
 103 #define sockstats_xmldesc NULL
 104 #define dnssecstats_xmldesc NULL
 105 #endif  /* HAVE_LIBXML2 */
 106
 107 #define TRY0(a) do { xmlrc = (a); if (xmlrc < 0) goto error; } while(0)
 108
 109 /*%
 110  * Mapping arrays to represent statistics counters in the order of our
 111  * preference, regardless of the order of counter indices.  For example,
 112  * nsstats_desc[nsstats_index[0]] will be the description that is shown first.
 113  */
 114 static int nsstats_index[dns_nsstatscounter_max];
 115 static int resstats_index[dns_resstatscounter_max];
 116 static int zonestats_index[dns_zonestatscounter_max];
 117 static int sockstats_index[isc_sockstatscounter_max];
 118 static int dnssecstats_index[dns_dnssecstats_max];
 119
 120 static inline void
 121 set_desc(int counter, int maxcounter, const char *fdesc, const char **fdescs,
 122          const char *xdesc, const char **xdescs)
 123 {
 124         REQUIRE(counter < maxcounter);
 125         REQUIRE(fdescs[counter] == NULL);
 126 #ifdef HAVE_LIBXML2
 127         REQUIRE(xdescs[counter] == NULL);
 128 #endif
 129
 130         fdescs[counter] = fdesc;
 131 #ifdef HAVE_LIBXML2
 132         xdescs[counter] = xdesc;
 133 #else
 134         UNUSED(xdesc);
 135         UNUSED(xdescs);
 136 #endif
 137 }
 138
 139 static void
 140 init_desc(void) {
 141         int i;
 142
 143         /* Initialize name server statistics */
 144         for (i = 0; i < dns_nsstatscounter_max; i++)
 145                 nsstats_desc[i] = NULL;
 146 #ifdef HAVE_LIBXML2
 147         for (i = 0; i < dns_nsstatscounter_max; i++)
 148                 nsstats_xmldesc[i] = NULL;
 149 #endif
 150
 151 #define SET_NSSTATDESC(counterid, desc, xmldesc) \
 152         do { \
 153                 set_desc(dns_nsstatscounter_ ## counterid, \
 154                          dns_nsstatscounter_max, \
 155                          desc, nsstats_desc, xmldesc, nsstats_xmldesc); \
 156                 nsstats_index[i++] = dns_nsstatscounter_ ## counterid; \
 157         } while (0)
 158
 159         i = 0;
 160         SET_NSSTATDESC(requestv4, "IPv4 requests received", "Requestv4");
 161         SET_NSSTATDESC(requestv6, "IPv6 requests received", "Requestv6");
 162         SET_NSSTATDESC(edns0in, "requests with EDNS(0) received", "ReqEdns0");
 163         SET_NSSTATDESC(badednsver,
 164                        "requests with unsupported EDNS version received",
 165                        "ReqBadEDNSVer");
 166         SET_NSSTATDESC(tsigin, "requests with TSIG received", "ReqTSIG");
 167         SET_NSSTATDESC(sig0in, "requests with SIG(0) received", "ReqSIG0");
 168         SET_NSSTATDESC(invalidsig, "requests with invalid signature",
 169                        "ReqBadSIG");
 170         SET_NSSTATDESC(tcp, "TCP requests received", "ReqTCP");
 171         SET_NSSTATDESC(authrej, "auth queries rejected", "AuthQryRej");
 172         SET_NSSTATDESC(recurserej, "recursive queries rejected", "RecQryRej");
 173         SET_NSSTATDESC(xfrrej, "transfer requests rejected", "XfrRej");
 174         SET_NSSTATDESC(updaterej, "update requests rejected", "UpdateRej");
 175         SET_NSSTATDESC(response, "responses sent", "Response");
 176         SET_NSSTATDESC(truncatedresp, "truncated responses sent",
 177                        "TruncatedResp");
 178         SET_NSSTATDESC(edns0out, "responses with EDNS(0) sent", "RespEDNS0");
 179         SET_NSSTATDESC(tsigout, "responses with TSIG sent", "RespTSIG");
 180         SET_NSSTATDESC(sig0out, "responses with SIG(0) sent", "RespSIG0");
 181         SET_NSSTATDESC(success, "queries resulted in successful answer",
 182                        "QrySuccess");
 183         SET_NSSTATDESC(authans, "queries resulted in authoritative answer",
 184                        "QryAuthAns");
 185         SET_NSSTATDESC(nonauthans,
 186                        "queries resulted in non authoritative answer",
 187                        "QryNoauthAns");
 188         SET_NSSTATDESC(referral, "queries resulted in referral answer",
 189                        "QryReferral");
 190         SET_NSSTATDESC(nxrrset, "queries resulted in nxrrset", "QryNxrrset");
 191         SET_NSSTATDESC(servfail, "queries resulted in SERVFAIL", "QrySERVFAIL");
 192         SET_NSSTATDESC(formerr, "queries resulted in FORMERR", "QryFORMERR");
 193         SET_NSSTATDESC(nxdomain, "queries resulted in NXDOMAIN", "QryNXDOMAIN");
 194         SET_NSSTATDESC(recursion, "queries caused recursion", "QryRecursion");
 195         SET_NSSTATDESC(duplicate, "duplicate queries received", "QryDuplicate");
 196         SET_NSSTATDESC(dropped, "queries dropped", "QryDropped");
 197         SET_NSSTATDESC(failure, "other query failures", "QryFailure");
 198         SET_NSSTATDESC(xfrdone, "requested transfers completed", "XfrReqDone");
 199         SET_NSSTATDESC(updatereqfwd, "update requests forwarded",
 200                        "UpdateReqFwd");
 201         SET_NSSTATDESC(updaterespfwd, "update responses forwarded",
 202                        "UpdateRespFwd");
 203         SET_NSSTATDESC(updatefwdfail, "update forward failed", "UpdateFwdFail");
 204         SET_NSSTATDESC(updatedone, "updates completed", "UpdateDone");
 205         SET_NSSTATDESC(updatefail, "updates failed", "UpdateFail");
 206         SET_NSSTATDESC(updatebadprereq,
 207                        "updates rejected due to prerequisite failure",
 208                        "UpdateBadPrereq");
 209         SET_NSSTATDESC(rpz_rewrites, "response policy zone rewrites",
 210                        "RPZRewrites");
 211         INSIST(i == dns_nsstatscounter_max);
 212
 213         /* Initialize resolver statistics */
 214         for (i = 0; i < dns_resstatscounter_max; i++)
 215                 resstats_desc[i] = NULL;
 216 #ifdef  HAVE_LIBXML2
 217         for (i = 0; i < dns_resstatscounter_max; i++)
 218                 resstats_xmldesc[i] = NULL;
 219 #endif
 220
 221 #define SET_RESSTATDESC(counterid, desc, xmldesc) \
 222         do { \
 223                 set_desc(dns_resstatscounter_ ## counterid, \
 224                          dns_resstatscounter_max, \
 225                          desc, resstats_desc, xmldesc, resstats_xmldesc); \
 226                 resstats_index[i++] = dns_resstatscounter_ ## counterid; \
 227         } while (0)
 228
 229         i = 0;
 230         SET_RESSTATDESC(queryv4, "IPv4 queries sent", "Queryv4");
 231         SET_RESSTATDESC(queryv6, "IPv6 queries sent", "Queryv6");
 232         SET_RESSTATDESC(responsev4, "IPv4 responses received", "Responsev4");
 233         SET_RESSTATDESC(responsev6, "IPv6 responses received", "Responsev6");
 234         SET_RESSTATDESC(nxdomain, "NXDOMAIN received", "NXDOMAIN");
 235         SET_RESSTATDESC(servfail, "SERVFAIL received", "SERVFAIL");
 236         SET_RESSTATDESC(formerr, "FORMERR received", "FORMERR");
 237         SET_RESSTATDESC(othererror, "other errors received", "OtherError");
 238         SET_RESSTATDESC(edns0fail, "EDNS(0) query failures", "EDNS0Fail");
 239         SET_RESSTATDESC(mismatch, "mismatch responses received", "Mismatch");
 240         SET_RESSTATDESC(truncated, "truncated responses received", "Truncated");
 241         SET_RESSTATDESC(lame, "lame delegations received", "Lame");
 242         SET_RESSTATDESC(retry, "query retries", "Retry");
 243         SET_RESSTATDESC(dispabort, "queries aborted due to quota",
 244                         "QueryAbort");
 245         SET_RESSTATDESC(dispsockfail, "failures in opening query sockets",
 246                         "QuerySockFail");
 247         SET_RESSTATDESC(querytimeout, "query timeouts", "QueryTimeout");
 248         SET_RESSTATDESC(gluefetchv4, "IPv4 NS address fetches", "GlueFetchv4");
 249         SET_RESSTATDESC(gluefetchv6, "IPv6 NS address fetches", "GlueFetchv6");
 250         SET_RESSTATDESC(gluefetchv4fail, "IPv4 NS address fetch failed",
 251                         "GlueFetchv4Fail");
 252         SET_RESSTATDESC(gluefetchv6fail, "IPv6 NS address fetch failed",
 253                         "GlueFetchv6Fail");
 254         SET_RESSTATDESC(val, "DNSSEC validation attempted", "ValAttempt");
 255         SET_RESSTATDESC(valsuccess, "DNSSEC validation succeeded", "ValOk");
 256         SET_RESSTATDESC(valnegsuccess, "DNSSEC NX validation succeeded",
 257                         "ValNegOk");
 258         SET_RESSTATDESC(valfail, "DNSSEC validation failed", "ValFail");
 259         SET_RESSTATDESC(queryrtt0, "queries with RTT < "
 260                         DNS_RESOLVER_QRYRTTCLASS0STR "ms",
 261                         "QryRTT" DNS_RESOLVER_QRYRTTCLASS0STR);
 262         SET_RESSTATDESC(queryrtt1, "queries with RTT "
 263                         DNS_RESOLVER_QRYRTTCLASS0STR "-"
 264                         DNS_RESOLVER_QRYRTTCLASS1STR "ms",
 265                         "QryRTT" DNS_RESOLVER_QRYRTTCLASS1STR);
 266         SET_RESSTATDESC(queryrtt2, "queries with RTT "
 267                         DNS_RESOLVER_QRYRTTCLASS1STR "-"
 268                         DNS_RESOLVER_QRYRTTCLASS2STR "ms",
 269                         "QryRTT" DNS_RESOLVER_QRYRTTCLASS2STR);
 270         SET_RESSTATDESC(queryrtt3, "queries with RTT "
 271                         DNS_RESOLVER_QRYRTTCLASS2STR "-"
 272                         DNS_RESOLVER_QRYRTTCLASS3STR "ms",
 273                         "QryRTT" DNS_RESOLVER_QRYRTTCLASS3STR);
 274         SET_RESSTATDESC(queryrtt4, "queries with RTT "
 275                         DNS_RESOLVER_QRYRTTCLASS3STR "-"
 276                         DNS_RESOLVER_QRYRTTCLASS4STR "ms",
 277                         "QryRTT" DNS_RESOLVER_QRYRTTCLASS4STR);
 278         SET_RESSTATDESC(queryrtt5, "queries with RTT > "
 279                         DNS_RESOLVER_QRYRTTCLASS4STR "ms",
 280                         "QryRTT" DNS_RESOLVER_QRYRTTCLASS4STR "+");
 281         INSIST(i == dns_resstatscounter_max);
 282
 283         /* Initialize zone statistics */
 284         for (i = 0; i < dns_zonestatscounter_max; i++)
 285                 zonestats_desc[i] = NULL;
 286 #ifdef  HAVE_LIBXML2
 287         for (i = 0; i < dns_zonestatscounter_max; i++)
 288                 zonestats_xmldesc[i] = NULL;
 289 #endif
 290
 291 #define SET_ZONESTATDESC(counterid, desc, xmldesc) \
 292         do { \
 293                 set_desc(dns_zonestatscounter_ ## counterid, \
 294                          dns_zonestatscounter_max, \
 295                          desc, zonestats_desc, xmldesc, zonestats_xmldesc); \
 296                 zonestats_index[i++] = dns_zonestatscounter_ ## counterid; \
 297         } while (0)
 298
 299         i = 0;
 300         SET_ZONESTATDESC(notifyoutv4, "IPv4 notifies sent", "NotifyOutv4");
 301         SET_ZONESTATDESC(notifyoutv6, "IPv6 notifies sent", "NotifyOutv6");
 302         SET_ZONESTATDESC(notifyinv4, "IPv4 notifies received", "NotifyInv4");
 303         SET_ZONESTATDESC(notifyinv6, "IPv6 notifies received", "NotifyInv6");
 304         SET_ZONESTATDESC(notifyrej, "notifies rejected", "NotifyRej");
 305         SET_ZONESTATDESC(soaoutv4, "IPv4 SOA queries sent", "SOAOutv4");
 306         SET_ZONESTATDESC(soaoutv6, "IPv6 SOA queries sent", "SOAOutv6");
 307         SET_ZONESTATDESC(axfrreqv4, "IPv4 AXFR requested", "AXFRReqv4");
 308         SET_ZONESTATDESC(axfrreqv6, "IPv6 AXFR requested", "AXFRReqv6");
 309         SET_ZONESTATDESC(ixfrreqv4, "IPv4 IXFR requested", "IXFRReqv4");
 310         SET_ZONESTATDESC(ixfrreqv6, "IPv6 IXFR requested", "IXFRReqv6");
 311         SET_ZONESTATDESC(xfrsuccess, "transfer requests succeeded",
 312                          "XfrSuccess");
 313         SET_ZONESTATDESC(xfrfail, "transfer requests failed", "XfrFail");
 314         INSIST(i == dns_zonestatscounter_max);
 315
 316         /* Initialize socket statistics */
 317         for (i = 0; i < isc_sockstatscounter_max; i++)
 318                 sockstats_desc[i] = NULL;
 319 #ifdef  HAVE_LIBXML2
 320         for (i = 0; i < isc_sockstatscounter_max; i++)
 321                 sockstats_xmldesc[i] = NULL;
 322 #endif
 323
 324 #define SET_SOCKSTATDESC(counterid, desc, xmldesc) \
 325         do { \
 326                 set_desc(isc_sockstatscounter_ ## counterid, \
 327                          isc_sockstatscounter_max, \
 328                          desc, sockstats_desc, xmldesc, sockstats_xmldesc); \
 329                 sockstats_index[i++] = isc_sockstatscounter_ ## counterid; \
 330         } while (0)
 331
 332         i = 0;
 333         SET_SOCKSTATDESC(udp4open, "UDP/IPv4 sockets opened", "UDP4Open");
 334         SET_SOCKSTATDESC(udp6open, "UDP/IPv6 sockets opened", "UDP6Open");
 335         SET_SOCKSTATDESC(tcp4open, "TCP/IPv4 sockets opened", "TCP4Open");
 336         SET_SOCKSTATDESC(tcp6open, "TCP/IPv6 sockets opened", "TCP6Open");
 337         SET_SOCKSTATDESC(unixopen, "Unix domain sockets opened", "UnixOpen");
 338         SET_SOCKSTATDESC(udp4openfail, "UDP/IPv4 socket open failures",
 339                          "UDP4OpenFail");
 340         SET_SOCKSTATDESC(udp6openfail, "UDP/IPv6 socket open failures",
 341                          "UDP6OpenFail");
 342         SET_SOCKSTATDESC(tcp4openfail, "TCP/IPv4 socket open failures",
 343                          "TCP4OpenFail");
 344         SET_SOCKSTATDESC(tcp6openfail, "TCP/IPv6 socket open failures",
 345                          "TCP6OpenFail");
 346         SET_SOCKSTATDESC(unixopenfail, "Unix domain socket open failures",
 347                          "UnixOpenFail");
 348         SET_SOCKSTATDESC(udp4close, "UDP/IPv4 sockets closed", "UDP4Close");
 349         SET_SOCKSTATDESC(udp6close, "UDP/IPv6 sockets closed", "UDP6Close");
 350         SET_SOCKSTATDESC(tcp4close, "TCP/IPv4 sockets closed", "TCP4Close");
 351         SET_SOCKSTATDESC(tcp6close, "TCP/IPv6 sockets closed", "TCP6Close");
 352         SET_SOCKSTATDESC(unixclose, "Unix domain sockets closed", "UnixClose");
 353         SET_SOCKSTATDESC(fdwatchclose, "FDwatch sockets closed",
 354                          "FDWatchClose");
 355         SET_SOCKSTATDESC(udp4bindfail, "UDP/IPv4 socket bind failures",
 356                          "UDP4BindFail");
 357         SET_SOCKSTATDESC(udp6bindfail, "UDP/IPv6 socket bind failures",
 358                          "UDP6BindFail");
 359         SET_SOCKSTATDESC(tcp4bindfail, "TCP/IPv4 socket bind failures",
 360                          "TCP4BindFail");
 361         SET_SOCKSTATDESC(tcp6bindfail, "TCP/IPv6 socket bind failures",
 362                          "TCP6BindFail");
 363         SET_SOCKSTATDESC(unixbindfail, "Unix domain socket bind failures",
 364                          "UnixBindFail");
 365         SET_SOCKSTATDESC(fdwatchbindfail, "FDwatch socket bind failures",
 366                          "FdwatchBindFail");
 367         SET_SOCKSTATDESC(udp4connectfail, "UDP/IPv4 socket connect failures",
 368                          "UDP4ConnFail");
 369         SET_SOCKSTATDESC(udp6connectfail, "UDP/IPv6 socket connect failures",
 370                          "UDP6ConnFail");
 371         SET_SOCKSTATDESC(tcp4connectfail, "TCP/IPv4 socket connect failures",
 372                          "TCP4ConnFail");
 373         SET_SOCKSTATDESC(tcp6connectfail, "TCP/IPv6 socket connect failures",
 374                          "TCP6ConnFail");
 375         SET_SOCKSTATDESC(unixconnectfail, "Unix domain socket connect failures",
 376                          "UnixConnFail");
 377         SET_SOCKSTATDESC(fdwatchconnectfail, "FDwatch socket connect failures",
 378                          "FDwatchConnFail");
 379         SET_SOCKSTATDESC(udp4connect, "UDP/IPv4 connections established",
 380                          "UDP4Conn");
 381         SET_SOCKSTATDESC(udp6connect, "UDP/IPv6 connections established",
 382                          "UDP6Conn");
 383         SET_SOCKSTATDESC(tcp4connect, "TCP/IPv4 connections established",
 384                          "TCP4Conn");
 385         SET_SOCKSTATDESC(tcp6connect, "TCP/IPv6 connections established",
 386                          "TCP6Conn");
 387         SET_SOCKSTATDESC(unixconnect, "Unix domain connections established",
 388                          "UnixConn");
 389         SET_SOCKSTATDESC(fdwatchconnect,
 390                          "FDwatch domain connections established",
 391                          "FDwatchConn");
 392         SET_SOCKSTATDESC(tcp4acceptfail, "TCP/IPv4 connection accept failures",
 393                          "TCP4AcceptFail");
 394         SET_SOCKSTATDESC(tcp6acceptfail, "TCP/IPv6 connection accept failures",
 395                          "TCP6AcceptFail");
 396         SET_SOCKSTATDESC(unixacceptfail,
 397                          "Unix domain connection accept failures",
 398                          "UnixAcceptFail");
 399         SET_SOCKSTATDESC(tcp4accept, "TCP/IPv4 connections accepted",
 400                          "TCP4Accept");
 401         SET_SOCKSTATDESC(tcp6accept, "TCP/IPv6 connections accepted",
 402                          "TCP6Accept");
 403         SET_SOCKSTATDESC(unixaccept, "Unix domain connections accepted",
 404                          "UnixAccept");
 405         SET_SOCKSTATDESC(udp4sendfail, "UDP/IPv4 send errors", "UDP4SendErr");
 406         SET_SOCKSTATDESC(udp6sendfail, "UDP/IPv6 send errors", "UDP6SendErr");
 407         SET_SOCKSTATDESC(tcp4sendfail, "TCP/IPv4 send errors", "TCP4SendErr");
 408         SET_SOCKSTATDESC(tcp6sendfail, "TCP/IPv6 send errors", "TCP6SendErr");
 409         SET_SOCKSTATDESC(unixsendfail, "Unix domain send errors",
 410                          "UnixSendErr");
 411         SET_SOCKSTATDESC(fdwatchsendfail, "FDwatch send errors",
 412                          "FDwatchSendErr");
 413         SET_SOCKSTATDESC(udp4recvfail, "UDP/IPv4 recv errors", "UDP4RecvErr");
 414         SET_SOCKSTATDESC(udp6recvfail, "UDP/IPv6 recv errors", "UDP6RecvErr");
 415         SET_SOCKSTATDESC(tcp4recvfail, "TCP/IPv4 recv errors", "TCP4RecvErr");
 416         SET_SOCKSTATDESC(tcp6recvfail, "TCP/IPv6 recv errors", "TCP6RecvErr");
 417         SET_SOCKSTATDESC(unixrecvfail, "Unix domain recv errors",
 418                          "UnixRecvErr");
 419         SET_SOCKSTATDESC(fdwatchrecvfail, "FDwatch recv errors",
 420                          "FDwatchRecvErr");
 421         INSIST(i == isc_sockstatscounter_max);
 422
 423         /* Initialize DNSSEC statistics */
 424         for (i = 0; i < dns_dnssecstats_max; i++)
 425                 dnssecstats_desc[i] = NULL;
 426 #ifdef  HAVE_LIBXML2
 427         for (i = 0; i < dns_dnssecstats_max; i++)
 428                 dnssecstats_xmldesc[i] = NULL;
 429 #endif
 430
 431 #define SET_DNSSECSTATDESC(counterid, desc, xmldesc) \
 432         do { \
 433                 set_desc(dns_dnssecstats_ ## counterid, \
 434                          dns_dnssecstats_max, \
 435                          desc, dnssecstats_desc, \
 436                          xmldesc, dnssecstats_xmldesc); \
 437                 dnssecstats_index[i++] = dns_dnssecstats_ ## counterid; \
 438         } while (0)
 439
 440         i = 0;
 441         SET_DNSSECSTATDESC(asis, "dnssec validation success with signer "
 442                            "\"as is\"", "DNSSECasis");
 443         SET_DNSSECSTATDESC(downcase, "dnssec validation success with signer "
 444                            "lower cased", "DNSSECdowncase");
 445         SET_DNSSECSTATDESC(wildcard, "dnssec validation of wildcard signature",
 446                            "DNSSECwild");
 447         SET_DNSSECSTATDESC(fail, "dnssec validation failures", "DNSSECfail");
 448         INSIST(i == dns_dnssecstats_max);
 449
 450         /* Sanity check */
 451         for (i = 0; i < dns_nsstatscounter_max; i++)
 452                 INSIST(nsstats_desc[i] != NULL);
 453         for (i = 0; i < dns_resstatscounter_max; i++)
 454                 INSIST(resstats_desc[i] != NULL);
 455         for (i = 0; i < dns_zonestatscounter_max; i++)
 456                 INSIST(zonestats_desc[i] != NULL);
 457         for (i = 0; i < isc_sockstatscounter_max; i++)
 458                 INSIST(sockstats_desc[i] != NULL);
 459         for (i = 0; i < dns_dnssecstats_max; i++)
 460                 INSIST(dnssecstats_desc[i] != NULL);
 461 #ifdef  HAVE_LIBXML2
 462         for (i = 0; i < dns_nsstatscounter_max; i++)
 463                 INSIST(nsstats_xmldesc[i] != NULL);
 464         for (i = 0; i < dns_resstatscounter_max; i++)
 465                 INSIST(resstats_xmldesc[i] != NULL);
 466         for (i = 0; i < dns_zonestatscounter_max; i++)
 467                 INSIST(zonestats_xmldesc[i] != NULL);
 468         for (i = 0; i < isc_sockstatscounter_max; i++)
 469                 INSIST(sockstats_xmldesc[i] != NULL);
 470         for (i = 0; i < dns_dnssecstats_max; i++)
 471                 INSIST(dnssecstats_xmldesc[i] != NULL);
 472 #endif
 473 }
 474
 475 /*%
 476  * Dump callback functions.
 477  */
 478 static void
 479 generalstat_dump(isc_statscounter_t counter, isc_uint64_t val, void *arg) {
 480         stats_dumparg_t *dumparg = arg;
 481
 482         REQUIRE(counter < dumparg->ncounters);
 483         dumparg->countervalues[counter] = val;
 484 }
 485
 486 static isc_result_t
 487 dump_counters(isc_stats_t *stats, statsformat_t type, void *arg,
 488               const char *category, const char **desc, int ncounters,
 489               int *indices, isc_uint64_t *values, int options)
 490 {
 491         int i, index;
 492         isc_uint64_t value;
 493         stats_dumparg_t dumparg;
 494         FILE *fp;
 495 #ifdef HAVE_LIBXML2
 496         xmlTextWriterPtr writer;
 497         int xmlrc;
 498 #endif
 499
 500 #ifndef HAVE_LIBXML2
 501         UNUSED(category);
 502 #endif
 503
 504         dumparg.type = type;
 505         dumparg.ncounters = ncounters;
 506         dumparg.counterindices = indices;
 507         dumparg.countervalues = values;
 508
 509         memset(values, 0, sizeof(values[0]) * ncounters);
 510         isc_stats_dump(stats, generalstat_dump, &dumparg, options);
 511
 512         for (i = 0; i < ncounters; i++) {
 513                 index = indices[i];
 514                 value = values[index];
 515
 516                 if (value == 0 && (options & ISC_STATSDUMP_VERBOSE) == 0)
 517                         continue;
 518
 519                 switch (dumparg.type) {
 520                 case statsformat_file:
 521                         fp = arg;
 522                         fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n",
 523                                 value, desc[index]);
 524                         break;
 525                 case statsformat_xml:
 526 #ifdef HAVE_LIBXML2
 527 #ifdef NEWSTATS
 528                 writer = arg;
 529
 530                 if (category != NULL) {
 531                         /* <NameOfCategory> */
 532                         TRY0(xmlTextWriterStartElement(writer,
 533                                                        ISC_XMLCHAR
 534                                                        category));
 535                         /* <name> inside category */
 536                         TRY0(xmlTextWriterStartElement(writer,
 537                                                        ISC_XMLCHAR
 538                                                        "name"));
 539                         TRY0(xmlTextWriterWriteString(writer,
 540                                                       ISC_XMLCHAR
 541                                                       desc[index]));
 542                         TRY0(xmlTextWriterEndElement(writer));
 543                         /* </name> */
 544
 545                         /* <counter> */
 546                         TRY0(xmlTextWriterStartElement(writer,
 547                                                        ISC_XMLCHAR
 548                                                        "counter"));
 549                         TRY0(xmlTextWriterWriteFormatString(writer,
 550                                 "%" ISC_PRINT_QUADFORMAT "u", value));
 551
 552                         TRY0(xmlTextWriterEndElement(writer));
 553                         /* </counter> */
 554                         TRY0(xmlTextWriterEndElement(writer));
 555                         /* </NameOfCategory> */
 556
 557                 } else {
 558                         TRY0(xmlTextWriterStartElement(writer,
 559                                                        ISC_XMLCHAR
 560                                                        "counter"));
 561                         TRY0(xmlTextWriterWriteAttribute(writer,
 562                                                          ISC_XMLCHAR
 563                                                          "name",
 564                                                          ISC_XMLCHAR
 565                                                          desc[index]));
 566                         TRY0(xmlTextWriterWriteFormatString(writer,
 567                                 "%" ISC_PRINT_QUADFORMAT "u", value));
 568                         TRY0(xmlTextWriterEndElement(writer));
 569                         /* counter */
 570                 }
 571 #else /* !NEWSTATS */
 572                         writer = arg;
 573
 574                         if (category != NULL) {
 575                                 TRY0(xmlTextWriterStartElement(writer,
 576                                                                ISC_XMLCHAR
 577                                                                category));
 578                                 TRY0(xmlTextWriterStartElement(writer,
 579                                                                ISC_XMLCHAR
 580                                                                "name"));
 581                                 TRY0(xmlTextWriterWriteString(writer,
 582                                                               ISC_XMLCHAR
 583                                                               desc[index]));
 584                                 TRY0(xmlTextWriterEndElement(writer)); /* name */
 585
 586                                 TRY0(xmlTextWriterStartElement(writer,
 587                                                                ISC_XMLCHAR
 588                                                                "counter"));
 589                         } else {
 590                                 TRY0(xmlTextWriterStartElement(writer,
 591                                                                ISC_XMLCHAR
 592                                                                desc[index]));
 593                         }
 594                         TRY0(xmlTextWriterWriteFormatString(writer,
 595                                                             "%"
 596                                                             ISC_PRINT_QUADFORMAT
 597                                                             "u", value));
 598                         TRY0(xmlTextWriterEndElement(writer)); /* counter */
 599                         if (category != NULL)
 600                                 TRY0(xmlTextWriterEndElement(writer)); /* category */
 601 #endif /* NEWSTATS */
 602 #endif /* LIBXML2 */
 603                         break;
 604                 }
 605         }
 606         return (ISC_R_SUCCESS);
 607 #ifdef HAVE_LIBXML2
 608  error:
 609         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_SERVER,
 610                       ISC_LOG_ERROR, "failed at dump_counters()");
 611         return (ISC_R_FAILURE);
 612 #endif
 613 }
 614
 615 #ifdef NEWSTATS
 616 static void
 617 rdtypestat_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
 618         char typebuf[64];
 619         const char *typestr;
 620         stats_dumparg_t *dumparg = arg;
 621         FILE *fp;
 622 #ifdef HAVE_LIBXML2
 623         xmlTextWriterPtr writer;
 624         int xmlrc;
 625 #endif
 626
 627         if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_OTHERTYPE)
 628             == 0) {
 629                 dns_rdatatype_format(DNS_RDATASTATSTYPE_BASE(type), typebuf,
 630                                      sizeof(typebuf));
 631                 typestr = typebuf;
 632         } else
 633                 typestr = "Others";
 634
 635         switch (dumparg->type) {
 636         case statsformat_file:
 637                 fp = dumparg->arg;
 638                 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, typestr);
 639                 break;
 640         case statsformat_xml:
 641 #ifdef HAVE_LIBXML2
 642
 643                 writer = dumparg->arg;
 644
 645
 646                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter"));
 647                 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name",
 648                                                  ISC_XMLCHAR typestr));
 649
 650                 TRY0(xmlTextWriterWriteFormatString(writer,
 651                                                "%" ISC_PRINT_QUADFORMAT "u",
 652                                                val));
 653
 654                 TRY0(xmlTextWriterEndElement(writer)); /* type */
 655 #endif
 656                 break;
 657         }
 658         return;
 659 #ifdef HAVE_LIBXML2
 660  error:
 661         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_SERVER,
 662                       ISC_LOG_ERROR, "failed at rdtypestat_dump()");
 663         dumparg->result = ISC_R_FAILURE;
 664         return;
 665 #endif
 666 }
 667 #else  /* NEWSTATS */
 668 static void
 669 rdtypestat_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
 670         char typebuf[64];
 671         const char *typestr;
 672         stats_dumparg_t *dumparg = arg;
 673         FILE *fp;
 674 #ifdef HAVE_LIBXML2
 675         xmlTextWriterPtr writer;
 676         int xmlrc;
 677 #endif
 678
 679         if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_OTHERTYPE)
 680             == 0) {
 681                 dns_rdatatype_format(DNS_RDATASTATSTYPE_BASE(type), typebuf,
 682                                      sizeof(typebuf));
 683                 typestr = typebuf;
 684         } else
 685                 typestr = "Others";
 686
 687         switch (dumparg->type) {
 688         case statsformat_file:
 689                 fp = dumparg->arg;
 690                 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, typestr);
 691                 break;
 692         case statsformat_xml:
 693 #ifdef HAVE_LIBXML2
 694                 writer = dumparg->arg;
 695
 696                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "rdtype"));
 697
 698                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "name"));
 699                 TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR typestr));
 700                 TRY0(xmlTextWriterEndElement(writer)); /* name */
 701
 702                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter"));
 703                 TRY0(xmlTextWriterWriteFormatString(writer,
 704                                                "%" ISC_PRINT_QUADFORMAT "u",
 705                                                val));
 706                 TRY0(xmlTextWriterEndElement(writer)); /* counter */
 707
 708                 TRY0(xmlTextWriterEndElement(writer)); /* rdtype */
 709 #endif
 710                 break;
 711         }
 712         return;
 713 #ifdef HAVE_LIBXML2
 714  error:
 715         dumparg->result = ISC_R_FAILURE;
 716         return;
 717 #endif
 718 }
 719 #endif  /* NEWSTATS */
 720
 721 static void
 722 rdatasetstats_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
 723         stats_dumparg_t *dumparg = arg;
 724         FILE *fp;
 725         char typebuf[64];
 726         const char *typestr;
 727         isc_boolean_t nxrrset = ISC_FALSE;
 728 #ifdef HAVE_LIBXML2
 729         xmlTextWriterPtr writer;
 730         int xmlrc;
 731 #endif
 732
 733         if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_NXDOMAIN)
 734             != 0) {
 735                 typestr = "NXDOMAIN";
 736         } else if ((DNS_RDATASTATSTYPE_ATTR(type) &
 737                     DNS_RDATASTATSTYPE_ATTR_OTHERTYPE) != 0) {
 738                 typestr = "Others";
 739         } else {
 740                 dns_rdatatype_format(DNS_RDATASTATSTYPE_BASE(type), typebuf,
 741                                      sizeof(typebuf));
 742                 typestr = typebuf;
 743         }
 744
 745         if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_NXRRSET)
 746             != 0)
 747                 nxrrset = ISC_TRUE;
 748
 749         switch (dumparg->type) {
 750         case statsformat_file:
 751                 fp = dumparg->arg;
 752                 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s%s\n", val,
 753                         nxrrset ? "!" : "", typestr);
 754                 break;
 755         case statsformat_xml:
 756 #ifdef HAVE_LIBXML2
 757                 writer = dumparg->arg;
 758
 759                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "rrset"));
 760                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "name"));
 761                 TRY0(xmlTextWriterWriteFormatString(writer, "%s%s",
 762                                                nxrrset ? "!" : "", typestr));
 763                 TRY0(xmlTextWriterEndElement(writer)); /* name */
 764
 765                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter"));
 766                 TRY0(xmlTextWriterWriteFormatString(writer,
 767                                                "%" ISC_PRINT_QUADFORMAT "u",
 768                                                val));
 769                 TRY0(xmlTextWriterEndElement(writer)); /* counter */
 770
 771                 TRY0(xmlTextWriterEndElement(writer)); /* rrset */
 772 #endif
 773                 break;
 774         }
 775         return;
 776 #ifdef HAVE_LIBXML2
 777  error:
 778         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_SERVER,
 779                       ISC_LOG_ERROR, "failed at rdatasetstats_dump()");
 780         dumparg->result = ISC_R_FAILURE;
 781 #endif
 782
 783 }
 784
 785 #ifdef NEWSTATS
 786 static void
 787 opcodestat_dump(dns_opcode_t code, isc_uint64_t val, void *arg) {
 788         FILE *fp;
 789         isc_buffer_t b;
 790         char codebuf[64];
 791         stats_dumparg_t *dumparg = arg;
 792 #ifdef HAVE_LIBXML2
 793         xmlTextWriterPtr writer;
 794         int xmlrc;
 795 #endif
 796
 797         isc_buffer_init(&b, codebuf, sizeof(codebuf) - 1);
 798         dns_opcode_totext(code, &b);
 799         codebuf[isc_buffer_usedlength(&b)] = '\0';
 800
 801         switch (dumparg->type) {
 802         case statsformat_file:
 803                 fp = dumparg->arg;
 804                 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, codebuf);
 805                 break;
 806         case statsformat_xml:
 807 #ifdef HAVE_LIBXML2
 808                 writer = dumparg->arg;
 809                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter"));
 810                 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name",
 811                                                  ISC_XMLCHAR codebuf ));
 812                 TRY0(xmlTextWriterWriteFormatString(writer,
 813                                                        "%" ISC_PRINT_QUADFORMAT "u",
 814                                                        val));
 815                 TRY0(xmlTextWriterEndElement(writer)); /* counter */
 816 #endif
 817                 break;
 818         }
 819         return;
 820
 821 #ifdef HAVE_LIBXML2
 822  error:
 823         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_SERVER,
 824                       ISC_LOG_ERROR, "failed at opcodestat_dump()");
 825         dumparg->result = ISC_R_FAILURE;
 826         return;
 827 #endif
 828 }
 829 #else  /* NEWSTATS */
 830 static void
 831 opcodestat_dump(dns_opcode_t code, isc_uint64_t val, void *arg) {
 832         FILE *fp;
 833         isc_buffer_t b;
 834         char codebuf[64];
 835         stats_dumparg_t *dumparg = arg;
 836 #ifdef HAVE_LIBXML2
 837         xmlTextWriterPtr writer;
 838         int xmlrc;
 839 #endif
 840
 841         isc_buffer_init(&b, codebuf, sizeof(codebuf) - 1);
 842         dns_opcode_totext(code, &b);
 843         codebuf[isc_buffer_usedlength(&b)] = '\0';
 844
 845         switch (dumparg->type) {
 846         case statsformat_file:
 847                 fp = dumparg->arg;
 848                 fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, codebuf);
 849                 break;
 850         case statsformat_xml:
 851 #ifdef HAVE_LIBXML2
 852                 writer = dumparg->arg;
 853
 854                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "opcode"));
 855
 856                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "name"));
 857                 TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR codebuf));
 858                 TRY0(xmlTextWriterEndElement(writer)); /* name */
 859
 860                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter"));
 861                 TRY0(xmlTextWriterWriteFormatString(writer,
 862                                                "%" ISC_PRINT_QUADFORMAT "u",
 863                                                val));
 864                 TRY0(xmlTextWriterEndElement(writer)); /* counter */
 865
 866                 TRY0(xmlTextWriterEndElement(writer)); /* opcode */
 867 #endif
 868                 break;
 869         }
 870         return;
 871
 872 #ifdef HAVE_LIBXML2
 873  error:
 874         dumparg->result = ISC_R_FAILURE;
 875         return;
 876 #endif
 877 }
 878 #endif  /* NEWSTATS */
 879
 880 #ifdef HAVE_LIBXML2
 881
 882 /* XXXMLG below here sucks. (not so much) */
 883
 884 #ifdef NEWSTATS
 885 static isc_result_t
 886 zone_xmlrender(dns_zone_t *zone, void *arg) {
 887         isc_result_t result;
 888         char buf[1024 + 32];    /* sufficiently large for zone name and class */
 889         char *zone_name_only = NULL;
 890         dns_rdataclass_t rdclass;
 891         isc_uint32_t serial;
 892         xmlTextWriterPtr writer = arg;
 893         isc_stats_t *zonestats;
 894         dns_stats_t *rcvquerystats;
 895         dns_zonestat_level_t statlevel;
 896         isc_uint64_t nsstat_values[dns_nsstatscounter_max];
 897         int xmlrc;
 898         stats_dumparg_t dumparg;
 899
 900         statlevel = dns_zone_getstatlevel(zone);
 901         if (statlevel == dns_zonestat_none)
 902                 return (ISC_R_SUCCESS);
 903
 904         dumparg.type = statsformat_xml;
 905         dumparg.arg = writer;
 906
 907         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "zone"));
 908         dns_zone_name(zone, buf, sizeof(buf));
 909         zone_name_only = strtok(buf, "/");
 910         if(zone_name_only == NULL)
 911                 zone_name_only = buf;
 912
 913         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name",
 914                                          ISC_XMLCHAR zone_name_only));
 915         rdclass = dns_zone_getclass(zone);
 916         dns_rdataclass_format(rdclass, buf, sizeof(buf));
 917         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "rdataclass",
 918                                          ISC_XMLCHAR buf));
 919
 920         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "serial"));
 921         if (dns_zone_getserial2(zone, &serial) == ISC_R_SUCCESS)
 922                 TRY0(xmlTextWriterWriteFormatString(writer, "%u", serial));
 923         else
 924                 TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR "-"));
 925         TRY0(xmlTextWriterEndElement(writer)); /* serial */
 926
 927         zonestats = dns_zone_getrequeststats(zone);
 928         rcvquerystats = dns_zone_getrcvquerystats(zone);
 929         if (statlevel == dns_zonestat_full && zonestats != NULL) {
 930                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
 931                 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
 932                                                  ISC_XMLCHAR "rcode"));
 933
 934                 result = dump_counters(zonestats, statsformat_xml, writer,
 935                                        NULL, nsstats_xmldesc,
 936                                        dns_nsstatscounter_max, nsstats_index,
 937                                        nsstat_values, ISC_STATSDUMP_VERBOSE);
 938                 if (result != ISC_R_SUCCESS)
 939                         goto error;
 940                 /* counters type="rcode"*/
 941                 TRY0(xmlTextWriterEndElement(writer));
 942         }
 943
 944         if (statlevel == dns_zonestat_full && rcvquerystats != NULL) {
 945                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
 946                 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
 947                                                  ISC_XMLCHAR "qtype"));
 948
 949                 dumparg.result = ISC_R_SUCCESS;
 950                 dns_rdatatypestats_dump(rcvquerystats, rdtypestat_dump,
 951                                         &dumparg, 0);
 952                 if(dumparg.result != ISC_R_SUCCESS)
 953                         goto error;
 954
 955                 /* counters type="qtype"*/
 956                 TRY0(xmlTextWriterEndElement(writer));
 957         }
 958
 959         TRY0(xmlTextWriterEndElement(writer)); /* zone */
 960
 961         return (ISC_R_SUCCESS);
 962  error:
 963         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_SERVER,
 964                       ISC_LOG_ERROR, "Failed at zone_xmlrender()");
 965         return (ISC_R_FAILURE);
 966 }
 967 #else  /* NEWSTATS */
 968 static isc_result_t
 969 zone_xmlrender(dns_zone_t *zone, void *arg) {
 970         char buf[1024 + 32];    /* sufficiently large for zone name and class */
 971         dns_rdataclass_t rdclass;
 972         isc_uint32_t serial;
 973         xmlTextWriterPtr writer = arg;
 974         isc_stats_t *zonestats;
 975         isc_uint64_t nsstat_values[dns_nsstatscounter_max];
 976         int xmlrc;
 977         isc_result_t result;
 978
 979         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "zone"));
 980
 981         dns_zone_name(zone, buf, sizeof(buf));
 982         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "name"));
 983         TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR buf));
 984         TRY0(xmlTextWriterEndElement(writer));
 985
 986         rdclass = dns_zone_getclass(zone);
 987         dns_rdataclass_format(rdclass, buf, sizeof(buf));
 988         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "rdataclass"));
 989         TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR buf));
 990         TRY0(xmlTextWriterEndElement(writer));
 991
 992         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "serial"));
 993         if (dns_zone_getserial2(zone, &serial) == ISC_R_SUCCESS)
 994                 TRY0(xmlTextWriterWriteFormatString(writer, "%u", serial));
 995         else
 996                 TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR "-"));
 997         TRY0(xmlTextWriterEndElement(writer));
 998
 999         zonestats = dns_zone_getrequeststats(zone);
1000         if (zonestats != NULL) {
1001                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
1002                 result = dump_counters(zonestats, statsformat_xml, writer, NULL,
1003                                       nsstats_xmldesc, dns_nsstatscounter_max,
1004                                       nsstats_index, nsstat_values,
1005                                       ISC_STATSDUMP_VERBOSE);
1006                 if (result != ISC_R_SUCCESS)
1007                         goto error;
1008                 TRY0(xmlTextWriterEndElement(writer)); /* counters */
1009         }
1010
1011         TRY0(xmlTextWriterEndElement(writer)); /* zone */
1012
1013         return (ISC_R_SUCCESS);
1014  error:
1015         return (ISC_R_FAILURE);
1016 }
1017 #endif  /* NEWSTATS */
1018
1019 #ifdef NEWSTATS
1020 static isc_result_t
1021 generatexml(ns_server_t *server, int *buflen, xmlChar **buf) {
1022         char boottime[sizeof "yyyy-mm-ddThh:mm:ssZ"];
1023         char nowstr[sizeof "yyyy-mm-ddThh:mm:ssZ"];
1024         isc_time_t now;
1025         xmlTextWriterPtr writer = NULL;
1026         xmlDocPtr doc = NULL;
1027         int xmlrc;
1028         dns_view_t *view;
1029         stats_dumparg_t dumparg;
1030         dns_stats_t *cacherrstats;
1031         isc_uint64_t nsstat_values[dns_nsstatscounter_max];
1032         isc_uint64_t resstat_values[dns_resstatscounter_max];
1033         isc_uint64_t zonestat_values[dns_zonestatscounter_max];
1034         isc_uint64_t sockstat_values[isc_sockstatscounter_max];
1035         isc_result_t result;
1036
1037         isc_time_now(&now);
1038         isc_time_formatISO8601(&ns_g_boottime, boottime, sizeof boottime);
1039         isc_time_formatISO8601(&now, nowstr, sizeof nowstr);
1040
1041         writer = xmlNewTextWriterDoc(&doc, 0);
1042         if (writer == NULL)
1043                 goto error;
1044         TRY0(xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL));
1045         TRY0(xmlTextWriterWritePI(writer, ISC_XMLCHAR "xml-stylesheet",
1046                         ISC_XMLCHAR "type=\"text/xsl\" href=\"/bind9.ver3.xsl\""));
1047         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "statistics"));
1048         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "version",
1049                                          ISC_XMLCHAR "3.0"));
1050
1051         /* Set common fields for statistics dump */
1052         dumparg.type = statsformat_xml;
1053         dumparg.arg = writer;
1054
1055         /*
1056          * Start by rendering the views we know of here.  For each view we
1057          * know of, call its rendering function.
1058          */
1059         view = ISC_LIST_HEAD(server->viewlist);
1060         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "views"));
1061         while (view != NULL) {
1062                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "view"));
1063                 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name",
1064                                                  ISC_XMLCHAR view->name));
1065
1066                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "zones"));
1067                 result = dns_zt_apply(view->zonetable, ISC_TRUE, zone_xmlrender,
1068                                       writer);
1069                 if (result != ISC_R_SUCCESS)
1070                         goto error;
1071                 TRY0(xmlTextWriterEndElement(writer)); /* zones */
1072
1073                 TRY0(xmlTextWriterStartElement(writer,
1074                                                ISC_XMLCHAR "counters"));
1075                 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
1076                                                  ISC_XMLCHAR "resqtype"));
1077
1078                 if (view->resquerystats != NULL) {
1079                         dumparg.result = ISC_R_SUCCESS;
1080                         dns_rdatatypestats_dump(view->resquerystats,
1081                                                 rdtypestat_dump, &dumparg, 0);
1082                         if (dumparg.result != ISC_R_SUCCESS)
1083                                 goto error;
1084                 }
1085                 TRY0(xmlTextWriterEndElement(writer));
1086
1087                 /* <resstats> */
1088                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
1089                 TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
1090                                                  ISC_XMLCHAR "resstats"));
1091                 if (view->resstats != NULL) {
1092                         result = dump_counters(view->resstats,
1093                                                statsformat_xml, writer,
1094                                                NULL, resstats_xmldesc,
1095                                                dns_resstatscounter_max,
1096                                                resstats_index, resstat_values,
1097                                                ISC_STATSDUMP_VERBOSE);
1098                         if (result != ISC_R_SUCCESS)
1099                                 goto error;
1100                 }
1101                 TRY0(xmlTextWriterEndElement(writer)); /* </resstats> */
1102
1103                 cacherrstats = dns_db_getrrsetstats(view->cachedb);
1104                 if (cacherrstats != NULL) {
1105                         TRY0(xmlTextWriterStartElement(writer,
1106                                                        ISC_XMLCHAR "cache"));
1107                         TRY0(xmlTextWriterWriteAttribute(writer,
1108                                          ISC_XMLCHAR "name",
1109                                          ISC_XMLCHAR
1110                                          dns_cache_getname(view->cache)));
1111                         dumparg.result = ISC_R_SUCCESS;
1112                         dns_rdatasetstats_dump(cacherrstats, rdatasetstats_dump,
1113                                                &dumparg, 0);
1114                         if (dumparg.result != ISC_R_SUCCESS)
1115                                 goto error;
1116                         TRY0(xmlTextWriterEndElement(writer)); /* cache */
1117                 }
1118
1119                 TRY0(xmlTextWriterEndElement(writer)); /* view */
1120
1121                 view = ISC_LIST_NEXT(view, link);
1122         }
1123         TRY0(xmlTextWriterEndElement(writer)); /* views */
1124
1125         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "socketmgr"));
1126         isc_socketmgr_renderxml(ns_g_socketmgr, writer);
1127         TRY0(xmlTextWriterEndElement(writer)); /* socketmgr */
1128
1129         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "taskmgr"));
1130         isc_taskmgr_renderxml(ns_g_taskmgr, writer);
1131         TRY0(xmlTextWriterEndElement(writer)); /* taskmgr */
1132
1133         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "server"));
1134         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "boot-time"));
1135         TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR boottime));
1136         TRY0(xmlTextWriterEndElement(writer)); /* boot-time */
1137         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "current-time"));
1138         TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR nowstr));
1139         TRY0(xmlTextWriterEndElement(writer));  /* current-time */
1140
1141         dumparg.result = ISC_R_SUCCESS;
1142
1143         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
1144         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
1145                                          ISC_XMLCHAR "opcode"));
1146
1147         dns_opcodestats_dump(server->opcodestats, opcodestat_dump, &dumparg,
1148                              0);
1149         if (dumparg.result != ISC_R_SUCCESS)
1150                 goto error;
1151
1152         TRY0(xmlTextWriterEndElement(writer)); /* counters type=opcode */
1153
1154         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
1155         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
1156                                          ISC_XMLCHAR "qtype"));
1157
1158         dumparg.result = ISC_R_SUCCESS;
1159         dns_rdatatypestats_dump(server->rcvquerystats, rdtypestat_dump,
1160                                 &dumparg, 0);
1161         if (dumparg.result != ISC_R_SUCCESS)
1162                 goto error;
1163         TRY0(xmlTextWriterEndElement(writer)); /* counters */
1164
1165         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
1166         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
1167                                          ISC_XMLCHAR "nsstat"));
1168
1169         result = dump_counters(server->nsstats, statsformat_xml,
1170                                writer, NULL, nsstats_xmldesc,
1171                                dns_nsstatscounter_max,
1172                                nsstats_index, nsstat_values,
1173                                ISC_STATSDUMP_VERBOSE);
1174         if (result != ISC_R_SUCCESS)
1175                 goto error;
1176
1177         TRY0(xmlTextWriterEndElement(writer)); /* counters type=nsstat */
1178
1179         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
1180         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
1181                                          ISC_XMLCHAR "zonestat"));
1182
1183         result = dump_counters(server->zonestats, statsformat_xml, writer,
1184                                NULL, zonestats_xmldesc,
1185                                dns_zonestatscounter_max, zonestats_index,
1186                                zonestat_values, ISC_STATSDUMP_VERBOSE);
1187         if (result != ISC_R_SUCCESS)
1188                 goto error;
1189
1190         TRY0(xmlTextWriterEndElement(writer)); /* counters type=zonestat */
1191
1192         /*
1193          * Most of the common resolver statistics entries are 0, so we don't
1194          * use the verbose dump here.
1195          */
1196
1197         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
1198         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
1199                                          ISC_XMLCHAR "resstat"));
1200         result = dump_counters(server->resolverstats, statsformat_xml,
1201                                writer, NULL, resstats_xmldesc,
1202                                dns_resstatscounter_max, resstats_index,
1203                                resstat_values, 0);
1204         if (result != ISC_R_SUCCESS)
1205                 goto error;
1206
1207         TRY0(xmlTextWriterEndElement(writer)); /* counters type=resstat */
1208
1209         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counters"));
1210         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "type",
1211                                          ISC_XMLCHAR "sockstat"));
1212
1213         result = dump_counters(server->sockstats, statsformat_xml,
1214                                writer, NULL, sockstats_xmldesc,
1215                                isc_sockstatscounter_max, sockstats_index,
1216                                sockstat_values, ISC_STATSDUMP_VERBOSE);
1217         if (result != ISC_R_SUCCESS)
1218                 goto error;
1219
1220         TRY0(xmlTextWriterEndElement(writer)); /* counters type=sockstat */
1221
1222         TRY0(xmlTextWriterEndElement(writer)); /* server */
1223
1224         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "memory"));
1225         isc_mem_renderxml(writer);
1226         TRY0(xmlTextWriterEndElement(writer)); /* memory */
1227
1228         TRY0(xmlTextWriterEndElement(writer)); /* statistics */
1229
1230         TRY0(xmlTextWriterEndDocument(writer));
1231
1232         xmlFreeTextWriter(writer);
1233
1234         xmlDocDumpFormatMemoryEnc(doc, buf, buflen, "UTF-8", 0);
1235         xmlFreeDoc(doc);
1236         return (ISC_R_SUCCESS);
1237
1238  error:
1239         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_SERVER,
1240                       ISC_LOG_ERROR, "failed generating XML response");
1241         if (writer != NULL)
1242                 xmlFreeTextWriter(writer);
1243         if (doc != NULL)
1244                 xmlFreeDoc(doc);
1245         return (ISC_R_FAILURE);
1246 }
1247 #else /* OLDSTATS */
1248 static isc_result_t
1249 generatexml(ns_server_t *server, int *buflen, xmlChar **buf) {
1250         char boottime[sizeof "yyyy-mm-ddThh:mm:ssZ"];
1251         char nowstr[sizeof "yyyy-mm-ddThh:mm:ssZ"];
1252         isc_time_t now;
1253         xmlTextWriterPtr writer = NULL;
1254         xmlDocPtr doc = NULL;
1255         int xmlrc;
1256         dns_view_t *view;
1257         stats_dumparg_t dumparg;
1258         dns_stats_t *cachestats;
1259         isc_uint64_t nsstat_values[dns_nsstatscounter_max];
1260         isc_uint64_t resstat_values[dns_resstatscounter_max];
1261         isc_uint64_t zonestat_values[dns_zonestatscounter_max];
1262         isc_uint64_t sockstat_values[isc_sockstatscounter_max];
1263         isc_result_t result;
1264
1265         isc_time_now(&now);
1266         isc_time_formatISO8601(&ns_g_boottime, boottime, sizeof boottime);
1267         isc_time_formatISO8601(&now, nowstr, sizeof nowstr);
1268
1269         writer = xmlNewTextWriterDoc(&doc, 0);
1270         if (writer == NULL)
1271                 goto error;
1272         TRY0(xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL));
1273         TRY0(xmlTextWriterWritePI(writer, ISC_XMLCHAR "xml-stylesheet",
1274                         ISC_XMLCHAR "type=\"text/xsl\" href=\"/bind9.xsl\""));
1275         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "isc"));
1276         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "version",
1277                                          ISC_XMLCHAR "1.0"));
1278
1279         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "bind"));
1280         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "statistics"));
1281         TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "version",
1282                                          ISC_XMLCHAR "2.2"));
1283
1284         /* Set common fields for statistics dump */
1285         dumparg.type = statsformat_xml;
1286         dumparg.arg = writer;
1287
1288         /*
1289          * Start by rendering the views we know of here.  For each view we
1290          * know of, call its rendering function.
1291          */
1292         view = ISC_LIST_HEAD(server->viewlist);
1293         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "views"));
1294         while (view != NULL) {
1295                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "view"));
1296
1297                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "name"));
1298                 TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR view->name));
1299                 TRY0(xmlTextWriterEndElement(writer));
1300
1301                 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "zones"));
1302                 result = dns_zt_apply(view->zonetable, ISC_TRUE, zone_xmlrender,
1303                                       writer);
1304                 if (result != ISC_R_SUCCESS)
1305                         goto error;
1306                 TRY0(xmlTextWriterEndElement(writer));
1307
1308                 if (view->resquerystats != NULL) {
1309                         dumparg.result = ISC_R_SUCCESS;
1310                         dns_rdatatypestats_dump(view->resquerystats,
1311                                                 rdtypestat_dump, &dumparg, 0);
1312                         if (dumparg.result != ISC_R_SUCCESS)
1313                                 goto error;
1314                 }
1315
1316                 if (view->resstats != NULL) {
1317                         result = dump_counters(view->resstats, statsformat_xml,
1318                                                writer, "resstat",
1319                                                resstats_xmldesc,
1320                                                dns_resstatscounter_max,
1321                                                resstats_index, resstat_values,
1322                                                ISC_STATSDUMP_VERBOSE);
1323                         if (result != ISC_R_SUCCESS)
1324                                 goto error;
1325                 }
1326
1327                 cachestats = dns_db_getrrsetstats(view->cachedb);
1328                 if (cachestats != NULL) {
1329                         TRY0(xmlTextWriterStartElement(writer,
1330                                                        ISC_XMLCHAR "cache"));
1331                         TRY0(xmlTextWriterWriteAttribute(writer,
1332                                          ISC_XMLCHAR "name",
1333                                          ISC_XMLCHAR
1334                                          dns_cache_getname(view->cache)));
1335                         dumparg.result = ISC_R_SUCCESS;
1336                         dns_rdatasetstats_dump(cachestats, rdatasetstats_dump,
1337                                                &dumparg, 0);
1338                         if (dumparg.result != ISC_R_SUCCESS)
1339                                 goto error;
1340                         TRY0(xmlTextWriterEndElement(writer)); /* cache */
1341                 }
1342
1343                 TRY0(xmlTextWriterEndElement(writer)); /* view */
1344
1345                 view = ISC_LIST_NEXT(view, link);
1346         }
1347         TRY0(xmlTextWriterEndElement(writer)); /* views */
1348
1349         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "socketmgr"));
1350         TRY0(isc_socketmgr_renderxml(ns_g_socketmgr, writer));
1351         TRY0(xmlTextWriterEndElement(writer)); /* socketmgr */
1352
1353         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "taskmgr"));
1354         TRY0(isc_taskmgr_renderxml(ns_g_taskmgr, writer));
1355         TRY0(xmlTextWriterEndElement(writer)); /* taskmgr */
1356
1357         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "server"));
1358         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "boot-time"));
1359         TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR boottime));
1360         TRY0(xmlTextWriterEndElement(writer));
1361         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "current-time"));
1362         TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR nowstr));
1363         TRY0(xmlTextWriterEndElement(writer));
1364
1365         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "requests"));
1366         dumparg.result = ISC_R_SUCCESS;
1367         dns_opcodestats_dump(server->opcodestats, opcodestat_dump, &dumparg,
1368                              0);
1369         if (dumparg.result != ISC_R_SUCCESS)
1370                 goto error;
1371         TRY0(xmlTextWriterEndElement(writer)); /* requests */
1372
1373         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "queries-in"));
1374         dumparg.result = ISC_R_SUCCESS;
1375         dns_rdatatypestats_dump(server->rcvquerystats, rdtypestat_dump,
1376                                 &dumparg, 0);
1377         if (dumparg.result != ISC_R_SUCCESS)
1378                 goto error;
1379         TRY0(xmlTextWriterEndElement(writer)); /* queries-in */
1380
1381         result = dump_counters(server->nsstats, statsformat_xml, writer,
1382                                "nsstat", nsstats_xmldesc,
1383                                 dns_nsstatscounter_max,
1384                                 nsstats_index, nsstat_values,
1385                                 ISC_STATSDUMP_VERBOSE);
1386         if (result != ISC_R_SUCCESS)
1387                 goto error;
1388
1389         result = dump_counters(server->zonestats, statsformat_xml, writer,
1390                                "zonestat", zonestats_xmldesc,
1391                                dns_zonestatscounter_max, zonestats_index,
1392                                zonestat_values, ISC_STATSDUMP_VERBOSE);
1393         if (result != ISC_R_SUCCESS)
1394                 goto error;
1395
1396         /*
1397          * Most of the common resolver statistics entries are 0, so we don't
1398          * use the verbose dump here.
1399          */
1400         result = dump_counters(server->resolverstats, statsformat_xml, writer,
1401                                "resstat", resstats_xmldesc,
1402                                dns_resstatscounter_max, resstats_index,
1403                                resstat_values, 0);
1404         if (result != ISC_R_SUCCESS)
1405                 goto error;
1406
1407         result = dump_counters(server->sockstats, statsformat_xml, writer,
1408                                "sockstat", sockstats_xmldesc,
1409                                isc_sockstatscounter_max, sockstats_index,
1410                                sockstat_values, ISC_STATSDUMP_VERBOSE);
1411         if (result != ISC_R_SUCCESS)
1412                 goto error;
1413
1414         TRY0(xmlTextWriterEndElement(writer)); /* server */
1415
1416         TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "memory"));
1417         TRY0(isc_mem_renderxml(writer));
1418         TRY0(xmlTextWriterEndElement(writer)); /* memory */
1419
1420         TRY0(xmlTextWriterEndElement(writer)); /* statistics */
1421         TRY0(xmlTextWriterEndElement(writer)); /* bind */
1422         TRY0(xmlTextWriterEndElement(writer)); /* isc */
1423
1424         TRY0(xmlTextWriterEndDocument(writer));
1425
1426         xmlFreeTextWriter(writer);
1427
1428         xmlDocDumpFormatMemoryEnc(doc, buf, buflen, "UTF-8", 1);
1429         xmlFreeDoc(doc);
1430         return (ISC_R_SUCCESS);
1431
1432  error:
1433         if (writer != NULL)
1434                 xmlFreeTextWriter(writer);
1435         if (doc != NULL)
1436                 xmlFreeDoc(doc);
1437         return (ISC_R_FAILURE);
1438 }
1439 #endif /* NEWSTATS */
1440
1441 static void
1442 wrap_xmlfree(isc_buffer_t *buffer, void *arg) {
1443         UNUSED(arg);
1444
1445         xmlFree(isc_buffer_base(buffer));
1446 }
1447
1448 static isc_result_t
1449 render_index(const char *url, const char *querystring, void *arg,
1450              unsigned int *retcode, const char **retmsg, const char **mimetype,
1451              isc_buffer_t *b, isc_httpdfree_t **freecb,
1452              void **freecb_args)
1453 {
1454         unsigned char *msg;
1455         int msglen;
1456         ns_server_t *server = arg;
1457         isc_result_t result;
1458
1459         UNUSED(url);
1460         UNUSED(querystring);
1461
1462         result = generatexml(server, &msglen, &msg);
1463
1464         if (result == ISC_R_SUCCESS) {
1465                 *retcode = 200;
1466                 *retmsg = "OK";
1467                 *mimetype = "text/xml";
1468                 isc_buffer_reinit(b, msg, msglen);
1469                 isc_buffer_add(b, msglen);
1470                 *freecb = wrap_xmlfree;
1471                 *freecb_args = NULL;
1472         } else
1473                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
1474                               NS_LOGMODULE_SERVER, ISC_LOG_ERROR,
1475                               "failed at rendering XML()");
1476
1477         return (result);
1478 }
1479
1480 #endif  /* HAVE_LIBXML2 */
1481
1482 static isc_result_t
1483 render_xsl(const char *url, const char *querystring, void *args,
1484            unsigned int *retcode, const char **retmsg, const char **mimetype,
1485            isc_buffer_t *b, isc_httpdfree_t **freecb,
1486            void **freecb_args)
1487 {
1488         UNUSED(url);
1489         UNUSED(querystring);
1490         UNUSED(args);
1491
1492         *retcode = 200;
1493         *retmsg = "OK";
1494         *mimetype = "text/xslt+xml";
1495         isc_buffer_reinit(b, xslmsg, strlen(xslmsg));
1496         isc_buffer_add(b, strlen(xslmsg));
1497         *freecb = NULL;
1498         *freecb_args = NULL;
1499
1500         return (ISC_R_SUCCESS);
1501 }
1502
1503 static void
1504 shutdown_listener(ns_statschannel_t *listener) {
1505         char socktext[ISC_SOCKADDR_FORMATSIZE];
1506         isc_sockaddr_format(&listener->address, socktext, sizeof(socktext));
1507         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_SERVER,
1508                       ISC_LOG_NOTICE, "stopping statistics channel on %s",
1509                       socktext);
1510
1511         isc_httpdmgr_shutdown(&listener->httpdmgr);
1512 }
1513
1514 static isc_boolean_t
1515 client_ok(const isc_sockaddr_t *fromaddr, void *arg) {
1516         ns_statschannel_t *listener = arg;
1517         isc_netaddr_t netaddr;
1518         char socktext[ISC_SOCKADDR_FORMATSIZE];
1519         int match;
1520
1521         REQUIRE(listener != NULL);
1522
1523         isc_netaddr_fromsockaddr(&netaddr, fromaddr);
1524
1525         LOCK(&listener->lock);
1526         if (dns_acl_match(&netaddr, NULL, listener->acl, &ns_g_server->aclenv,
1527                           &match, NULL) == ISC_R_SUCCESS && match > 0) {
1528                 UNLOCK(&listener->lock);
1529                 return (ISC_TRUE);
1530         }
1531         UNLOCK(&listener->lock);
1532
1533         isc_sockaddr_format(fromaddr, socktext, sizeof(socktext));
1534         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
1535                       NS_LOGMODULE_SERVER, ISC_LOG_WARNING,
1536                       "rejected statistics connection from %s", socktext);
1537
1538         return (ISC_FALSE);
1539 }
1540
1541 static void
1542 destroy_listener(void *arg) {
1543         ns_statschannel_t *listener = arg;
1544
1545         REQUIRE(listener != NULL);
1546         REQUIRE(!ISC_LINK_LINKED(listener, link));
1547
1548         /* We don't have to acquire the lock here since it's already unlinked */
1549         dns_acl_detach(&listener->acl);
1550
1551         DESTROYLOCK(&listener->lock);
1552         isc_mem_putanddetach(&listener->mctx, listener, sizeof(*listener));
1553 }
1554
1555 static isc_result_t
1556 add_listener(ns_server_t *server, ns_statschannel_t **listenerp,
1557              const cfg_obj_t *listen_params, const cfg_obj_t *config,
1558              isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
1559              const char *socktext)
1560 {
1561         isc_result_t result;
1562         ns_statschannel_t *listener;
1563         isc_task_t *task = NULL;
1564         isc_socket_t *sock = NULL;
1565         const cfg_obj_t *allow;
1566         dns_acl_t *new_acl = NULL;
1567
1568         listener = isc_mem_get(server->mctx, sizeof(*listener));
1569         if (listener == NULL)
1570                 return (ISC_R_NOMEMORY);
1571
1572         listener->httpdmgr = NULL;
1573         listener->address = *addr;
1574         listener->acl = NULL;
1575         listener->mctx = NULL;
1576         ISC_LINK_INIT(listener, link);
1577
1578         result = isc_mutex_init(&listener->lock);
1579         if (result != ISC_R_SUCCESS) {
1580                 isc_mem_put(server->mctx, listener, sizeof(*listener));
1581                 return (ISC_R_FAILURE);
1582         }
1583
1584         isc_mem_attach(server->mctx, &listener->mctx);
1585
1586         allow = cfg_tuple_get(listen_params, "allow");
1587         if (allow != NULL && cfg_obj_islist(allow)) {
1588                 result = cfg_acl_fromconfig(allow, config, ns_g_lctx,
1589                                             aclconfctx, listener->mctx, 0,
1590                                             &new_acl);
1591         } else
1592                 result = dns_acl_any(listener->mctx, &new_acl);
1593         if (result != ISC_R_SUCCESS)
1594                 goto cleanup;
1595         dns_acl_attach(new_acl, &listener->acl);
1596         dns_acl_detach(&new_acl);
1597
1598         result = isc_task_create(ns_g_taskmgr, 0, &task);
1599         if (result != ISC_R_SUCCESS)
1600                 goto cleanup;
1601         isc_task_setname(task, "statchannel", NULL);
1602
1603         result = isc_socket_create(ns_g_socketmgr, isc_sockaddr_pf(addr),
1604                                    isc_sockettype_tcp, &sock);
1605         if (result != ISC_R_SUCCESS)
1606                 goto cleanup;
1607         isc_socket_setname(sock, "statchannel", NULL);
1608
1609 #ifndef ISC_ALLOW_MAPPED
1610         isc_socket_ipv6only(sock, ISC_TRUE);
1611 #endif
1612
1613         result = isc_socket_bind(sock, addr, ISC_SOCKET_REUSEADDRESS);
1614         if (result != ISC_R_SUCCESS)
1615                 goto cleanup;
1616
1617         result = isc_httpdmgr_create(server->mctx, sock, task, client_ok,
1618                                      destroy_listener, listener, ns_g_timermgr,
1619                                      &listener->httpdmgr);
1620         if (result != ISC_R_SUCCESS)
1621                 goto cleanup;
1622
1623 #ifdef HAVE_LIBXML2
1624         isc_httpdmgr_addurl(listener->httpdmgr, "/", render_index, server);
1625         isc_httpdmgr_addurl(listener->httpdmgr, "/xml", render_index, server);
1626 #ifdef NEWSTATS
1627         isc_httpdmgr_addurl(listener->httpdmgr, "/xml/v3", render_index,
1628                             server);
1629 #else /* OLDSTATS */
1630         isc_httpdmgr_addurl(listener->httpdmgr, "/xml/v2", render_index,
1631                             server);
1632 #endif /* NEWSTATS */
1633 #endif
1634 #ifdef NEWSTATS
1635         isc_httpdmgr_addurl(listener->httpdmgr, "/bind9.ver3.xsl", render_xsl,
1636                             server);
1637 #else /* OLDSTATS */
1638         isc_httpdmgr_addurl(listener->httpdmgr, "/bind9.xsl", render_xsl,
1639                             server);
1640 #endif /* NEWSTATS */
1641         *listenerp = listener;
1642         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
1643                       NS_LOGMODULE_SERVER, ISC_LOG_NOTICE,
1644                       "statistics channel listening on %s", socktext);
1645
1646 cleanup:
1647         if (result != ISC_R_SUCCESS) {
1648                 if (listener->acl != NULL)
1649                         dns_acl_detach(&listener->acl);
1650                 DESTROYLOCK(&listener->lock);
1651                 isc_mem_putanddetach(&listener->mctx, listener,
1652                                      sizeof(*listener));
1653         }
1654         if (task != NULL)
1655                 isc_task_detach(&task);
1656         if (sock != NULL)
1657                 isc_socket_detach(&sock);
1658
1659         return (result);
1660 }
1661
1662 static void
1663 update_listener(ns_server_t *server, ns_statschannel_t **listenerp,
1664                 const cfg_obj_t *listen_params, const cfg_obj_t *config,
1665                 isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
1666                 const char *socktext)
1667 {
1668         ns_statschannel_t *listener;
1669         const cfg_obj_t *allow = NULL;
1670         dns_acl_t *new_acl = NULL;
1671         isc_result_t result = ISC_R_SUCCESS;
1672
1673         for (listener = ISC_LIST_HEAD(server->statschannels);
1674              listener != NULL;
1675              listener = ISC_LIST_NEXT(listener, link))
1676                 if (isc_sockaddr_equal(addr, &listener->address))
1677                         break;
1678
1679         if (listener == NULL) {
1680                 *listenerp = NULL;
1681                 return;
1682         }
1683
1684         /*
1685          * Now, keep the old access list unless a new one can be made.
1686          */
1687         allow = cfg_tuple_get(listen_params, "allow");
1688         if (allow != NULL && cfg_obj_islist(allow)) {
1689                 result = cfg_acl_fromconfig(allow, config, ns_g_lctx,
1690                                             aclconfctx, listener->mctx, 0,
1691                                             &new_acl);
1692         } else
1693                 result = dns_acl_any(listener->mctx, &new_acl);
1694
1695         if (result == ISC_R_SUCCESS) {
1696                 LOCK(&listener->lock);
1697
1698                 dns_acl_detach(&listener->acl);
1699                 dns_acl_attach(new_acl, &listener->acl);
1700                 dns_acl_detach(&new_acl);
1701
1702                 UNLOCK(&listener->lock);
1703         } else {
1704                 cfg_obj_log(listen_params, ns_g_lctx, ISC_LOG_WARNING,
1705                             "couldn't install new acl for "
1706                             "statistics channel %s: %s",
1707                             socktext, isc_result_totext(result));
1708         }
1709
1710         *listenerp = listener;
1711 }
1712
1713 isc_result_t
1714 ns_statschannels_configure(ns_server_t *server, const cfg_obj_t *config,
1715                          cfg_aclconfctx_t *aclconfctx)
1716 {
1717         ns_statschannel_t *listener, *listener_next;
1718         ns_statschannellist_t new_listeners;
1719         const cfg_obj_t *statschannellist = NULL;
1720         const cfg_listelt_t *element, *element2;
1721         char socktext[ISC_SOCKADDR_FORMATSIZE];
1722
1723         RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS);
1724
1725         ISC_LIST_INIT(new_listeners);
1726
1727         /*
1728          * Get the list of named.conf 'statistics-channels' statements.
1729          */
1730         (void)cfg_map_get(config, "statistics-channels", &statschannellist);
1731
1732         /*
1733          * Run through the new address/port list, noting sockets that are
1734          * already being listened on and moving them to the new list.
1735          *
1736          * Identifying duplicate addr/port combinations is left to either
1737          * the underlying config code, or to the bind attempt getting an
1738          * address-in-use error.
1739          */
1740         if (statschannellist != NULL) {
1741 #ifndef HAVE_LIBXML2
1742                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
1743                               NS_LOGMODULE_SERVER, ISC_LOG_WARNING,
1744                               "statistics-channels specified but not effective "
1745                               "due to missing XML library");
1746 #endif
1747
1748                 for (element = cfg_list_first(statschannellist);
1749                      element != NULL;
1750                      element = cfg_list_next(element)) {
1751                         const cfg_obj_t *statschannel;
1752                         const cfg_obj_t *listenercfg = NULL;
1753
1754                         statschannel = cfg_listelt_value(element);
1755                         (void)cfg_map_get(statschannel, "inet",
1756                                           &listenercfg);
1757                         if (listenercfg == NULL)
1758                                 continue;
1759
1760                         for (element2 = cfg_list_first(listenercfg);
1761                              element2 != NULL;
1762                              element2 = cfg_list_next(element2)) {
1763                                 const cfg_obj_t *listen_params;
1764                                 const cfg_obj_t *obj;
1765                                 isc_sockaddr_t addr;
1766
1767                                 listen_params = cfg_listelt_value(element2);
1768
1769                                 obj = cfg_tuple_get(listen_params, "address");
1770                                 addr = *cfg_obj_assockaddr(obj);
1771                                 if (isc_sockaddr_getport(&addr) == 0)
1772                                         isc_sockaddr_setport(&addr,
1773                                                      NS_STATSCHANNEL_HTTPPORT);
1774
1775                                 isc_sockaddr_format(&addr, socktext,
1776                                                     sizeof(socktext));
1777
1778                                 isc_log_write(ns_g_lctx,
1779                                               NS_LOGCATEGORY_GENERAL,
1780                                               NS_LOGMODULE_SERVER,
1781                                               ISC_LOG_DEBUG(9),
1782                                               "processing statistics "
1783                                               "channel %s",
1784                                               socktext);
1785
1786                                 update_listener(server, &listener,
1787                                                 listen_params, config, &addr,
1788                                                 aclconfctx, socktext);
1789
1790                                 if (listener != NULL) {
1791                                         /*
1792                                          * Remove the listener from the old
1793                                          * list, so it won't be shut down.
1794                                          */
1795                                         ISC_LIST_UNLINK(server->statschannels,
1796                                                         listener, link);
1797                                 } else {
1798                                         /*
1799                                          * This is a new listener.
1800                                          */
1801                                         isc_result_t r;
1802
1803                                         r = add_listener(server, &listener,
1804                                                          listen_params, config,
1805                                                          &addr, aclconfctx,
1806                                                          socktext);
1807                                         if (r != ISC_R_SUCCESS) {
1808                                                 cfg_obj_log(listen_params,
1809                                                             ns_g_lctx,
1810                                                             ISC_LOG_WARNING,
1811                                                             "couldn't allocate "
1812                                                             "statistics channel"
1813                                                             " %s: %s",
1814                                                             socktext,
1815                                                             isc_result_totext(r));
1816                                         }
1817                                 }
1818
1819                                 if (listener != NULL)
1820                                         ISC_LIST_APPEND(new_listeners, listener,
1821                                                         link);
1822                         }
1823                 }
1824         }
1825
1826         for (listener = ISC_LIST_HEAD(server->statschannels);
1827              listener != NULL;
1828              listener = listener_next) {
1829                 listener_next = ISC_LIST_NEXT(listener, link);
1830                 ISC_LIST_UNLINK(server->statschannels, listener, link);
1831                 shutdown_listener(listener);
1832         }
1833
1834         ISC_LIST_APPENDLIST(server->statschannels, new_listeners, link);
1835         return (ISC_R_SUCCESS);
1836 }
1837
1838 void
1839 ns_statschannels_shutdown(ns_server_t *server) {
1840         ns_statschannel_t *listener;
1841
1842         while ((listener = ISC_LIST_HEAD(server->statschannels)) != NULL) {
1843                 ISC_LIST_UNLINK(server->statschannels, listener, link);
1844                 shutdown_listener(listener);
1845         }
1846 }
1847
1848 isc_result_t
1849 ns_stats_dump(ns_server_t *server, FILE *fp) {
1850         isc_stdtime_t now;
1851         isc_result_t result;
1852         dns_view_t *view;
1853         dns_zone_t *zone, *next;
1854         stats_dumparg_t dumparg;
1855         isc_uint64_t nsstat_values[dns_nsstatscounter_max];
1856         isc_uint64_t resstat_values[dns_resstatscounter_max];
1857         isc_uint64_t zonestat_values[dns_zonestatscounter_max];
1858         isc_uint64_t sockstat_values[isc_sockstatscounter_max];
1859
1860         RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS);
1861
1862         /* Set common fields */
1863         dumparg.type = statsformat_file;
1864         dumparg.arg = fp;
1865
1866         isc_stdtime_get(&now);
1867         fprintf(fp, "+++ Statistics Dump +++ (%lu)\n", (unsigned long)now);
1868
1869         fprintf(fp, "++ Incoming Requests ++\n");
1870         dns_opcodestats_dump(server->opcodestats, opcodestat_dump, &dumparg, 0);
1871
1872         fprintf(fp, "++ Incoming Queries ++\n");
1873         dns_rdatatypestats_dump(server->rcvquerystats, rdtypestat_dump,
1874                                 &dumparg, 0);
1875
1876         fprintf(fp, "++ Outgoing Queries ++\n");
1877         for (view = ISC_LIST_HEAD(server->viewlist);
1878              view != NULL;
1879              view = ISC_LIST_NEXT(view, link)) {
1880                 if (view->resquerystats == NULL)
1881                         continue;
1882                 if (strcmp(view->name, "_default") == 0)
1883                         fprintf(fp, "[View: default]\n");
1884                 else
1885                         fprintf(fp, "[View: %s]\n", view->name);
1886                 dns_rdatatypestats_dump(view->resquerystats, rdtypestat_dump,
1887                                         &dumparg, 0);
1888         }
1889
1890         fprintf(fp, "++ Name Server Statistics ++\n");
1891         (void) dump_counters(server->nsstats, statsformat_file, fp, NULL,
1892                              nsstats_desc, dns_nsstatscounter_max,
1893                              nsstats_index, nsstat_values, 0);
1894
1895         fprintf(fp, "++ Zone Maintenance Statistics ++\n");
1896         (void) dump_counters(server->zonestats, statsformat_file, fp, NULL,
1897                              zonestats_desc, dns_zonestatscounter_max,
1898                              zonestats_index, zonestat_values, 0);
1899
1900         fprintf(fp, "++ Resolver Statistics ++\n");
1901         fprintf(fp, "[Common]\n");
1902         (void) dump_counters(server->resolverstats, statsformat_file, fp, NULL,
1903                              resstats_desc, dns_resstatscounter_max,
1904                              resstats_index, resstat_values, 0);
1905         for (view = ISC_LIST_HEAD(server->viewlist);
1906              view != NULL;
1907              view = ISC_LIST_NEXT(view, link)) {
1908                 if (view->resstats == NULL)
1909                         continue;
1910                 if (strcmp(view->name, "_default") == 0)
1911                         fprintf(fp, "[View: default]\n");
1912                 else
1913                         fprintf(fp, "[View: %s]\n", view->name);
1914                 (void) dump_counters(view->resstats, statsformat_file, fp, NULL,
1915                                      resstats_desc, dns_resstatscounter_max,
1916                                      resstats_index, resstat_values, 0);
1917         }
1918
1919         fprintf(fp, "++ Cache DB RRsets ++\n");
1920         for (view = ISC_LIST_HEAD(server->viewlist);
1921              view != NULL;
1922              view = ISC_LIST_NEXT(view, link)) {
1923                 dns_stats_t *cachestats;
1924
1925                 cachestats = dns_db_getrrsetstats(view->cachedb);
1926                 if (cachestats == NULL)
1927                         continue;
1928                 if (strcmp(view->name, "_default") == 0)
1929                         fprintf(fp, "[View: default]\n");
1930                 else
1931                         fprintf(fp, "[View: %s (Cache: %s)]\n", view->name,
1932                                 dns_cache_getname(view->cache));
1933                 if (dns_view_iscacheshared(view)) {
1934                         /*
1935                          * Avoid dumping redundant statistics when the cache is
1936                          * shared.
1937                          */
1938                         continue;
1939                 }
1940                 dns_rdatasetstats_dump(cachestats, rdatasetstats_dump, &dumparg,
1941                                        0);
1942         }
1943
1944         fprintf(fp, "++ Socket I/O Statistics ++\n");
1945         (void) dump_counters(server->sockstats, statsformat_file, fp, NULL,
1946                              sockstats_desc, isc_sockstatscounter_max,
1947                              sockstats_index, sockstat_values, 0);
1948
1949         fprintf(fp, "++ Per Zone Query Statistics ++\n");
1950         zone = NULL;
1951         for (result = dns_zone_first(server->zonemgr, &zone);
1952              result == ISC_R_SUCCESS;
1953              next = NULL, result = dns_zone_next(zone, &next), zone = next)
1954         {
1955                 isc_stats_t *zonestats = dns_zone_getrequeststats(zone);
1956                 if (zonestats != NULL) {
1957                         char zonename[DNS_NAME_FORMATSIZE];
1958
1959                         dns_name_format(dns_zone_getorigin(zone),
1960                                         zonename, sizeof(zonename));
1961                         view = dns_zone_getview(zone);
1962
1963                         fprintf(fp, "[%s", zonename);
1964                         if (strcmp(view->name, "_default") != 0)
1965                                 fprintf(fp, " (view: %s)", view->name);
1966                         fprintf(fp, "]\n");
1967
1968                         (void) dump_counters(zonestats, statsformat_file, fp,
1969                                              NULL, nsstats_desc,
1970                                              dns_nsstatscounter_max,
1971                                              nsstats_index, nsstat_values, 0);
1972                 }
1973         }
1974
1975         fprintf(fp, "--- Statistics Dump --- (%lu)\n", (unsigned long)now);
1976
1977         return (ISC_R_SUCCESS); /* this function currently always succeeds */
1978 }