18679017918

Committed 21 Oct 2025 09:15AM UTC coverage: 69.743% (+2.0%) from 67.713%

Build # 18679017918

Build Type

Pull #16307

github

Committed by

web-flow

Commit Message

Merge ba88af487 into da98764c6

Pull Request Pull Request #16307: rec: explicit disabling/enabling of tls-gnutls for full and least configs and packages

Run Details

26192 of 45526 branches covered (57.53%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 1 file covered. (100.0%)

2282 existing lines in 57 files now uncovered.

86265 of 115719 relevant lines covered (74.55%)

4323875.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.71

/pdns/dnstap.cc

#include <boost/uuid/uuid.hpp>
#include "config.h"
#include "gettime.hh"
#include "protozero/types.hpp"
#include "dnstap.hh"

#ifndef DISABLE_PROTOBUF

#include <protozero/pbf_writer.hpp>

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 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,
  policy = 15,
  http_protocol = 16,
};
}

std::string&& DnstapMessage::getBuffer()
{
  return std::move(d_buffer);
}

DnstapMessage::DnstapMessage(std::string&& buffer, DnstapMessage::MessageType type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, DnstapMessage::ProtocolType protocol, const char* packet, const size_t len, const struct timespec* queryTime, const struct timespec* responseTime, const boost::optional<const DNSName&>& auth, const boost::optional<HttpProtocolType> httpProtocol) :
  d_buffer(std::move(buffer))
{
  protozero::pbf_writer pbf{d_buffer};

  pbf.add_bytes(DnstapBaseFields::identity, identity);
  pbf.add_bytes(DnstapBaseFields::version, PACKAGE_STRING);
  pbf.add_enum(DnstapBaseFields::type, DnstapMessageTypes::message);

  protozero::pbf_writer pbf_message{pbf, DnstapBaseFields::message};

  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
  pbf_message.add_enum(DnstapMessageFields::type, static_cast<protozero::pbf_tag_type>(type));
  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
  pbf_message.add_enum(DnstapMessageFields::socket_protocol, static_cast<protozero::pbf_tag_type>(protocol));

  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) {
    if (requestor->sin4.sin_family == AF_INET) {
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      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) {
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      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(DnstapMessageFields::query_port, ntohs(requestor->sin4.sin_port));
  }

  if (responder != nullptr) {
    if (responder->sin4.sin_family == AF_INET) {
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      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) {
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      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(DnstapMessageFields::response_port, ntohs(responder->sin4.sin_port));
  }

  if (queryTime != nullptr) {
    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(DnstapMessageFields::response_time_sec, responseTime->tv_sec);
    pbf_message.add_fixed32(DnstapMessageFields::response_time_nsec, responseTime->tv_nsec);
  }

  if (packet != nullptr && len >= sizeof(dnsheader)) {
    const dnsheader_aligned dnsheader(packet);
    if (!dnsheader->qr) {
      pbf_message.add_bytes(DnstapMessageFields::query_message, packet, len);
    }
    else {
      pbf_message.add_bytes(DnstapMessageFields::response_message, packet, len);
    }
  }
  if (httpProtocol) {
    // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
    pbf_message.add_enum(DnstapMessageFields::http_protocol, static_cast<protozero::pbf_tag_type>(*httpProtocol));
  }

  if (auth) {
    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(DnstapBaseFields::extra, extra);
}

#endif /* DISABLE_PROTOBUF */

1	#include <boost/uuid/uuid.hpp>
2	#include "config.h"
3	#include "gettime.hh"
4	#include "protozero/types.hpp"
5	#include "dnstap.hh"
6
7	#ifndef DISABLE_PROTOBUF
8
9	#include <protozero/pbf_writer.hpp>
10
11	namespace DnstapBaseFields
12	{
13	enum : protozero::pbf_tag_type
14	{
15	identity = 1,
16	version = 2,
17	extra = 3,
18	message = 14,
19	type = 15
20	};
21	}
22
23	namespace DnstapMessageTypes
24	{
25	enum : protozero::pbf_tag_type
26	{
27	message = 1
28	};
29	}
30
31	namespace DnstapSocketFamilyTypes
32	{
33	enum : protozero::pbf_tag_type
34	{
35	inet = 1,
36	inet6 = 2
37	};
38	}
39
40	namespace DnstapMessageFields
41	{
42	enum : protozero::pbf_tag_type
43	{
44	type = 1,
45	socket_family = 2,
46	socket_protocol = 3,
47	query_address = 4,
48	response_address = 5,
49	query_port = 6,
50	response_port = 7,
51	query_time_sec = 8,
52	query_time_nsec = 9,
53	query_message = 10,
54	query_zone = 11,
55	response_time_sec = 12,
56	response_time_nsec = 13,
57	response_message = 14,
58	policy = 15,
59	http_protocol = 16,
60	};
61	}
62
63	std::string&& DnstapMessage::getBuffer()
64	{	30✔
65	return std::move(d_buffer);	30✔
66	}	30✔
67
68	DnstapMessage::DnstapMessage(std::string&& buffer, DnstapMessage::MessageType type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, DnstapMessage::ProtocolType protocol, const char* packet, const size_t len, const struct timespec* queryTime, const struct timespec* responseTime, const boost::optional<const DNSName&>& auth, const boost::optional<HttpProtocolType> httpProtocol) :
69	d_buffer(std::move(buffer))	30✔
70	{	30✔
71	protozero::pbf_writer pbf{d_buffer};	30✔
72
73	pbf.add_bytes(DnstapBaseFields::identity, identity);	30✔
74	pbf.add_bytes(DnstapBaseFields::version, PACKAGE_STRING);	30✔
75	pbf.add_enum(DnstapBaseFields::type, DnstapMessageTypes::message);	30✔
76
77	protozero::pbf_writer pbf_message{pbf, DnstapBaseFields::message};	30✔
78
79	// NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
80	pbf_message.add_enum(DnstapMessageFields::type, static_cast<protozero::pbf_tag_type>(type));	30✔
81	// NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
82	pbf_message.add_enum(DnstapMessageFields::socket_protocol, static_cast<protozero::pbf_tag_type>(protocol));	30✔
83
84	if (requestor != nullptr) {	30!
85	pbf_message.add_enum(DnstapMessageFields::socket_family, requestor->sin4.sin_family == AF_INET ? DnstapSocketFamilyTypes::inet : DnstapSocketFamilyTypes::inet6);	30!
86	}	30✔
87	else if (responder != nullptr) {	×
88	pbf_message.add_enum(DnstapMessageFields::socket_family, responder->sin4.sin_family == AF_INET ? DnstapSocketFamilyTypes::inet : DnstapSocketFamilyTypes::inet6);	×
89	}	×
90
91	if (requestor != nullptr) {	30!
92	if (requestor->sin4.sin_family == AF_INET) {	30!
93	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
94	pbf_message.add_bytes(DnstapMessageFields::query_address, reinterpret_cast<const char*>(&requestor->sin4.sin_addr.s_addr), sizeof(requestor->sin4.sin_addr.s_addr));	30✔
95	}	30✔
96	else if (requestor->sin4.sin_family == AF_INET6) {	×
97	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
98	pbf_message.add_bytes(DnstapMessageFields::query_address, reinterpret_cast<const char*>(&requestor->sin6.sin6_addr.s6_addr), sizeof(requestor->sin6.sin6_addr.s6_addr));	×
99	}	×
100	pbf_message.add_uint32(DnstapMessageFields::query_port, ntohs(requestor->sin4.sin_port));	30✔
101	}	30✔
102
103	if (responder != nullptr) {	30!
104	if (responder->sin4.sin_family == AF_INET) {	30!
105	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
106	pbf_message.add_bytes(DnstapMessageFields::response_address, reinterpret_cast<const char*>(&responder->sin4.sin_addr.s_addr), sizeof(responder->sin4.sin_addr.s_addr));	30✔
107	}	30✔
108	else if (responder->sin4.sin_family == AF_INET6) {	×
109	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
110	pbf_message.add_bytes(DnstapMessageFields::response_address, reinterpret_cast<const char*>(&responder->sin6.sin6_addr.s6_addr), sizeof(responder->sin6.sin6_addr.s6_addr));	×
111	}	×
112	pbf_message.add_uint32(DnstapMessageFields::response_port, ntohs(responder->sin4.sin_port));	30✔
113	}	30✔
114
115	if (queryTime != nullptr) {	30!
116	pbf_message.add_uint64(DnstapMessageFields::query_time_sec, queryTime->tv_sec);	30✔
117	pbf_message.add_fixed32(DnstapMessageFields::query_time_nsec, queryTime->tv_nsec);	30✔
118	}	30✔
119
120	if (responseTime != nullptr) {	30✔
121	pbf_message.add_uint64(DnstapMessageFields::response_time_sec, responseTime->tv_sec);	8✔
122	pbf_message.add_fixed32(DnstapMessageFields::response_time_nsec, responseTime->tv_nsec);	8✔
123	}	8✔
124
125	if (packet != nullptr && len >= sizeof(dnsheader)) {	30!
126	const dnsheader_aligned dnsheader(packet);	30✔
127	if (!dnsheader->qr) {	30✔
128	pbf_message.add_bytes(DnstapMessageFields::query_message, packet, len);	22✔
129	}	22✔
130	else {	8✔
131	pbf_message.add_bytes(DnstapMessageFields::response_message, packet, len);	8✔
132	}	8✔
133	}	30✔
134	if (httpProtocol) {	30✔
135	// NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
136	pbf_message.add_enum(DnstapMessageFields::http_protocol, static_cast<protozero::pbf_tag_type>(*httpProtocol));	2✔
137	}	2✔
138
139	if (auth) {	30!
UNCOV 140	pbf_message.add_bytes(DnstapMessageFields::query_zone, auth->toDNSString());	×
UNCOV 141	}	×
142
143	pbf_message.commit();	30✔
144	}	30✔
145
146	void DnstapMessage::setExtra(const std::string& extra)
147	{	8✔
148	protozero::pbf_writer pbf{d_buffer};	8✔
149	pbf.add_bytes(DnstapBaseFields::extra, extra);	8✔
150	}	8✔
151
152	#endif /* DISABLE_PROTOBUF */

PowerDNS / pdns / 18679017918

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous