12321902803

Committed 13 Dec 2024 07:34PM UTC coverage: 66.359% (+1.6%) from 64.78%

Build # 12321902803

Build Type

Pull #14970

github

Committed by

web-flow

Commit Message

Merge e3a7df61c into 3dfd8e317

Pull Request Pull Request #14970: boost > std optional

Run Details

26084 of 54744 branches covered (47.65%)

Branch coverage included in aggregate %.

14 of 15 new or added lines in 2 files covered. (93.33%)

1863 existing lines in 52 files now uncovered.

85857 of 113946 relevant lines covered (75.35%)

4412729.59 hits per line

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

63.44

/pdns/dnstap.cc

#include <boost/uuid/uuid.hpp>
#include "config.h"
#include "gettime.hh"
#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
};
}

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

PowerDNS / pdns / 12321902803

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