5079590438

Committed 25 May 2023 12:28PM UTC coverage: 92.228% (+0.5%) from 91.723%

Build # 5079590438

Build Type

Pull #3502

github

Pull Request Pull Request #3502: Apply clang-format to the codebase

Run Details

75589 of 81959 relevant lines covered (92.23%)

12139530.51 hits per line

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

85.44

/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 <algorithm>

namespace Botan {

/**
* A node in a SecureQueue
*/
class SecureQueueNode final {
   public:
      SecureQueueNode() : m_buffer(BOTAN_DEFAULT_BUFFER_SIZE) {
         m_next = nullptr;
         m_start = 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;
}

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

   m_head = m_tail = new SecureQueueNode;
   SecureQueueNode* temp = input.m_head;
   while(temp) {
      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) {
      SecureQueueNode* holder = temp->m_next;
      delete temp;
      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;
   SecureQueueNode* temp = input.m_head;
   while(temp) {
      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)
      m_head = m_tail = new SecureQueueNode;
   while(length) {
      const size_t n = m_tail->write(input, length);
      input += n;
      length -= n;
      if(length) {
         m_tail->m_next = new SecureQueueNode;
         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 && m_head) {
      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;
         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 && current) {
      if(offset >= current->size()) {
         offset -= current->size();
         current = current->m_next;
      } else
         break;
   }

   size_t got = 0;
   while(length && current) {
      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) {
      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); }

}

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	#include <algorithm>
11
12	namespace Botan {
13
14	/**
15	* A node in a SecureQueue
16	*/
17	class SecureQueueNode final {
18	public:
19	SecureQueueNode() : m_buffer(BOTAN_DEFAULT_BUFFER_SIZE) {	152✔
20	m_next = nullptr;	76✔
21	m_start = m_end = 0;	76✔
22	}
23
24	~SecureQueueNode() {	76✔
25	m_next = nullptr;	76✔
26	m_start = m_end = 0;	76✔
27	}	76✔
28
29	SecureQueueNode(const SecureQueueNode& other) = delete;
30	SecureQueueNode(SecureQueueNode&& other) = delete;
31	SecureQueueNode& operator=(const SecureQueueNode& other) = delete;
32	SecureQueueNode& operator=(SecureQueueNode&& other) = delete;
33
34	size_t write(const uint8_t input[], size_t length) {	95✔
35	size_t copied = std::min<size_t>(length, m_buffer.size() - m_end);	95✔
36	copy_mem(m_buffer.data() + m_end, input, copied);	95✔
37	m_end += copied;	95✔
38	return copied;	95✔
39	}
40
41	size_t read(uint8_t output[], size_t length) {	70✔
42	size_t copied = std::min(length, m_end - m_start);	70✔
43	copy_mem(output, m_buffer.data() + m_start, copied);	70✔
44	m_start += copied;	70✔
45	return copied;	70✔
46	}
47
48	size_t peek(uint8_t output[], size_t length, size_t offset = 0) {	1✔
49	const size_t left = m_end - m_start;	1✔
50	if(offset >= left)	1✔
51	return 0;
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() {	75✔
70	m_bytes_read = 0;	75✔
71	set_next(nullptr, 0);	75✔
72	m_head = m_tail = new SecureQueueNode;	75✔
73	}	75✔
74
75	/*
76	* Copy a SecureQueue
77	*/
78	SecureQueue::SecureQueue(const SecureQueue& input) : Fanout_Filter(), DataSource() {	×
79	m_bytes_read = 0;	×
80	set_next(nullptr, 0);	×
81
82	m_head = m_tail = new SecureQueueNode;	×
83	SecureQueueNode* temp = input.m_head;	×
84	while(temp) {	×
85	write(&temp->m_buffer[temp->m_start], temp->m_end - temp->m_start);	×
86	temp = temp->m_next;	×
87	}
88	}	×
89
90	/*
91	* Destroy this SecureQueue
92	*/
93	void SecureQueue::destroy() {	76✔
94	SecureQueueNode* temp = m_head;	76✔
95	while(temp) {	85✔
96	SecureQueueNode* holder = temp->m_next;	9✔
97	delete temp;	9✔
98	temp = holder;	9✔
99	}
100	m_head = m_tail = nullptr;	76✔
101	}	76✔
102
103	/*
104	* Copy a SecureQueue
105	*/
106	SecureQueue& SecureQueue::operator=(const SecureQueue& input) {	1✔
107	if(this == &input)	1✔
108	return *this;
109
110	destroy();	1✔
111	m_bytes_read = input.get_bytes_read();	1✔
112	m_head = m_tail = new SecureQueueNode;	1✔
113	SecureQueueNode* temp = input.m_head;	1✔
114	while(temp) {	2✔
115	write(&temp->m_buffer[temp->m_start], temp->m_end - temp->m_start);	1✔
116	temp = temp->m_next;	1✔
117	}
118	return (*this);
119	}
120
121	/*
122	* Add some bytes to the queue
123	*/
124	void SecureQueue::write(const uint8_t input[], size_t length) {	96✔
125	if(!m_head)	96✔
126	m_head = m_tail = new SecureQueueNode;	×
127	while(length) {	191✔
128	const size_t n = m_tail->write(input, length);	95✔
129	input += n;	95✔
130	length -= n;	95✔
131	if(length) {	95✔
132	m_tail->m_next = new SecureQueueNode;	×
133	m_tail = m_tail->m_next;	×
134	}
135	}
136	}	96✔
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 && m_head) {	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;	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 && current) {	1✔
165	if(offset >= current->size()) {	1✔
166	offset -= current->size();	×
167	current = current->m_next;	×
168	} else
169	break;
170	}
171
172	size_t got = 0;
173	while(length && current) {	2✔
174	const size_t n = current->peek(output, length, offset);	1✔
175	offset = 0;	1✔
176	output += n;	1✔
177	got += n;	1✔
178	length -= n;	1✔
179	current = current->m_next;	1✔
180	}
181	return got;	1✔
182	}
183
184	/**
185	* Return how many bytes have been read so far.
186	*/
187	size_t SecureQueue::get_bytes_read() const { return m_bytes_read; }	12✔
188
189	/*
190	* Return how many bytes the queue holds
191	*/
192	size_t SecureQueue::size() const {	354✔
193	SecureQueueNode* current = m_head;	354✔
194	size_t count = 0;	354✔
195
196	while(current) {	685✔
197	count += current->size();	331✔
198	current = current->m_next;	331✔
199	}
200	return count;	354✔
201	}
202
203	/*
204	* Test if the queue has any data in it
205	*/
206	bool SecureQueue::end_of_data() const { return (size() == 0); }	×
207
208	bool SecureQueue::empty() const { return (size() == 0); }	275✔
209
210	}

randombit / botan / 5079590438

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