Adding upstream version 1.7.3.upstream/1.7.3upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 614 insertions, 0 deletions

diff --git a/dnsdist-snmp.cc b/dnsdist-snmp.cc
new file mode 100644
index 0000000..4da43ee
--- /dev/null
+++ b/dnsdist-snmp.cc
@@ -0,0 +1,614 @@
+
+#include "dnsdist-snmp.hh"
+#include "dolog.hh"
+
+bool g_snmpEnabled{false};
+bool g_snmpTrapsEnabled{false};
+DNSDistSNMPAgent* g_snmpAgent{nullptr};
+
+#ifdef HAVE_NET_SNMP
+
+#define DNSDIST_OID 1, 3, 6, 1, 4, 1, 43315, 3
+#define DNSDIST_STATS_OID DNSDIST_OID, 1
+#define DNSDIST_STATS_TABLE_OID DNSDIST_OID, 2
+#define DNSDIST_TRAPS_OID DNSDIST_OID, 10, 0
+#define DNSDIST_TRAP_OBJECTS_OID DNSDIST_OID, 11
+
+static const oid queriesOID[] = { DNSDIST_STATS_OID, 1 };
+static const oid responsesOID[] = { DNSDIST_STATS_OID, 2 };
+static const oid servfailResponsesOID[] = { DNSDIST_STATS_OID, 3 };
+static const oid aclDropsOID[] = { DNSDIST_STATS_OID, 4 };
+// 5 was BlockFilter, removed in 1.2.0
+static const oid ruleDropOID[] = { DNSDIST_STATS_OID, 6 };
+static const oid ruleNXDomainOID[] = { DNSDIST_STATS_OID, 7 };
+static const oid ruleRefusedOID[] = { DNSDIST_STATS_OID, 8 };
+static const oid selfAnsweredOID[] = { DNSDIST_STATS_OID, 9 };
+static const oid downstreamTimeoutsOID[] = { DNSDIST_STATS_OID, 10 };
+static const oid downstreamSendErrorsOID[] = { DNSDIST_STATS_OID, 11 };
+static const oid truncFailOID[] = { DNSDIST_STATS_OID, 12 };
+static const oid noPolicyOID[] = { DNSDIST_STATS_OID, 13 };
+static const oid latency0_1OID[] = { DNSDIST_STATS_OID, 14 };
+static const oid latency1_10OID[] = { DNSDIST_STATS_OID, 15 };
+static const oid latency10_50OID[] = { DNSDIST_STATS_OID, 16 };
+static const oid latency50_100OID[] = { DNSDIST_STATS_OID, 17 };
+static const oid latency100_1000OID[] = { DNSDIST_STATS_OID, 18 };
+static const oid latencySlowOID[] = { DNSDIST_STATS_OID, 19 };
+static const oid latencyAvg100OID[] = { DNSDIST_STATS_OID, 20 };
+static const oid latencyAvg1000OID[] = { DNSDIST_STATS_OID, 21 };
+static const oid latencyAvg10000OID[] = { DNSDIST_STATS_OID, 22 };
+static const oid latencyAvg1000000OID[] = { DNSDIST_STATS_OID, 23 };
+static const oid uptimeOID[] = { DNSDIST_STATS_OID, 24 };
+static const oid realMemoryUsageOID[] = { DNSDIST_STATS_OID, 25 };
+static const oid nonCompliantQueriesOID[] = { DNSDIST_STATS_OID, 26 };
+static const oid nonCompliantResponsesOID[] = { DNSDIST_STATS_OID, 27 };
+static const oid rdQueriesOID[] = { DNSDIST_STATS_OID, 28 };
+static const oid emptyQueriesOID[] = { DNSDIST_STATS_OID, 29 };
+static const oid cacheHitsOID[] = { DNSDIST_STATS_OID, 30 };
+static const oid cacheMissesOID[] = { DNSDIST_STATS_OID, 31 };
+static const oid cpuUserMSecOID[] = { DNSDIST_STATS_OID, 32 };
+static const oid cpuSysMSecOID[] = { DNSDIST_STATS_OID, 33 };
+static const oid fdUsageOID[] = { DNSDIST_STATS_OID, 34 };
+static const oid dynBlockedOID[] = { DNSDIST_STATS_OID, 35 };
+static const oid dynBlockedNMGSizeOID[] = { DNSDIST_STATS_OID, 36 };
+static const oid ruleServFailOID[] = { DNSDIST_STATS_OID, 37 };
+static const oid securityStatusOID[] = { DNSDIST_STATS_OID, 38 };
+static const oid specialMemoryUsageOID[] = { DNSDIST_STATS_OID, 39 };
+static const oid ruleTruncatedOID[] = { DNSDIST_STATS_OID, 40 };
+
+static std::unordered_map<oid, DNSDistStats::entry_t> s_statsMap;
+
+/* We are never called for a GETNEXT if it's registered as a
+   "instance", as it's "magically" handled for us.  */
+/* a instance handler also only hands us one request at a time, so
+   we don't need to loop over a list of requests; we'll only get one. */
+
+static int handleCounter64Stats(netsnmp_mib_handler* handler,
+                                netsnmp_handler_registration* reginfo,
+                                netsnmp_agent_request_info* reqinfo,
+                                netsnmp_request_info* requests)
+{
+  if (reqinfo->mode != MODE_GET) {
+    return SNMP_ERR_GENERR;
+  }
+
+  if (reginfo->rootoid_len != OID_LENGTH(queriesOID) + 1) {
+    return SNMP_ERR_GENERR;
+  }
+
+  const auto& it = s_statsMap.find(reginfo->rootoid[reginfo->rootoid_len - 2]);
+  if (it == s_statsMap.end()) {
+    return SNMP_ERR_GENERR;
+  }
+
+  if (const auto& val = boost::get<pdns::stat_t*>(&it->second)) {
+    return DNSDistSNMPAgent::setCounter64Value(requests, (*val)->load());
+  }
+
+  return SNMP_ERR_GENERR;
+}
+
+static void registerCounter64Stat(const char* name, const oid statOID[], size_t statOIDLength, pdns::stat_t* ptr)
+{
+  if (statOIDLength != OID_LENGTH(queriesOID)) {
+    errlog("Invalid OID for SNMP Counter64 statistic %s", name);
+    return;
+  }
+
+  if (s_statsMap.find(statOID[statOIDLength - 1]) != s_statsMap.end()) {
+    errlog("OID for SNMP Counter64 statistic %s has already been registered", name);
+    return;
+  }
+
+  s_statsMap[statOID[statOIDLength - 1]] = ptr;
+  netsnmp_register_scalar(netsnmp_create_handler_registration(name,
+                                                              handleCounter64Stats,
+                                                              statOID,
+                                                              statOIDLength,
+                                                              HANDLER_CAN_RONLY));
+}
+
+static int handleFloatStats(netsnmp_mib_handler* handler,
+                            netsnmp_handler_registration* reginfo,
+                            netsnmp_agent_request_info* reqinfo,
+                            netsnmp_request_info* requests)
+{
+  if (reqinfo->mode != MODE_GET) {
+    return SNMP_ERR_GENERR;
+  }
+
+  if (reginfo->rootoid_len != OID_LENGTH(queriesOID) + 1) {
+    return SNMP_ERR_GENERR;
+  }
+
+  const auto& it = s_statsMap.find(reginfo->rootoid[reginfo->rootoid_len - 2]);
+  if (it == s_statsMap.end()) {
+    return SNMP_ERR_GENERR;
+  }
+
+  if (const auto& val = boost::get<double*>(&it->second)) {
+    std::string str(std::to_string(**val));
+    snmp_set_var_typed_value(requests->requestvb,
+                             ASN_OCTET_STR,
+                             str.c_str(),
+                             str.size());
+    return SNMP_ERR_NOERROR;
+  }
+
+  return SNMP_ERR_GENERR;
+}
+
+static void registerFloatStat(const char* name, const oid statOID[], size_t statOIDLength, double* ptr)
+{
+  if (statOIDLength != OID_LENGTH(queriesOID)) {
+    errlog("Invalid OID for SNMP Float statistic %s", name);
+    return;
+  }
+
+  if (s_statsMap.find(statOID[statOIDLength - 1]) != s_statsMap.end()) {
+    errlog("OID for SNMP Float statistic %s has already been registered", name);
+    return;
+  }
+
+  s_statsMap[statOID[statOIDLength - 1]] = ptr;
+  netsnmp_register_scalar(netsnmp_create_handler_registration(name,
+                                                              handleFloatStats,
+                                                              statOID,
+                                                              statOIDLength,
+                                                              HANDLER_CAN_RONLY));
+}
+
+static int handleGauge64Stats(netsnmp_mib_handler* handler,
+                              netsnmp_handler_registration* reginfo,
+                              netsnmp_agent_request_info* reqinfo,
+                              netsnmp_request_info* requests)
+{
+  if (reqinfo->mode != MODE_GET) {
+    return SNMP_ERR_GENERR;
+  }
+
+  if (reginfo->rootoid_len != OID_LENGTH(queriesOID) + 1) {
+    return SNMP_ERR_GENERR;
+  }
+
+  const auto& it = s_statsMap.find(reginfo->rootoid[reginfo->rootoid_len - 2]);
+  if (it == s_statsMap.end()) {
+    return SNMP_ERR_GENERR;
+  }
+
+  std::string str;
+  uint64_t value = (*boost::get<DNSDistStats::statfunction_t>(&it->second))(str);
+  return DNSDistSNMPAgent::setCounter64Value(requests, value);
+}
+
+static void registerGauge64Stat(const char* name, const oid statOID[], size_t statOIDLength, DNSDistStats::statfunction_t ptr)
+{
+  if (statOIDLength != OID_LENGTH(queriesOID)) {
+    errlog("Invalid OID for SNMP Gauge64 statistic %s", name);
+    return;
+  }
+
+  if (s_statsMap.find(statOID[statOIDLength - 1]) != s_statsMap.end()) {
+    errlog("OID for SNMP Gauge64 statistic %s has already been registered", name);
+    return;
+  }
+
+  s_statsMap[statOID[statOIDLength - 1]] = ptr;
+  netsnmp_register_scalar(netsnmp_create_handler_registration(name,
+                                                              handleGauge64Stats,
+                                                              statOID,
+                                                              statOIDLength,
+                                                              HANDLER_CAN_RONLY));
+}
+
+/* column number definitions for table backendStatTable */
+#define COLUMN_BACKENDID                1
+#define COLUMN_BACKENDNAME              2
+#define COLUMN_BACKENDLATENCY           3
+#define COLUMN_BACKENDWEIGHT            4
+#define COLUMN_BACKENDOUTSTANDING       5
+#define COLUMN_BACKENDQPSLIMIT          6
+#define COLUMN_BACKENDREUSED            7
+#define COLUMN_BACKENDSTATE             8
+#define COLUMN_BACKENDADDRESS           9
+#define COLUMN_BACKENDPOOLS             10
+#define COLUMN_BACKENDQPS               11
+#define COLUMN_BACKENDQUERIES           12
+#define COLUMN_BACKENDORDER             13
+
+static const oid backendStatTableOID[] = { DNSDIST_STATS_TABLE_OID };
+static const oid backendNameOID[] = { DNSDIST_STATS_TABLE_OID, 1, 2 };
+static const oid backendStateOID[] = { DNSDIST_STATS_TABLE_OID, 1, 8};
+static const oid backendAddressOID[] = { DNSDIST_STATS_TABLE_OID, 1, 9};
+
+static const oid socketFamilyOID[] = { DNSDIST_TRAP_OBJECTS_OID, 1, 0 };
+static const oid socketProtocolOID[] = { DNSDIST_TRAP_OBJECTS_OID, 2, 0 };
+static const oid fromAddressOID[] = { DNSDIST_TRAP_OBJECTS_OID, 3, 0 };
+static const oid toAddressOID[] = { DNSDIST_TRAP_OBJECTS_OID, 4, 0 };
+static const oid queryTypeOID[] = { DNSDIST_TRAP_OBJECTS_OID, 5, 0 };
+static const oid querySizeOID[] = { DNSDIST_TRAP_OBJECTS_OID, 6, 0 };
+static const oid queryIDOID[] = { DNSDIST_TRAP_OBJECTS_OID, 7, 0 };
+static const oid qNameOID[] = { DNSDIST_TRAP_OBJECTS_OID, 8, 0 };
+static const oid qClassOID[] = { DNSDIST_TRAP_OBJECTS_OID, 9, 0 };
+static const oid qTypeOID[] = { DNSDIST_TRAP_OBJECTS_OID, 10, 0 };
+static const oid trapReasonOID[] = { DNSDIST_TRAP_OBJECTS_OID, 11, 0 };
+
+static const oid backendStatusChangeTrapOID[] = { DNSDIST_TRAPS_OID, 1 };
+static const oid actionTrapOID[] = { DNSDIST_TRAPS_OID, 2 };
+static const oid customTrapOID[] = { DNSDIST_TRAPS_OID, 3 };
+
+static servers_t s_servers;
+static size_t s_currentServerIdx = 0;
+
+static netsnmp_variable_list* backendStatTable_get_next_data_point(void** loop_context,
+                                                                   void** my_data_context,
+                                                                   netsnmp_variable_list* put_index_data,
+                                                                   netsnmp_iterator_info* mydata)
+{
+  if (s_currentServerIdx >= s_servers.size()) {
+    return NULL;
+  }
+
+  *my_data_context = (void*) (s_servers[s_currentServerIdx]).get();
+  snmp_set_var_typed_integer(put_index_data, ASN_UNSIGNED, s_currentServerIdx);
+  s_currentServerIdx++;
+
+  return put_index_data;
+}
+
+static netsnmp_variable_list* backendStatTable_get_first_data_point(void** loop_context,
+                                                                    void** data_context,
+                                                                    netsnmp_variable_list* put_index_data,
+                                                                    netsnmp_iterator_info* data)
+{
+  s_currentServerIdx = 0;
+
+  /* get a copy of the shared_ptrs so they are not
+     destroyed while we process the request */
+  auto dstates = g_dstates.getLocal();
+  s_servers.clear();
+  s_servers.reserve(dstates->size());
+  for (const auto& server : *dstates) {
+    s_servers.push_back(server);
+  }
+
+  return backendStatTable_get_next_data_point(loop_context,
+                                              data_context,
+                                              put_index_data,
+                                              data);
+}
+
+static int backendStatTable_handler(netsnmp_mib_handler* handler,
+                                    netsnmp_handler_registration* reginfo,
+                                    netsnmp_agent_request_info* reqinfo,
+                                    netsnmp_request_info* requests)
+{
+  netsnmp_request_info* request;
+
+  switch (reqinfo->mode) {
+  case MODE_GET:
+    for (request = requests; request; request = request->next) {
+      netsnmp_table_request_info* table_info = netsnmp_extract_table_info(request);
+      const DownstreamState* server = (const DownstreamState*) netsnmp_extract_iterator_context(request);
+
+      if (!server) {
+        continue;
+      }
+
+      switch (table_info->colnum) {
+      case COLUMN_BACKENDNAME:
+        snmp_set_var_typed_value(request->requestvb,
+                                 ASN_OCTET_STR,
+                                 server->getName().c_str(),
+                                 server->getName().size());
+        break;
+      case COLUMN_BACKENDLATENCY:
+        DNSDistSNMPAgent::setCounter64Value(request,
+                                            server->latencyUsec/1000.0);
+        break;
+      case COLUMN_BACKENDWEIGHT:
+        DNSDistSNMPAgent::setCounter64Value(request,
+                                            server->weight);
+        break;
+      case COLUMN_BACKENDOUTSTANDING:
+        DNSDistSNMPAgent::setCounter64Value(request,
+                                            server->outstanding.load());
+        break;
+      case COLUMN_BACKENDQPSLIMIT:
+        DNSDistSNMPAgent::setCounter64Value(request,
+                                            server->qps.getRate());
+        break;
+      case COLUMN_BACKENDREUSED:
+        DNSDistSNMPAgent::setCounter64Value(request, server->reuseds.load());
+        break;
+      case COLUMN_BACKENDSTATE:
+      {
+        std::string state(server->getStatus());
+        snmp_set_var_typed_value(request->requestvb,
+                                 ASN_OCTET_STR,
+                                 state.c_str(),
+                                 state.size());
+        break;
+      }
+      case COLUMN_BACKENDADDRESS:
+      {
+        std::string addr(server->remote.toStringWithPort());
+        snmp_set_var_typed_value(request->requestvb,
+                                 ASN_OCTET_STR,
+                                 addr.c_str(),
+                                 addr.size());
+        break;
+      }
+      case COLUMN_BACKENDPOOLS:
+      {
+        std::string pools;
+        for(auto& p : server->pools) {
+          if(!pools.empty())
+            pools+=" ";
+          pools+=p;
+        }
+        snmp_set_var_typed_value(request->requestvb,
+                                 ASN_OCTET_STR,
+                                 pools.c_str(),
+                                 pools.size());
+        break;
+      }
+      case COLUMN_BACKENDQPS:
+        DNSDistSNMPAgent::setCounter64Value(request, server->queryLoad.load());
+        break;
+      case COLUMN_BACKENDQUERIES:
+        DNSDistSNMPAgent::setCounter64Value(request, server->queries.load());
+        break;
+      case COLUMN_BACKENDORDER:
+        DNSDistSNMPAgent::setCounter64Value(request, server->order);
+        break;
+      default:
+        netsnmp_set_request_error(reqinfo,
+                                  request,
+                                  SNMP_NOSUCHOBJECT);
+        break;
+      }
+    }
+    break;
+  }
+  return SNMP_ERR_NOERROR;
+}
+#endif /* HAVE_NET_SNMP */
+
+bool DNSDistSNMPAgent::sendBackendStatusChangeTrap(const std::shared_ptr<DownstreamState>& dss)
+{
+#ifdef HAVE_NET_SNMP
+  const string backendAddress = dss->remote.toStringWithPort();
+  const string backendStatus = dss->getStatus();
+  netsnmp_variable_list* varList = nullptr;
+
+  snmp_varlist_add_variable(&varList,
+                            snmpTrapOID,
+                            snmpTrapOIDLen,
+                            ASN_OBJECT_ID,
+                            backendStatusChangeTrapOID,
+                            OID_LENGTH(backendStatusChangeTrapOID)  * sizeof(oid));
+
+
+  snmp_varlist_add_variable(&varList,
+                            backendNameOID,
+                            OID_LENGTH(backendNameOID),
+                            ASN_OCTET_STR,
+                            dss->getName().c_str(),
+                            dss->getName().size());
+
+  snmp_varlist_add_variable(&varList,
+                            backendAddressOID,
+                            OID_LENGTH(backendAddressOID),
+                            ASN_OCTET_STR,
+                            backendAddress.c_str(),
+                            backendAddress.size());
+
+  snmp_varlist_add_variable(&varList,
+                            backendStateOID,
+                            OID_LENGTH(backendStateOID),
+                            ASN_OCTET_STR,
+                            backendStatus.c_str(),
+                            backendStatus.size());
+
+  return sendTrap(d_trapPipe[1], varList);
+#else
+  return true;
+#endif /* HAVE_NET_SNMP */
+}
+
+bool DNSDistSNMPAgent::sendCustomTrap(const std::string& reason)
+{
+#ifdef HAVE_NET_SNMP
+  netsnmp_variable_list* varList = nullptr;
+
+  snmp_varlist_add_variable(&varList,
+                            snmpTrapOID,
+                            snmpTrapOIDLen,
+                            ASN_OBJECT_ID,
+                            customTrapOID,
+                            OID_LENGTH(customTrapOID)  * sizeof(oid));
+
+  snmp_varlist_add_variable(&varList,
+                            trapReasonOID,
+                            OID_LENGTH(trapReasonOID),
+                            ASN_OCTET_STR,
+                            reason.c_str(),
+                            reason.size());
+
+  return sendTrap(d_trapPipe[1], varList);
+#else
+  return true;
+#endif /* HAVE_NET_SNMP */
+}
+
+bool DNSDistSNMPAgent::sendDNSTrap(const DNSQuestion& dq, const std::string& reason)
+{
+#ifdef HAVE_NET_SNMP
+  std::string local = dq.local->toString();
+  std::string remote = dq.remote->toString();
+  std::string qname = dq.qname->toStringNoDot();
+  const uint32_t socketFamily = dq.remote->isIPv4() ? 1 : 2;
+  const uint32_t socketProtocol = dq.overTCP() ? 2 : 1;
+  const uint32_t queryType = dq.getHeader()->qr ? 2 : 1;
+  const uint32_t querySize = (uint32_t) dq.getData().size();
+  const uint32_t queryID = (uint32_t) ntohs(dq.getHeader()->id);
+  const uint32_t qType = (uint32_t) dq.qtype;
+  const uint32_t qClass = (uint32_t) dq.qclass;
+
+  netsnmp_variable_list* varList = nullptr;
+
+  snmp_varlist_add_variable(&varList,
+                            snmpTrapOID,
+                            snmpTrapOIDLen,
+                            ASN_OBJECT_ID,
+                            actionTrapOID,
+                            OID_LENGTH(actionTrapOID)  * sizeof(oid));
+
+  snmp_varlist_add_variable(&varList,
+                            socketFamilyOID,
+                            OID_LENGTH(socketFamilyOID),
+                            ASN_INTEGER,
+                            reinterpret_cast<const u_char*>(&socketFamily),
+                            sizeof(socketFamily));
+
+  snmp_varlist_add_variable(&varList,
+                            socketProtocolOID,
+                            OID_LENGTH(socketProtocolOID),
+                            ASN_INTEGER,
+                            reinterpret_cast<const u_char*>(&socketProtocol),
+                            sizeof(socketProtocol));
+
+  snmp_varlist_add_variable(&varList,
+                            fromAddressOID,
+                            OID_LENGTH(fromAddressOID),
+                            ASN_OCTET_STR,
+                            remote.c_str(),
+                            remote.size());
+
+  snmp_varlist_add_variable(&varList,
+                            toAddressOID,
+                            OID_LENGTH(toAddressOID),
+                            ASN_OCTET_STR,
+                            local.c_str(),
+                            local.size());
+
+  snmp_varlist_add_variable(&varList,
+                            queryTypeOID,
+                            OID_LENGTH(queryTypeOID),
+                            ASN_INTEGER,
+                            reinterpret_cast<const u_char*>(&queryType),
+                            sizeof(queryType));
+
+  snmp_varlist_add_variable(&varList,
+                            querySizeOID,
+                            OID_LENGTH(querySizeOID),
+                            ASN_UNSIGNED,
+                            reinterpret_cast<const u_char*>(&querySize),
+                            sizeof(querySize));
+
+  snmp_varlist_add_variable(&varList,
+                            queryIDOID,
+                            OID_LENGTH(queryIDOID),
+                            ASN_UNSIGNED,
+                            reinterpret_cast<const u_char*>(&queryID),
+                            sizeof(queryID));
+
+  snmp_varlist_add_variable(&varList,
+                            qNameOID,
+                            OID_LENGTH(qNameOID),
+                            ASN_OCTET_STR,
+                            qname.c_str(),
+                            qname.size());
+
+  snmp_varlist_add_variable(&varList,
+                            qClassOID,
+                            OID_LENGTH(qClassOID),
+                            ASN_UNSIGNED,
+                            reinterpret_cast<const u_char*>(&qClass),
+                            sizeof(qClass));
+
+  snmp_varlist_add_variable(&varList,
+                            qTypeOID,
+                            OID_LENGTH(qTypeOID),
+                            ASN_UNSIGNED,
+                            reinterpret_cast<const u_char*>(&qType),
+                            sizeof(qType));
+
+  snmp_varlist_add_variable(&varList,
+                            trapReasonOID,
+                            OID_LENGTH(trapReasonOID),
+                            ASN_OCTET_STR,
+                            reason.c_str(),
+                            reason.size());
+
+  return sendTrap(d_trapPipe[1], varList);
+#else
+  return true;
+#endif /* HAVE_NET_SNMP */
+}
+
+DNSDistSNMPAgent::DNSDistSNMPAgent(const std::string& name, const std::string& daemonSocket): SNMPAgent(name, daemonSocket)
+{
+#ifdef HAVE_NET_SNMP
+
+  registerCounter64Stat("queries", queriesOID, OID_LENGTH(queriesOID), &g_stats.queries);
+  registerCounter64Stat("responses", responsesOID, OID_LENGTH(responsesOID), &g_stats.responses);
+  registerCounter64Stat("servfailResponses", servfailResponsesOID, OID_LENGTH(servfailResponsesOID), &g_stats.servfailResponses);
+  registerCounter64Stat("aclDrops", aclDropsOID, OID_LENGTH(aclDropsOID), &g_stats.aclDrops);
+  registerCounter64Stat("ruleDrop", ruleDropOID, OID_LENGTH(ruleDropOID), &g_stats.ruleDrop);
+  registerCounter64Stat("ruleNXDomain", ruleNXDomainOID, OID_LENGTH(ruleNXDomainOID), &g_stats.ruleNXDomain);
+  registerCounter64Stat("ruleRefused", ruleRefusedOID, OID_LENGTH(ruleRefusedOID), &g_stats.ruleRefused);
+  registerCounter64Stat("ruleServFail", ruleServFailOID, OID_LENGTH(ruleServFailOID), &g_stats.ruleServFail);
+  registerCounter64Stat("ruleTruncated", ruleTruncatedOID, OID_LENGTH(ruleTruncatedOID), &g_stats.ruleTruncated);
+  registerCounter64Stat("selfAnswered", selfAnsweredOID, OID_LENGTH(selfAnsweredOID), &g_stats.selfAnswered);
+  registerCounter64Stat("downstreamTimeouts", downstreamTimeoutsOID, OID_LENGTH(downstreamTimeoutsOID), &g_stats.downstreamTimeouts);
+  registerCounter64Stat("downstreamSendErrors", downstreamSendErrorsOID, OID_LENGTH(downstreamSendErrorsOID), &g_stats.downstreamSendErrors);
+  registerCounter64Stat("truncFail", truncFailOID, OID_LENGTH(truncFailOID), &g_stats.truncFail);
+  registerCounter64Stat("noPolicy", noPolicyOID, OID_LENGTH(noPolicyOID), &g_stats.noPolicy);
+  registerCounter64Stat("latency0_1", latency0_1OID, OID_LENGTH(latency0_1OID), &g_stats.latency0_1);
+  registerCounter64Stat("latency1_10", latency1_10OID, OID_LENGTH(latency1_10OID), &g_stats.latency1_10);
+  registerCounter64Stat("latency10_50", latency10_50OID, OID_LENGTH(latency10_50OID), &g_stats.latency10_50);
+  registerCounter64Stat("latency50_100", latency50_100OID, OID_LENGTH(latency50_100OID), &g_stats.latency50_100);
+  registerCounter64Stat("latency100_1000", latency100_1000OID, OID_LENGTH(latency100_1000OID), &g_stats.latency100_1000);
+  registerCounter64Stat("latencySlow", latencySlowOID, OID_LENGTH(latencySlowOID), &g_stats.latencySlow);
+  registerCounter64Stat("nonCompliantQueries", nonCompliantQueriesOID, OID_LENGTH(nonCompliantQueriesOID), &g_stats.nonCompliantQueries);
+  registerCounter64Stat("nonCompliantResponses", nonCompliantResponsesOID, OID_LENGTH(nonCompliantResponsesOID), &g_stats.nonCompliantResponses);
+  registerCounter64Stat("rdQueries", rdQueriesOID, OID_LENGTH(rdQueriesOID), &g_stats.rdQueries);
+  registerCounter64Stat("emptyQueries", emptyQueriesOID, OID_LENGTH(emptyQueriesOID), &g_stats.emptyQueries);
+  registerCounter64Stat("cacheHits", cacheHitsOID, OID_LENGTH(cacheHitsOID), &g_stats.cacheHits);
+  registerCounter64Stat("cacheMisses", cacheMissesOID, OID_LENGTH(cacheMissesOID), &g_stats.cacheMisses);
+  registerCounter64Stat("dynBlocked", dynBlockedOID, OID_LENGTH(dynBlockedOID), &g_stats.dynBlocked);
+  registerFloatStat("latencyAvg100", latencyAvg100OID, OID_LENGTH(latencyAvg100OID), &g_stats.latencyAvg100);
+  registerFloatStat("latencyAvg1000", latencyAvg1000OID, OID_LENGTH(latencyAvg1000OID), &g_stats.latencyAvg1000);
+  registerFloatStat("latencyAvg10000", latencyAvg10000OID, OID_LENGTH(latencyAvg10000OID), &g_stats.latencyAvg10000);
+  registerFloatStat("latencyAvg1000000", latencyAvg1000000OID, OID_LENGTH(latencyAvg1000000OID), &g_stats.latencyAvg1000000);
+  registerGauge64Stat("uptime", uptimeOID, OID_LENGTH(uptimeOID), &uptimeOfProcess);
+  registerGauge64Stat("specialMemoryUsage", specialMemoryUsageOID, OID_LENGTH(specialMemoryUsageOID), &getSpecialMemoryUsage);
+  registerGauge64Stat("cpuUserMSec", cpuUserMSecOID, OID_LENGTH(cpuUserMSecOID), &getCPUTimeUser);
+  registerGauge64Stat("cpuSysMSec", cpuSysMSecOID, OID_LENGTH(cpuSysMSecOID), &getCPUTimeSystem);
+  registerGauge64Stat("fdUsage", fdUsageOID, OID_LENGTH(fdUsageOID), &getOpenFileDescriptors);
+  registerGauge64Stat("dynBlockedNMGSize", dynBlockedNMGSizeOID, OID_LENGTH(dynBlockedNMGSizeOID), [](const std::string&) { return g_dynblockNMG.getLocal()->size(); });
+  registerGauge64Stat("securityStatus", securityStatusOID, OID_LENGTH(securityStatusOID), [](const std::string&) { return g_stats.securityStatus.load(); });
+  registerGauge64Stat("realMemoryUsage", realMemoryUsageOID, OID_LENGTH(realMemoryUsageOID), &getRealMemoryUsage);
+
+
+  netsnmp_table_registration_info* table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
+  netsnmp_table_helper_add_indexes(table_info,
+                                   ASN_GAUGE,  /* index: backendId */
+                                   0);
+  table_info->min_column = COLUMN_BACKENDNAME;
+  table_info->max_column = COLUMN_BACKENDORDER;
+  netsnmp_iterator_info* iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info);
+  iinfo->get_first_data_point = backendStatTable_get_first_data_point;
+  iinfo->get_next_data_point = backendStatTable_get_next_data_point;
+  iinfo->table_reginfo = table_info;
+
+  netsnmp_register_table_iterator(netsnmp_create_handler_registration("backendStatTable",
+                                                                      backendStatTable_handler,
+                                                                      backendStatTableOID,
+                                                                      OID_LENGTH(backendStatTableOID),
+                                                                      HANDLER_CAN_RONLY),
+                                  iinfo);
+
+#endif /* HAVE_NET_SNMP */
+}