19012754211

Committed 02 Nov 2025 01:10PM UTC coverage: 90.677% (+0.006%) from 90.671%

Build # 19012754211

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5137 from randombit/jack/clang-tidy-includes

Remove various unused includes flagged by clang-tidy misc-include-cleaner

Run Details

100457 of 110786 relevant lines covered (90.68%)

12189873.8 hits per line

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

83.56

/src/lib/tls/tls_client.cpp

/*
* TLS Client
* (C) 2004-2011,2012,2015,2016 Jack Lloyd
*     2016 Matthias Gierlings
*     2017 Harry Reimann, Rohde & Schwarz Cybersecurity
*     2021 Elektrobit Automotive GmbH
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/tls_client.h>

#include <botan/tls_messages.h>
#include <botan/internal/tls_handshake_state.h>

#include <botan/internal/tls_client_impl_12.h>
#if defined(BOTAN_HAS_TLS_13)
   #include <botan/internal/tls_client_impl_13.h>
#endif

namespace Botan::TLS {

/*
* TLS Client Constructor
*/
Client::Client(const std::shared_ptr<Callbacks>& callbacks,
               const std::shared_ptr<Session_Manager>& session_manager,
               const std::shared_ptr<Credentials_Manager>& creds,
               const std::shared_ptr<const Policy>& policy,
               const std::shared_ptr<RandomNumberGenerator>& rng,
               Server_Information info,
               Protocol_Version offer_version,
               const std::vector<std::string>& next_protocols,
               size_t io_buf_sz) {
   BOTAN_ARG_CHECK(policy->acceptable_protocol_version(offer_version),
                   "Policy does not allow to offer requested protocol version");

#if defined(BOTAN_HAS_TLS_13)
   if(offer_version == Protocol_Version::TLS_V13) {
      m_impl = std::make_unique<Client_Impl_13>(
         callbacks, session_manager, creds, policy, rng, std::move(info), next_protocols);

      if(m_impl->expects_downgrade()) {
         m_impl->set_io_buffer_size(io_buf_sz);
      }

      if(m_impl->is_downgrading()) {
         // TLS 1.3 implementation found a resumable TLS 1.2 session and
         // requested a downgrade right away.
         downgrade();
      }

      return;
   }
#endif

   m_impl = std::make_unique<Client_Impl_12>(callbacks,
                                             session_manager,
                                             creds,
                                             policy,
                                             rng,
                                             std::move(info),
                                             offer_version.is_datagram_protocol(),
                                             next_protocols,
                                             io_buf_sz);
}

Client::~Client() = default;

size_t Client::downgrade() {
   BOTAN_ASSERT_NOMSG(m_impl->is_downgrading());

   auto info = m_impl->extract_downgrade_info();
   m_impl = std::make_unique<Client_Impl_12>(*info);

   if(!info->peer_transcript.empty()) {
      // replay peer data received so far
      return m_impl->from_peer(info->peer_transcript);
   } else {
      // the downgrade happened due to a resumable TLS 1.2 session
      // before any data was transferred
      return 0;
   }
}

size_t Client::from_peer(std::span<const uint8_t> data) {
   auto read = m_impl->from_peer(data);

   if(m_impl->is_downgrading()) {
      read = downgrade();
   }

   return read;
}

bool Client::is_handshake_complete() const {
   return m_impl->is_handshake_complete();
}

bool Client::is_active() const {
   return m_impl->is_active();
}

bool Client::is_closed() const {
   return m_impl->is_closed();
}

bool Client::is_closed_for_reading() const {
   return m_impl->is_closed_for_reading();
}

bool Client::is_closed_for_writing() const {
   return m_impl->is_closed_for_writing();
}

std::vector<X509_Certificate> Client::peer_cert_chain() const {
   return m_impl->peer_cert_chain();
}

std::shared_ptr<const Public_Key> Client::peer_raw_public_key() const {
   return m_impl->peer_raw_public_key();
}

std::optional<std::string> Client::external_psk_identity() const {
   return m_impl->external_psk_identity();
}

SymmetricKey Client::key_material_export(std::string_view label, std::string_view context, size_t length) const {
   return m_impl->key_material_export(label, context, length);
}

void Client::renegotiate(bool force_full_renegotiation) {
   m_impl->renegotiate(force_full_renegotiation);
}

void Client::update_traffic_keys(bool request_peer_update) {
   m_impl->update_traffic_keys(request_peer_update);
}

bool Client::secure_renegotiation_supported() const {
   return m_impl->secure_renegotiation_supported();
}

void Client::to_peer(std::span<const uint8_t> data) {
   m_impl->to_peer(data);
}

void Client::send_alert(const Alert& alert) {
   m_impl->send_alert(alert);
}

void Client::send_warning_alert(Alert::Type type) {
   m_impl->send_warning_alert(type);
}

void Client::send_fatal_alert(Alert::Type type) {
   m_impl->send_fatal_alert(type);
}

void Client::close() {
   m_impl->close();
}

bool Client::timeout_check() {
   return m_impl->timeout_check();
}

std::string Client::application_protocol() const {
   return m_impl->application_protocol();
}

}  // namespace Botan::TLS

1	/*
2	* TLS Client
3	* (C) 2004-2011,2012,2015,2016 Jack Lloyd
4	* 2016 Matthias Gierlings
5	* 2017 Harry Reimann, Rohde & Schwarz Cybersecurity
6	* 2021 Elektrobit Automotive GmbH
7	*
8	* Botan is released under the Simplified BSD License (see license.txt)
9	*/
10
11	#include <botan/tls_client.h>
12
13	#include <botan/tls_messages.h>
14	#include <botan/internal/tls_handshake_state.h>
15
16	#include <botan/internal/tls_client_impl_12.h>
17	#if defined(BOTAN_HAS_TLS_13)
18	#include <botan/internal/tls_client_impl_13.h>
19	#endif
20
21	namespace Botan::TLS {
22
23	/*
24	* TLS Client Constructor
25	*/
26	Client::Client(const std::shared_ptr<Callbacks>& callbacks,	3,651✔
27	const std::shared_ptr<Session_Manager>& session_manager,
28	const std::shared_ptr<Credentials_Manager>& creds,
29	const std::shared_ptr<const Policy>& policy,
30	const std::shared_ptr<RandomNumberGenerator>& rng,
31	Server_Information info,
32	Protocol_Version offer_version,
33	const std::vector<std::string>& next_protocols,
34	size_t io_buf_sz) {	3,651✔
35	BOTAN_ARG_CHECK(policy->acceptable_protocol_version(offer_version),	3,651✔
36	"Policy does not allow to offer requested protocol version");
37
38	#if defined(BOTAN_HAS_TLS_13)
39	if(offer_version == Protocol_Version::TLS_V13) {	3,651✔
40	m_impl = std::make_unique<Client_Impl_13>(	1,104✔
41	callbacks, session_manager, creds, policy, rng, std::move(info), next_protocols);	1,104✔
42
43	if(m_impl->expects_downgrade()) {	1,104✔
44	m_impl->set_io_buffer_size(io_buf_sz);	1,075✔
45	}
46
47	if(m_impl->is_downgrading()) {	1,104✔
48	// TLS 1.3 implementation found a resumable TLS 1.2 session and
49	// requested a downgrade right away.
50	downgrade();	116✔
51	}
52
53	return;	1,104✔
54	}
55	#endif
56
57	m_impl = std::make_unique<Client_Impl_12>(callbacks,	7,641✔
58	session_manager,
59	creds,
60	policy,
61	rng,
62	std::move(info),
63	offer_version.is_datagram_protocol(),	5,094✔
64	next_protocols,
65	io_buf_sz);	2,547✔
66	}	×
67
68	Client::~Client() = default;	5,291✔
69
70	size_t Client::downgrade() {	603✔
71	BOTAN_ASSERT_NOMSG(m_impl->is_downgrading());	603✔
72
73	auto info = m_impl->extract_downgrade_info();	603✔
74	m_impl = std::make_unique<Client_Impl_12>(*info);	1,206✔
75
76	if(!info->peer_transcript.empty()) {	603✔
77	// replay peer data received so far
78	return m_impl->from_peer(info->peer_transcript);	487✔
79	} else {
80	// the downgrade happened due to a resumable TLS 1.2 session
81	// before any data was transferred
82	return 0;
83	}
84	}	603✔
85
86	size_t Client::from_peer(std::span<const uint8_t> data) {	89,499✔
87	auto read = m_impl->from_peer(data);	89,499✔
88
89	if(m_impl->is_downgrading()) {	87,136✔
90	read = downgrade();	487✔
91	}
92
93	return read;	87,041✔
94	}
95
96	bool Client::is_handshake_complete() const {	130✔
97	return m_impl->is_handshake_complete();	130✔
98	}
99
100	bool Client::is_active() const {	2,342✔
101	return m_impl->is_active();	2,342✔
102	}
103
104	bool Client::is_closed() const {	559✔
105	return m_impl->is_closed();	559✔
106	}
107
108	bool Client::is_closed_for_reading() const {	×
109	return m_impl->is_closed_for_reading();	×
110	}
111
112	bool Client::is_closed_for_writing() const {	×
113	return m_impl->is_closed_for_writing();	×
114	}
115
116	std::vector<X509_Certificate> Client::peer_cert_chain() const {	×
117	return m_impl->peer_cert_chain();	×
118	}
119
120	std::shared_ptr<const Public_Key> Client::peer_raw_public_key() const {	1✔
121	return m_impl->peer_raw_public_key();	1✔
122	}
123
124	std::optional<std::string> Client::external_psk_identity() const {	×
125	return m_impl->external_psk_identity();	×
126	}
127
128	SymmetricKey Client::key_material_export(std::string_view label, std::string_view context, size_t length) const {	212✔
129	return m_impl->key_material_export(label, context, length);	212✔
130	}
131
132	void Client::renegotiate(bool force_full_renegotiation) {	×
133	m_impl->renegotiate(force_full_renegotiation);	×
134	}	×
135
136	void Client::update_traffic_keys(bool request_peer_update) {	1✔
137	m_impl->update_traffic_keys(request_peer_update);	1✔
138	}	1✔
139
140	bool Client::secure_renegotiation_supported() const {	11✔
141	return m_impl->secure_renegotiation_supported();	11✔
142	}
143
144	void Client::to_peer(std::span<const uint8_t> data) {	1,766✔
145	m_impl->to_peer(data);	1,766✔
146	}	1,766✔
147
148	void Client::send_alert(const Alert& alert) {	934✔
149	m_impl->send_alert(alert);	934✔
150	}	934✔
151
152	void Client::send_warning_alert(Alert::Type type) {	119✔
153	m_impl->send_warning_alert(type);	119✔
154	}	119✔
155
156	void Client::send_fatal_alert(Alert::Type type) {	16✔
157	m_impl->send_fatal_alert(type);	16✔
158	}	16✔
159
160	void Client::close() {	193✔
161	m_impl->close();	193✔
162	}	193✔
163
164	bool Client::timeout_check() {	46✔
165	return m_impl->timeout_check();	46✔
166	}
167
168	std::string Client::application_protocol() const {	1,188✔
169	return m_impl->application_protocol();	1,188✔
170	}
171
172	} // namespace Botan::TLS

randombit / botan / 19012754211

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