dnstap: Declares names instead of using numerical values for fields

diff --git a/pdns/dnsdist-lua-actions.cc b/pdns/dnsdist-lua-actions.cc
index b8da49f0eaa70fb31e83322057b9919ee8763329..49bc53f17d1f0a6fa4ac47484e53d7b443bffe72 100644 (file)
--- a/pdns/dnsdist-lua-actions.cc
+++ b/pdns/dnsdist-lua-actions.cc
@@ -991,7 +991,7 @@ public:
     data.clear();
 
     const struct dnsheader* dh = reinterpret_cast<const struct dnsheader*>(dq->dh);
-    DnstapMessage message(data, !dh->qr ? 5 : 6, d_identity, dq->remote, dq->local, dq->tcp, reinterpret_cast<const char*>(dq->dh), dq->len, dq->queryTime, nullptr);
+    DnstapMessage message(data, !dh->qr ? DnstapMessage::MessageType::client_query : DnstapMessage::MessageType::client_response, d_identity, dq->remote, dq->local, dq->tcp, reinterpret_cast<const char*>(dq->dh), dq->len, dq->queryTime, nullptr);
     {
       if (d_alterFunc) {
         std::lock_guard<std::mutex> lock(g_luamutex);
@@ -1120,7 +1120,7 @@ public:
     gettime(&now, true);
     data.clear();
 
-    DnstapMessage message(data, 6, d_identity, dr->remote, dr->local, dr->tcp, reinterpret_cast<const char*>(dr->dh), dr->len, dr->queryTime, &now);
+    DnstapMessage message(data, DnstapMessage::MessageType::client_response, d_identity, dr->remote, dr->local, dr->tcp, reinterpret_cast<const char*>(dr->dh), dr->len, dr->queryTime, &now);
     {
       if (d_alterFunc) {
         std::lock_guard<std::mutex> lock(g_luamutex);

diff --git a/pdns/dnstap.cc b/pdns/dnstap.cc
index a8fa98b15f609e8a5e8e7011e1800b07dbdeefd5..45c1003eb5bd54d5ac2ef415fee92ce1dac77956 100644 (file)
--- a/pdns/dnstap.cc
+++ b/pdns/dnstap.cc
@@ -5,64 +5,92 @@
 
 #include "ext/protozero/include/protozero/pbf_writer.hpp"
 
-DnstapMessage::DnstapMessage(std::string& buffer, int32_t type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, bool isTCP, const char* packet, const size_t len, const struct timespec* queryTime, const struct timespec* responseTime, boost::optional<const DNSName&> auth): d_buffer(buffer)
+namespace DnstapBaseFields {
+  enum : protozero::pbf_tag_type { identity = 1, version = 2, extra = 3, message = 14, type = 15 };
+}
+
+namespace DnstapMessageTypes {
+  enum : protozero::pbf_tag_type { message = 1 };
+}
+
+namespace DnstapSocketFamilyTypes {
+  enum : protozero::pbf_tag_type { inet = 1, inet6 = 2 };
+}
+
+namespace DnstapSocketFamilyProtocol {
+  enum : protozero::pbf_tag_type { udp = 1, tcp = 2 };
+}
+
+namespace DnstapMessageFields {
+  enum : protozero::pbf_tag_type { type = 1, socket_family = 2, socket_protocol = 3, query_address = 4, response_address = 5, query_port = 6, response_port = 7, query_time_sec = 8, query_time_nsec = 9, query_message = 10, query_zone = 11, response_time_sec = 12, response_time_nsec = 13, response_message = 14 };
+}
+
+DnstapMessage::DnstapMessage(std::string& buffer, DnstapMessage::MessageType type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, bool isTCP, const char* packet, const size_t len, const struct timespec* queryTime, const struct timespec* responseTime, boost::optional<const DNSName&> auth): d_buffer(buffer)
 {
   protozero::pbf_writer pbf{d_buffer};
 
-  pbf.add_bytes(1, identity);
-  pbf.add_bytes(2, PACKAGE_STRING);
-  pbf.add_enum(15, 1);
+  pbf.add_bytes(DnstapBaseFields::identity, identity);
+  pbf.add_bytes(DnstapBaseFields::version, PACKAGE_STRING);
+  pbf.add_enum(DnstapBaseFields::type, DnstapMessageTypes::message);
 
   const struct dnsheader* dh = reinterpret_cast<const struct dnsheader*>(packet);
-  protozero::pbf_writer pbf_message{pbf, 14};
+  protozero::pbf_writer pbf_message{pbf, DnstapBaseFields::message};
 
-  pbf_message.add_enum(1, type);
-  pbf_message.add_enum(3, isTCP ? 2 : 1);
+  pbf_message.add_enum(DnstapMessageFields::type, static_cast<protozero::pbf_tag_type>(type));
+  pbf_message.add_enum(DnstapMessageFields::socket_protocol, isTCP ? DnstapSocketFamilyProtocol::tcp : DnstapSocketFamilyProtocol::udp);
+
+  if (requestor != nullptr) {
+    pbf_message.add_enum(DnstapMessageFields::socket_family, requestor->sin4.sin_family == AF_INET ? DnstapSocketFamilyTypes::inet : DnstapSocketFamilyTypes::inet6);
+  }
+  else if (responder != nullptr) {
+    pbf_message.add_enum(DnstapMessageFields::socket_family, responder->sin4.sin_family == AF_INET ? DnstapSocketFamilyTypes::inet : DnstapSocketFamilyTypes::inet6);
+  }
 
   if (requestor != nullptr) {
-    pbf_message.add_enum(2, requestor->sin4.sin_family == AF_INET ? 1 : 2);
     if (requestor->sin4.sin_family == AF_INET) {
-      pbf_message.add_bytes(4, reinterpret_cast<const char*>(&requestor->sin4.sin_addr.s_addr), sizeof(requestor->sin4.sin_addr.s_addr));
+      pbf_message.add_bytes(DnstapMessageFields::query_address, reinterpret_cast<const char*>(&requestor->sin4.sin_addr.s_addr), sizeof(requestor->sin4.sin_addr.s_addr));
     }
     else if (requestor->sin4.sin_family == AF_INET6) {
-      pbf_message.add_bytes(4, reinterpret_cast<const char*>(&requestor->sin6.sin6_addr.s6_addr), sizeof(requestor->sin6.sin6_addr.s6_addr));
+      pbf_message.add_bytes(DnstapMessageFields::query_address, reinterpret_cast<const char*>(&requestor->sin6.sin6_addr.s6_addr), sizeof(requestor->sin6.sin6_addr.s6_addr));
     }
-    pbf_message.add_uint32(6, ntohs(requestor->sin4.sin_port));
+    pbf_message.add_uint32(DnstapMessageFields::query_port, ntohs(requestor->sin4.sin_port));
   }
 
   if (responder != nullptr) {
     if (responder->sin4.sin_family == AF_INET) {
-      pbf_message.add_bytes(5, reinterpret_cast<const char*>(&responder->sin4.sin_addr.s_addr), sizeof(responder->sin4.sin_addr.s_addr));
+      pbf_message.add_bytes(DnstapMessageFields::response_address, reinterpret_cast<const char*>(&responder->sin4.sin_addr.s_addr), sizeof(responder->sin4.sin_addr.s_addr));
     }
     else if (responder->sin4.sin_family == AF_INET6) {
-      pbf_message.add_bytes(5, reinterpret_cast<const char*>(&responder->sin6.sin6_addr.s6_addr), sizeof(responder->sin6.sin6_addr.s6_addr));
+      pbf_message.add_bytes(DnstapMessageFields::response_address, reinterpret_cast<const char*>(&responder->sin6.sin6_addr.s6_addr), sizeof(responder->sin6.sin6_addr.s6_addr));
     }
-    pbf_message.add_uint32(7, ntohs(responder->sin4.sin_port));
+    pbf_message.add_uint32(DnstapMessageFields::response_port, ntohs(responder->sin4.sin_port));
   }
 
   if (queryTime != nullptr) {
-    pbf_message.add_uint64(8, queryTime->tv_sec);
-    pbf_message.add_fixed32(9, queryTime->tv_nsec);
+    pbf_message.add_uint64(DnstapMessageFields::query_time_sec, queryTime->tv_sec);
+    pbf_message.add_fixed32(DnstapMessageFields::query_time_nsec, queryTime->tv_nsec);
   }
 
   if (responseTime != nullptr) {
-    pbf_message.add_uint64(12, responseTime->tv_sec);
-    pbf_message.add_fixed32(13, responseTime->tv_nsec);
+    pbf_message.add_uint64(DnstapMessageFields::response_time_sec, responseTime->tv_sec);
+    pbf_message.add_fixed32(DnstapMessageFields::response_time_nsec, responseTime->tv_nsec);
   }
 
   if (!dh->qr) {
-    pbf_message.add_bytes(10, packet, len);
+    pbf_message.add_bytes(DnstapMessageFields::query_message, packet, len);
   } else {
-    pbf_message.add_bytes(14, packet, len);
+    pbf_message.add_bytes(DnstapMessageFields::response_message, packet, len);
   }
 
   if (auth) {
-    pbf_message.add_bytes(11, auth->toDNSString());
+    pbf_message.add_bytes(DnstapMessageFields::query_zone, auth->toDNSString());
   }
+
+  pbf_message.commit();
 }
 
 void DnstapMessage::setExtra(const std::string& extra)
 {
   protozero::pbf_writer pbf{d_buffer};
-  pbf.add_bytes(3, extra);
+  pbf.add_bytes(DnstapBaseFields::extra, extra);
 }

diff --git a/pdns/dnstap.hh b/pdns/dnstap.hh
index 2b1373ddfbcffcf3a00c48b720f8182cc1e43191..3d3fe71bb4552615db7b53c11089c78536834c05 100644 (file)
--- a/pdns/dnstap.hh
+++ b/pdns/dnstap.hh
@@ -33,7 +33,9 @@
 class DnstapMessage
 {
 public:
-  DnstapMessage(std::string& buffer, int32_t type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, bool isTCP, const char* packet, const size_t len, const struct timespec* queryTime, const struct timespec* responseTime, boost::optional<const DNSName&> auth=boost::none);
+  enum class MessageType : uint32_t { auth_query = 1, auth_response = 2, resolver_query = 3, resolver_response = 4, client_query = 5, client_response = 6, forwarder_query = 7, forwarded_response = 8, stub_query = 9, stub_response = 10, tool_query = 11, tool_response = 12 };
+
+  DnstapMessage(std::string& buffer, MessageType type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, bool isTCP, const char* packet, const size_t len, const struct timespec* queryTime, const struct timespec* responseTime, boost::optional<const DNSName&> auth=boost::none);
 
   void setExtra(const std::string& extra);
 

diff --git a/pdns/lwres.cc b/pdns/lwres.cc
index b9e1c0a0b8d6ae903fdb24e0763ac2a0aab52475..ed4013233c4005a09aba9abd5f2b924ffc11b75b 100644 (file)
--- a/pdns/lwres.cc
+++ b/pdns/lwres.cc
@@ -81,7 +81,7 @@ static void logFstreamQuery(const std::shared_ptr<std::vector<std::unique_ptr<Fr
   struct timespec ts;
   TIMEVAL_TO_TIMESPEC(&queryTime, &ts);
   std::string str;
-  DnstapMessage message(str, 4, SyncRes::s_serverID, nullptr, &ip, doTCP, reinterpret_cast<const char*>(&*packet.begin()), packet.size(), &ts, nullptr, auth);
+  DnstapMessage message(str, DnstapMessage::MessageType::resolver_query, SyncRes::s_serverID, nullptr, &ip, doTCP, reinterpret_cast<const char*>(&*packet.begin()), packet.size(), &ts, nullptr, auth);
 
   for (auto& logger : *fstreamLoggers) {
     logger->queueData(str);
@@ -111,7 +111,7 @@ static void logFstreamResponse(const std::shared_ptr<std::vector<std::unique_ptr
   TIMEVAL_TO_TIMESPEC(&queryTime, &ts1);
   TIMEVAL_TO_TIMESPEC(&replyTime, &ts2);
   std::string str;
-  DnstapMessage message(str, 3, SyncRes::s_serverID, nullptr, &ip, doTCP, static_cast<const char*>(&*packet.begin()), packet.size(), &ts1, &ts2, auth);
+  DnstapMessage message(str, DnstapMessage::MessageType::resolver_response, SyncRes::s_serverID, nullptr, &ip, doTCP, static_cast<const char*>(&*packet.begin()), packet.size(), &ts1, &ts2, auth);
 
   for (auto& logger : *fstreamLoggers) {
     logger->queueData(str);