16250409945

Committed 13 Jul 2025 02:59PM UTC coverage: 90.617% (-0.003%) from 90.62%

Build # 16250409945

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4985 from randombit/jack/fix-clang-tidy-cppcoreguidelines-prefer-member-initializer

Enable and fix clang-tidy warning cppcoreguidelines-prefer-member-initializer

Run Details

99526 of 109831 relevant lines covered (90.62%)

12277545.17 hits per line

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

85.29

/src/lib/filters/secqueue.cpp

/*
* SecureQueue
* (C) 1999-2007 Jack Lloyd
*     2012 Markus Wanner
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/internal/secqueue.h>

#include <botan/mem_ops.h>
#include <algorithm>

namespace Botan {

/**
* A node in a SecureQueue
*/
class SecureQueueNode final {
   public:
      SecureQueueNode() : m_next(nullptr), m_buffer(DefaultBufferSize), m_start(0), m_end(0) {}

      ~SecureQueueNode() {
         m_next = nullptr;
         m_start = m_end = 0;
      }

      SecureQueueNode(const SecureQueueNode& other) = delete;
      SecureQueueNode(SecureQueueNode&& other) = delete;
      SecureQueueNode& operator=(const SecureQueueNode& other) = delete;
      SecureQueueNode& operator=(SecureQueueNode&& other) = delete;

      size_t write(const uint8_t input[], size_t length) {
         size_t copied = std::min<size_t>(length, m_buffer.size() - m_end);
         copy_mem(m_buffer.data() + m_end, input, copied);
         m_end += copied;
         return copied;
      }

      size_t read(uint8_t output[], size_t length) {
         size_t copied = std::min(length, m_end - m_start);
         copy_mem(output, m_buffer.data() + m_start, copied);
         m_start += copied;
         return copied;
      }

      size_t peek(uint8_t output[], size_t length, size_t offset = 0) {
         const size_t left = m_end - m_start;
         if(offset >= left) {
            return 0;
         }
         size_t copied = std::min(length, left - offset);
         copy_mem(output, m_buffer.data() + m_start + offset, copied);
         return copied;
      }

      size_t size() const { return (m_end - m_start); }

   private:
      friend class SecureQueue;
      SecureQueueNode* m_next;
      secure_vector<uint8_t> m_buffer;
      size_t m_start, m_end;
};

/*
* Create a SecureQueue
*/
SecureQueue::SecureQueue() : m_bytes_read(0) {
   set_next(nullptr, 0);
   m_head = m_tail = new SecureQueueNode;  // NOLINT(*-owning-memory)
}

/*
* Copy a SecureQueue
*/
SecureQueue::SecureQueue(const SecureQueue& input) : Fanout_Filter(), m_bytes_read(0) {
   set_next(nullptr, 0);

   m_head = m_tail = new SecureQueueNode;  // NOLINT(*-owning-memory)
   SecureQueueNode* temp = input.m_head;
   while(temp != nullptr) {
      write(&temp->m_buffer[temp->m_start], temp->m_end - temp->m_start);
      temp = temp->m_next;
   }
}

/*
* Destroy this SecureQueue
*/
void SecureQueue::destroy() {
   SecureQueueNode* temp = m_head;
   while(temp != nullptr) {
      SecureQueueNode* holder = temp->m_next;
      delete temp;  // NOLINT(*-owning-memory)
      temp = holder;
   }
   m_head = m_tail = nullptr;
}

/*
* Copy a SecureQueue
*/
SecureQueue& SecureQueue::operator=(const SecureQueue& input) {
   if(this == &input) {
      return *this;
   }

   destroy();
   m_bytes_read = input.get_bytes_read();
   m_head = m_tail = new SecureQueueNode;  // NOLINT(*-owning-memory)
   SecureQueueNode* temp = input.m_head;
   while(temp != nullptr) {
      write(&temp->m_buffer[temp->m_start], temp->m_end - temp->m_start);
      temp = temp->m_next;
   }
   return (*this);
}

/*
* Add some bytes to the queue
*/
void SecureQueue::write(const uint8_t input[], size_t length) {
   if(m_head == nullptr) {
      m_head = m_tail = new SecureQueueNode;  // NOLINT(*-owning-memory)
   }
   while(length > 0) {
      const size_t n = m_tail->write(input, length);
      input += n;
      length -= n;
      if(length > 0) {
         m_tail->m_next = new SecureQueueNode;  // NOLINT(*-owning-memory)
         m_tail = m_tail->m_next;
      }
   }
}

/*
* Read some bytes from the queue
*/
size_t SecureQueue::read(uint8_t output[], size_t length) {
   size_t got = 0;
   while(length > 0 && m_head != nullptr) {
      const size_t n = m_head->read(output, length);
      output += n;
      got += n;
      length -= n;
      if(m_head->size() == 0) {
         SecureQueueNode* holder = m_head->m_next;
         delete m_head;  // NOLINT(*-owning-memory)
         m_head = holder;
      }
   }
   m_bytes_read += got;
   return got;
}

/*
* Read data, but do not remove it from queue
*/
size_t SecureQueue::peek(uint8_t output[], size_t length, size_t offset) const {
   SecureQueueNode* current = m_head;

   while(offset > 0 && current != nullptr) {
      if(offset >= current->size()) {
         offset -= current->size();
         current = current->m_next;
      } else {
         break;
      }
   }

   size_t got = 0;
   while(length > 0 && current != nullptr) {
      const size_t n = current->peek(output, length, offset);
      offset = 0;
      output += n;
      got += n;
      length -= n;
      current = current->m_next;
   }
   return got;
}

/**
* Return how many bytes have been read so far.
*/
size_t SecureQueue::get_bytes_read() const {
   return m_bytes_read;
}

/*
* Return how many bytes the queue holds
*/
size_t SecureQueue::size() const {
   SecureQueueNode* current = m_head;
   size_t count = 0;

   while(current != nullptr) {
      count += current->size();
      current = current->m_next;
   }
   return count;
}

/*
* Test if the queue has any data in it
*/
bool SecureQueue::end_of_data() const {
   return (size() == 0);
}

bool SecureQueue::empty() const {
   return (size() == 0);
}

}  // namespace Botan

1	/*
2	* SecureQueue
3	* (C) 1999-2007 Jack Lloyd
4	* 2012 Markus Wanner
5	*
6	* Botan is released under the Simplified BSD License (see license.txt)
7	*/
8
9	#include <botan/internal/secqueue.h>
10
11	#include <botan/mem_ops.h>
12	#include <algorithm>
13
14	namespace Botan {
15
16	/**
17	* A node in a SecureQueue
18	*/
19	class SecureQueueNode final {
20	public:
21	SecureQueueNode() : m_next(nullptr), m_buffer(DefaultBufferSize), m_start(0), m_end(0) {}	152✔
22
23	~SecureQueueNode() {	76✔
24	m_next = nullptr;	76✔
25	m_start = m_end = 0;	76✔
26	}	76✔
27
28	SecureQueueNode(const SecureQueueNode& other) = delete;
29	SecureQueueNode(SecureQueueNode&& other) = delete;
30	SecureQueueNode& operator=(const SecureQueueNode& other) = delete;
31	SecureQueueNode& operator=(SecureQueueNode&& other) = delete;
32
33	size_t write(const uint8_t input[], size_t length) {	93✔
34	size_t copied = std::min<size_t>(length, m_buffer.size() - m_end);	93✔
35	copy_mem(m_buffer.data() + m_end, input, copied);	93✔
36	m_end += copied;	93✔
37	return copied;	93✔
38	}
39
40	size_t read(uint8_t output[], size_t length) {	70✔
41	size_t copied = std::min(length, m_end - m_start);	70✔
42	copy_mem(output, m_buffer.data() + m_start, copied);	70✔
43	m_start += copied;	70✔
44	return copied;	70✔
45	}
46
47	size_t peek(uint8_t output[], size_t length, size_t offset = 0) {	1✔
48	const size_t left = m_end - m_start;	1✔
49	if(offset >= left) {	1✔
50	return 0;
51	}
52	size_t copied = std::min(length, left - offset);	1✔
53	copy_mem(output, m_buffer.data() + m_start + offset, copied);	1✔
54	return copied;	1✔
55	}
56
57	size_t size() const { return (m_end - m_start); }	402✔
58
59	private:
60	friend class SecureQueue;
61	SecureQueueNode* m_next;
62	secure_vector<uint8_t> m_buffer;
63	size_t m_start, m_end;
64	};
65
66	/*
67	* Create a SecureQueue
68	*/
69	SecureQueue::SecureQueue() : m_bytes_read(0) {	75✔
70	set_next(nullptr, 0);	75✔
71	m_head = m_tail = new SecureQueueNode; // NOLINT(*-owning-memory)	75✔
72	}	75✔
73
74	/*
75	* Copy a SecureQueue
76	*/
77	SecureQueue::SecureQueue(const SecureQueue& input) : Fanout_Filter(), m_bytes_read(0) {	×
78	set_next(nullptr, 0);	×
79
80	m_head = m_tail = new SecureQueueNode; // NOLINT(*-owning-memory)	×
81	SecureQueueNode* temp = input.m_head;	×
82	while(temp != nullptr) {	×
83	write(&temp->m_buffer[temp->m_start], temp->m_end - temp->m_start);	×
84	temp = temp->m_next;	×
85	}
86	}	×
87
88	/*
89	* Destroy this SecureQueue
90	*/
91	void SecureQueue::destroy() {	76✔
92	SecureQueueNode* temp = m_head;	76✔
93	while(temp != nullptr) {	85✔
94	SecureQueueNode* holder = temp->m_next;	9✔
95	delete temp; // NOLINT(*-owning-memory)	9✔
96	temp = holder;	9✔
97	}
98	m_head = m_tail = nullptr;	76✔
99	}	76✔
100
101	/*
102	* Copy a SecureQueue
103	*/
104	SecureQueue& SecureQueue::operator=(const SecureQueue& input) {	1✔
105	if(this == &input) {	1✔
106	return *this;
107	}
108
109	destroy();	1✔
110	m_bytes_read = input.get_bytes_read();	1✔
111	m_head = m_tail = new SecureQueueNode; // NOLINT(*-owning-memory)	1✔
112	SecureQueueNode* temp = input.m_head;	1✔
113	while(temp != nullptr) {	2✔
114	write(&temp->m_buffer[temp->m_start], temp->m_end - temp->m_start);	1✔
115	temp = temp->m_next;	1✔
116	}
117	return (*this);
118	}
119
120	/*
121	* Add some bytes to the queue
122	*/
123	void SecureQueue::write(const uint8_t input[], size_t length) {	94✔
124	if(m_head == nullptr) {	94✔
125	m_head = m_tail = new SecureQueueNode; // NOLINT(*-owning-memory)	×
126	}
127	while(length > 0) {	94✔
128	const size_t n = m_tail->write(input, length);	93✔
129	input += n;	93✔
130	length -= n;	93✔
131	if(length > 0) {	93✔
132	m_tail->m_next = new SecureQueueNode; // NOLINT(*-owning-memory)	×
133	m_tail = m_tail->m_next;	×
134	}
135	}
136	}	94✔
137
138	/*
139	* Read some bytes from the queue
140	*/
141	size_t SecureQueue::read(uint8_t output[], size_t length) {	117✔
142	size_t got = 0;	117✔
143	while(length > 0 && m_head != nullptr) {	187✔
144	const size_t n = m_head->read(output, length);	70✔
145	output += n;	70✔
146	got += n;	70✔
147	length -= n;	70✔
148	if(m_head->size() == 0) {	70✔
149	SecureQueueNode* holder = m_head->m_next;	67✔
150	delete m_head; // NOLINT(*-owning-memory)	67✔
151	m_head = holder;	67✔
152	}
153	}
154	m_bytes_read += got;	117✔
155	return got;	117✔
156	}
157
158	/*
159	* Read data, but do not remove it from queue
160	*/
161	size_t SecureQueue::peek(uint8_t output[], size_t length, size_t offset) const {	1✔
162	SecureQueueNode* current = m_head;	1✔
163
164	while(offset > 0 && current != nullptr) {	1✔
165	if(offset >= current->size()) {	1✔
166	offset -= current->size();	×
167	current = current->m_next;	×
168	} else {
169	break;
170	}
171	}
172
173	size_t got = 0;
174	while(length > 0 && current != nullptr) {	2✔
175	const size_t n = current->peek(output, length, offset);	1✔
176	offset = 0;	1✔
177	output += n;	1✔
178	got += n;	1✔
179	length -= n;	1✔
180	current = current->m_next;	1✔
181	}
182	return got;	1✔
183	}
184
185	/**
186	* Return how many bytes have been read so far.
187	*/
188	size_t SecureQueue::get_bytes_read() const {	12✔
189	return m_bytes_read;	12✔
190	}
191
192	/*
193	* Return how many bytes the queue holds
194	*/
195	size_t SecureQueue::size() const {	354✔
196	SecureQueueNode* current = m_head;	354✔
197	size_t count = 0;	354✔
198
199	while(current != nullptr) {	685✔
200	count += current->size();	331✔
201	current = current->m_next;	331✔
202	}
203	return count;	354✔
204	}
205
206	/*
207	* Test if the queue has any data in it
208	*/
209	bool SecureQueue::end_of_data() const {	×
210	return (size() == 0);	×
211	}
212
213	bool SecureQueue::empty() const {	275✔
214	return (size() == 0);	275✔
215	}
216
217	} // namespace Botan

randombit / botan / 16250409945

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