18743945403

Committed 23 Oct 2025 09:29AM UTC coverage: 65.845% (+0.02%) from 65.829%

Build # 18743945403

Build Type

Pull #16356

github

Committed by

web-flow

Commit Message

Merge 8a2027ef1 into efa3637e8

Pull Request Pull Request #16356: auth 5.0: backport "pdnsutil: fix b2b-migrate to from sql to non-sql"

Run Details

42073 of 92452 branches covered (45.51%)

Branch coverage included in aggregate %.

128008 of 165855 relevant lines covered (77.18%)

6379935.17 hits per line

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

51.74

/pdns/recursordist/rec-protozero.hh

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#pragma once

#include "protozero.hh"

#include "filterpo.hh"
#include "rec-eventtrace.hh"
#include "validate.hh"

namespace pdns
{
namespace ProtoZero
{
  class RecMessage : public Message
  {
  public:
    RecMessage() :
      Message(d_msgbuf)
    {
      d_response = protozero::pbf_writer(d_rspbuf);
    }

    RecMessage(std::string& buffer) :
      Message(buffer)
    {
      d_response = protozero::pbf_writer(buffer);
    }

    // Start a new messagebuf, containing separate data for the response part
    RecMessage(std::string::size_type sz1, std::string::size_type sz2) :
      RecMessage()
    {
      reserve(sz1, sz2);
    }

    // Construct a Message with (partially) constructed content
    RecMessage(const std::string& buf1, const std::string& buf2, std::string::size_type sz1, std::string::size_type sz2) :
      Message(d_msgbuf),
      d_msgbuf{buf1},
      d_rspbuf{buf2}
    {
      d_message = protozero::pbf_writer(d_msgbuf);
      d_response = protozero::pbf_writer(d_rspbuf);
      reserve(sz1, sz2);
    }
    RecMessage(const Message&) = delete;
    RecMessage(Message&&) = delete;
    RecMessage& operator=(const Message&) = delete;
    RecMessage& operator=(Message&&) = delete;

    void reserve(std::string::size_type sz1, std::string::size_type sz2)
    {
      // We expect to grow the buffers, in the end the d_message will contains the (grown) d_response
      // This is extra space in addition to what's already there
      // Different from what string.reserve() does
      std::string::size_type extra = sz1 + d_rspbuf.length() + sz2;
      if (d_msgbuf.capacity() < d_msgbuf.size() + extra) {
        d_message.reserve(extra);
      }
      if (d_rspbuf.capacity() < d_rspbuf.size() + sz2) {
        d_response.reserve(sz2);
      }
    }

    const std::string& getMessageBuf() const
    {
      return d_msgbuf;
    }

    const std::string& getResponseBuf() const
    {
      return d_rspbuf;
    }

    [[nodiscard]] size_t size() const
    {
      return d_msgbuf.size() + d_rspbuf.size();
    }

    std::string&& finishAndMoveBuf()
    {
      if (!d_rspbuf.empty()) {
        d_message.add_message(static_cast<protozero::pbf_tag_type>(Field::response), d_rspbuf);
      }
      return std::move(d_msgbuf);
    }

    void addEvents(const RecEventTrace& trace);

    // DNSResponse related fields below

    void addRR(const DNSRecord& record, const std::set<uint16_t>& exportTypes, std::optional<bool> udr);

    void setAppliedPolicyType(const DNSFilterEngine::PolicyType type)
    {
      uint32_t p;

      switch (type) {
      case DNSFilterEngine::PolicyType::None:
        p = 1;
        break;
      case DNSFilterEngine::PolicyType::QName:
        p = 2;
        break;
      case DNSFilterEngine::PolicyType::ClientIP:
        p = 3;
        break;
      case DNSFilterEngine::PolicyType::ResponseIP:
        p = 4;
        break;
      case DNSFilterEngine::PolicyType::NSDName:
        p = 5;
        break;
      case DNSFilterEngine::PolicyType::NSIP:
        p = 6;
        break;
      default:
        throw std::runtime_error("Unsupported protobuf policy type");
      }
      d_response.add_uint32(static_cast<protozero::pbf_tag_type>(ResponseField::appliedPolicyType), p);
    }

    void setAppliedPolicyTrigger(const DNSName& trigger)
    {
      encodeDNSName(d_response, d_rspbuf, static_cast<protozero::pbf_tag_type>(ResponseField::appliedPolicyTrigger), trigger);
    }

    void setAppliedPolicyHit(const std::string& hit)
    {
      d_response.add_string(static_cast<protozero::pbf_tag_type>(ResponseField::appliedPolicyHit), hit);
    }

    void setAppliedPolicyKind(const DNSFilterEngine::PolicyKind kind)
    {
      uint32_t k;

      switch (kind) {
      case DNSFilterEngine::PolicyKind::NoAction:
        k = 1;
        break;
      case DNSFilterEngine::PolicyKind::Drop:
        k = 2;
        break;
      case DNSFilterEngine::PolicyKind::NXDOMAIN:
        k = 3;
        break;
      case DNSFilterEngine::PolicyKind::NODATA:
        k = 4;
        break;
      case DNSFilterEngine::PolicyKind::Truncate:
        k = 5;
        break;
      case DNSFilterEngine::PolicyKind::Custom:
        k = 6;
        break;
      default:
        throw std::runtime_error("Unsupported protobuf policy kind");
      }
      d_response.add_uint32(static_cast<protozero::pbf_tag_type>(ResponseField::appliedPolicyKind), k);
    }

    void setValidationState(const vState state)
    {
      uint32_t s;

      switch (state) {
      case vState::Indeterminate:
        s = 1;
        break;
      case vState::Insecure:
        s = 2;
        break;
      case vState::Secure:
        s = 3;
        break;
      case vState::BogusNoValidDNSKEY:
        s = 4;
        break;
      case vState::BogusInvalidDenial:
        s = 5;
        break;
      case vState::BogusUnableToGetDSs:
        s = 6;
        break;
      case vState::BogusUnableToGetDNSKEYs:
        s = 7;
        break;
      case vState::BogusSelfSignedDS:
        s = 8;
        break;
      case vState::BogusNoRRSIG:
        s = 9;
        break;
      case vState::BogusNoValidRRSIG:
        s = 10;
        break;
      case vState::BogusMissingNegativeIndication:
        s = 11;
        break;
      case vState::BogusSignatureNotYetValid:
        s = 12;
        break;
      case vState::BogusSignatureExpired:
        s = 13;
        break;
      case vState::BogusUnsupportedDNSKEYAlgo:
        s = 14;
        break;
      case vState::BogusUnsupportedDSDigestType:
        s = 15;
        break;
      case vState::BogusNoZoneKeyBitSet:
        s = 16;
        break;
      case vState::BogusRevokedDNSKEY:
        s = 17;
        break;
      case vState::BogusInvalidDNSKEYProtocol:
        s = 18;
        break;
      default:
        throw std::runtime_error("Unsupported protobuf validation state");
      }
      d_response.add_uint32(static_cast<protozero::pbf_tag_type>(ResponseField::validationState), s);
    }

#ifdef NOD_ENABLED
    void clearUDR(std::string&);
#endif

  private:
    std::string d_msgbuf;
    std::string d_rspbuf;

#ifdef NOD_ENABLED
    vector<std::string::size_type> offsets;
#endif
  };
};
};

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#pragma once
23
24	#include "protozero.hh"
25
26	#include "filterpo.hh"
27	#include "rec-eventtrace.hh"
28	#include "validate.hh"
29
30	namespace pdns
31	{
32	namespace ProtoZero
33	{
34	class RecMessage : public Message
35	{
36	public:
37	RecMessage() :
38	Message(d_msgbuf)
39	{	3,181✔
40	d_response = protozero::pbf_writer(d_rspbuf);	3,181✔
41	}	3,181✔
42
43	RecMessage(std::string& buffer) :
44	Message(buffer)
45	{	22✔
46	d_response = protozero::pbf_writer(buffer);	22✔
47	}	22✔
48
49	// Start a new messagebuf, containing separate data for the response part
50	RecMessage(std::string::size_type sz1, std::string::size_type sz2) :
51	RecMessage()
52	{	26✔
53	reserve(sz1, sz2);	26✔
54	}	26✔
55
56	// Construct a Message with (partially) constructed content
57	RecMessage(const std::string& buf1, const std::string& buf2, std::string::size_type sz1, std::string::size_type sz2) :
58	Message(d_msgbuf),
59	d_msgbuf{buf1},
60	d_rspbuf{buf2}
61	{	9✔
62	d_message = protozero::pbf_writer(d_msgbuf);	9✔
63	d_response = protozero::pbf_writer(d_rspbuf);	9✔
64	reserve(sz1, sz2);	9✔
65	}	9✔
66	RecMessage(const Message&) = delete;
67	RecMessage(Message&&) = delete;
68	RecMessage& operator=(const Message&) = delete;
69	RecMessage& operator=(Message&&) = delete;
70
71	void reserve(std::string::size_type sz1, std::string::size_type sz2)
72	{	65✔
73	// We expect to grow the buffers, in the end the d_message will contains the (grown) d_response
74	// This is extra space in addition to what's already there
75	// Different from what string.reserve() does
76	std::string::size_type extra = sz1 + d_rspbuf.length() + sz2;	65✔
77	if (d_msgbuf.capacity() < d_msgbuf.size() + extra) {	65!
78	d_message.reserve(extra);	65✔
79	}	65✔
80	if (d_rspbuf.capacity() < d_rspbuf.size() + sz2) {	65✔
81	d_response.reserve(sz2);	44✔
82	}	44✔
83	}	65✔
84
85	const std::string& getMessageBuf() const
86	{	28✔
87	return d_msgbuf;	28✔
88	}	28✔
89
90	const std::string& getResponseBuf() const
91	{	28✔
92	return d_rspbuf;	28✔
93	}	28✔
94
95	[[nodiscard]] size_t size() const
96	{	41✔
97	return d_msgbuf.size() + d_rspbuf.size();	41✔
98	}	41✔
99
100	std::string&& finishAndMoveBuf()
101	{	60✔
102	if (!d_rspbuf.empty()) {	60✔
103	d_message.add_message(static_cast<protozero::pbf_tag_type>(Field::response), d_rspbuf);	39✔
104	}	39✔
105	return std::move(d_msgbuf);	60✔
106	}	60✔
107
108	void addEvents(const RecEventTrace& trace);
109
110	// DNSResponse related fields below
111
112	void addRR(const DNSRecord& record, const std::set<uint16_t>& exportTypes, std::optional<bool> udr);
113
114	void setAppliedPolicyType(const DNSFilterEngine::PolicyType type)
115	{	3✔
116	uint32_t p;	3✔
117
118	switch (type) {	3✔
119	case DNSFilterEngine::PolicyType::None:	×
120	p = 1;	×
121	break;	×
122	case DNSFilterEngine::PolicyType::QName:	2✔
123	p = 2;	2✔
124	break;	2✔
125	case DNSFilterEngine::PolicyType::ClientIP:	×
126	p = 3;	×
127	break;	×
128	case DNSFilterEngine::PolicyType::ResponseIP:	1✔
129	p = 4;	1✔
130	break;	1✔
131	case DNSFilterEngine::PolicyType::NSDName:	×
132	p = 5;	×
133	break;	×
134	case DNSFilterEngine::PolicyType::NSIP:	×
135	p = 6;	×
136	break;	×
137	default:	×
138	throw std::runtime_error("Unsupported protobuf policy type");	×
139	}	3✔
140	d_response.add_uint32(static_cast<protozero::pbf_tag_type>(ResponseField::appliedPolicyType), p);	3✔
141	}	3✔
142
143	void setAppliedPolicyTrigger(const DNSName& trigger)
144	{	3✔
145	encodeDNSName(d_response, d_rspbuf, static_cast<protozero::pbf_tag_type>(ResponseField::appliedPolicyTrigger), trigger);	3✔
146	}	3✔
147
148	void setAppliedPolicyHit(const std::string& hit)
149	{	3✔
150	d_response.add_string(static_cast<protozero::pbf_tag_type>(ResponseField::appliedPolicyHit), hit);	3✔
151	}	3✔
152
153	void setAppliedPolicyKind(const DNSFilterEngine::PolicyKind kind)
154	{	3✔
155	uint32_t k;	3✔
156
157	switch (kind) {	3✔
158	case DNSFilterEngine::PolicyKind::NoAction:	2✔
159	k = 1;	2✔
160	break;	2✔
161	case DNSFilterEngine::PolicyKind::Drop:	×
162	k = 2;	×
163	break;	×
164	case DNSFilterEngine::PolicyKind::NXDOMAIN:	×
165	k = 3;	×
166	break;	×
167	case DNSFilterEngine::PolicyKind::NODATA:	×
168	k = 4;	×
169	break;	×
170	case DNSFilterEngine::PolicyKind::Truncate:	×
171	k = 5;	×
172	break;	×
173	case DNSFilterEngine::PolicyKind::Custom:	1✔
174	k = 6;	1✔
175	break;	1✔
176	default:	×
177	throw std::runtime_error("Unsupported protobuf policy kind");	×
178	}	3✔
179	d_response.add_uint32(static_cast<protozero::pbf_tag_type>(ResponseField::appliedPolicyKind), k);	3✔
180	}	3✔
181
182	void setValidationState(const vState state)
183	{	28✔
184	uint32_t s;	28✔
185
186	switch (state) {	28✔
187	case vState::Indeterminate:	28!
188	s = 1;	28✔
189	break;	28✔
190	case vState::Insecure:	×
191	s = 2;	×
192	break;	×
193	case vState::Secure:	×
194	s = 3;	×
195	break;	×
196	case vState::BogusNoValidDNSKEY:	×
197	s = 4;	×
198	break;	×
199	case vState::BogusInvalidDenial:	×
200	s = 5;	×
201	break;	×
202	case vState::BogusUnableToGetDSs:	×
203	s = 6;	×
204	break;	×
205	case vState::BogusUnableToGetDNSKEYs:	×
206	s = 7;	×
207	break;	×
208	case vState::BogusSelfSignedDS:	×
209	s = 8;	×
210	break;	×
211	case vState::BogusNoRRSIG:	×
212	s = 9;	×
213	break;	×
214	case vState::BogusNoValidRRSIG:	×
215	s = 10;	×
216	break;	×
217	case vState::BogusMissingNegativeIndication:	×
218	s = 11;	×
219	break;	×
220	case vState::BogusSignatureNotYetValid:	×
221	s = 12;	×
222	break;	×
223	case vState::BogusSignatureExpired:	×
224	s = 13;	×
225	break;	×
226	case vState::BogusUnsupportedDNSKEYAlgo:	×
227	s = 14;	×
228	break;	×
229	case vState::BogusUnsupportedDSDigestType:	×
230	s = 15;	×
231	break;	×
232	case vState::BogusNoZoneKeyBitSet:	×
233	s = 16;	×
234	break;	×
235	case vState::BogusRevokedDNSKEY:	×
236	s = 17;	×
237	break;	×
238	case vState::BogusInvalidDNSKEYProtocol:	×
239	s = 18;	×
240	break;	×
241	default:	×
242	throw std::runtime_error("Unsupported protobuf validation state");	×
243	}	28✔
244	d_response.add_uint32(static_cast<protozero::pbf_tag_type>(ResponseField::validationState), s);	28✔
245	}	28✔
246
247	#ifdef NOD_ENABLED
248	void clearUDR(std::string&);
249	#endif
250
251	private:
252	std::string d_msgbuf;
253	std::string d_rspbuf;
254
255	#ifdef NOD_ENABLED
256	vector<std::string::size_type> offsets;
257	#endif
258	};
259	};
260	};

PowerDNS / pdns / 18743945403

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