5123321399

Committed 30 May 2023 04:06PM UTC coverage: 92.213% (+0.004%) from 92.209%

Build # 5123321399

Build Type

Pull #3558

github

Committed by

web-flow

Commit Message

Merge dd72f7389 into 057bcbc35

Pull Request Pull Request #3558: Add braces around all if/else statements

Run Details

75602 of 81986 relevant lines covered (92.21%)

11859779.3 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); }

}  // 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	#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	}
53	size_t copied = std::min(length, left - offset);	1✔
54	copy_mem(output, m_buffer.data() + m_start + offset, copied);	1✔
55	return copied;	1✔
56	}
57
58	size_t size() const { return (m_end - m_start); }	402✔
59
60	private:
61	friend class SecureQueue;
62	SecureQueueNode* m_next;
63	secure_vector<uint8_t> m_buffer;
64	size_t m_start, m_end;
65	};
66
67	/*
68	* Create a SecureQueue
69	*/
70	SecureQueue::SecureQueue() {	75✔
71	m_bytes_read = 0;	75✔
72	set_next(nullptr, 0);	75✔
73	m_head = m_tail = new SecureQueueNode;	75✔
74	}	75✔
75
76	/*
77	* Copy a SecureQueue
78	*/
79	SecureQueue::SecureQueue(const SecureQueue& input) : Fanout_Filter(), DataSource() {	×
80	m_bytes_read = 0;	×
81	set_next(nullptr, 0);	×
82
83	m_head = m_tail = new SecureQueueNode;	×
84	SecureQueueNode* temp = input.m_head;	×
85	while(temp) {	×
86	write(&temp->m_buffer[temp->m_start], temp->m_end - temp->m_start);	×
87	temp = temp->m_next;	×
88	}
89	}	×
90
91	/*
92	* Destroy this SecureQueue
93	*/
94	void SecureQueue::destroy() {	76✔
95	SecureQueueNode* temp = m_head;	76✔
96	while(temp) {	85✔
97	SecureQueueNode* holder = temp->m_next;	9✔
98	delete temp;	9✔
99	temp = holder;	9✔
100	}
101	m_head = m_tail = nullptr;	76✔
102	}	76✔
103
104	/*
105	* Copy a SecureQueue
106	*/
107	SecureQueue& SecureQueue::operator=(const SecureQueue& input) {	1✔
108	if(this == &input) {	1✔
109	return *this;
110	}
111
112	destroy();	1✔
113	m_bytes_read = input.get_bytes_read();	1✔
114	m_head = m_tail = new SecureQueueNode;	1✔
115	SecureQueueNode* temp = input.m_head;	1✔
116	while(temp) {	2✔
117	write(&temp->m_buffer[temp->m_start], temp->m_end - temp->m_start);	1✔
118	temp = temp->m_next;	1✔
119	}
120	return (*this);
121	}
122
123	/*
124	* Add some bytes to the queue
125	*/
126	void SecureQueue::write(const uint8_t input[], size_t length) {	96✔
127	if(!m_head) {	96✔
128	m_head = m_tail = new SecureQueueNode;	×
129	}
130	while(length) {	191✔
131	const size_t n = m_tail->write(input, length);	95✔
132	input += n;	95✔
133	length -= n;	95✔
134	if(length) {	95✔
135	m_tail->m_next = new SecureQueueNode;	×
136	m_tail = m_tail->m_next;	×
137	}
138	}
139	}	96✔
140
141	/*
142	* Read some bytes from the queue
143	*/
144	size_t SecureQueue::read(uint8_t output[], size_t length) {	117✔
145	size_t got = 0;	117✔
146	while(length && m_head) {	187✔
147	const size_t n = m_head->read(output, length);	70✔
148	output += n;	70✔
149	got += n;	70✔
150	length -= n;	70✔
151	if(m_head->size() == 0) {	70✔
152	SecureQueueNode* holder = m_head->m_next;	67✔
153	delete m_head;	67✔
154	m_head = holder;	67✔
155	}
156	}
157	m_bytes_read += got;	117✔
158	return got;	117✔
159	}
160
161	/*
162	* Read data, but do not remove it from queue
163	*/
164	size_t SecureQueue::peek(uint8_t output[], size_t length, size_t offset) const {	1✔
165	SecureQueueNode* current = m_head;	1✔
166
167	while(offset && current) {	1✔
168	if(offset >= current->size()) {	1✔
169	offset -= current->size();	×
170	current = current->m_next;	×
171	} else {
172	break;
173	}
174	}
175
176	size_t got = 0;
177	while(length && current) {	2✔
178	const size_t n = current->peek(output, length, offset);	1✔
179	offset = 0;	1✔
180	output += n;	1✔
181	got += n;	1✔
182	length -= n;	1✔
183	current = current->m_next;	1✔
184	}
185	return got;	1✔
186	}
187
188	/**
189	* Return how many bytes have been read so far.
190	*/
191	size_t SecureQueue::get_bytes_read() const { return m_bytes_read; }	12✔
192
193	/*
194	* Return how many bytes the queue holds
195	*/
196	size_t SecureQueue::size() const {	354✔
197	SecureQueueNode* current = m_head;	354✔
198	size_t count = 0;	354✔
199
200	while(current) {	685✔
201	count += current->size();	331✔
202	current = current->m_next;	331✔
203	}
204	return count;	354✔
205	}
206
207	/*
208	* Test if the queue has any data in it
209	*/
210	bool SecureQueue::end_of_data() const { return (size() == 0); }	×
211
212	bool SecureQueue::empty() const { return (size() == 0); }	275✔
213
214	} // namespace Botan

randombit / botan / 5123321399

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