13274522654

Committed 11 Feb 2025 11:26PM UTC coverage: 91.645% (-0.007%) from 91.652%

Build # 13274522654

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4647 from randombit/jack/internal-assert-and-mem-ops

Avoid using mem_ops.h or assert.h in public headers

Run Details

94854 of 103501 relevant lines covered (91.65%)

11334975.77 hits per line

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

87.72

/src/lib/filters/comp_filter.cpp

/*
* Filter interface for compression
* (C) 2014,2015,2016 Jack Lloyd
* (C) 2015 Matej Kenda
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/filters.h>

#include <botan/assert.h>
#include <botan/exceptn.h>
#include <botan/internal/fmt.h>

#if defined(BOTAN_HAS_COMPRESSION)
   #include <botan/compression.h>
#endif

namespace Botan {

#if defined(BOTAN_HAS_COMPRESSION)

Compression_Filter::Compression_Filter(std::string_view type, size_t level, size_t bs) :
      m_comp(Compression_Algorithm::create(type)), m_buffersize(std::max<size_t>(bs, 256)), m_level(level) {
   if(!m_comp) {
      throw Invalid_Argument(fmt("Compression type '{}' not found", type));
   }
}

Compression_Filter::~Compression_Filter() = default;

std::string Compression_Filter::name() const {
   return m_comp->name();
}

void Compression_Filter::start_msg() {
   m_comp->start(m_level);
}

void Compression_Filter::write(const uint8_t input[], size_t input_length) {
   while(input_length) {
      const size_t take = std::min(m_buffersize, input_length);
      BOTAN_ASSERT(take > 0, "Consumed something");

      m_buffer.assign(input, input + take);
      m_comp->update(m_buffer);

      send(m_buffer);

      input += take;
      input_length -= take;
   }
}

void Compression_Filter::flush() {
   m_buffer.clear();
   m_comp->update(m_buffer, 0, true);
   send(m_buffer);
}

void Compression_Filter::end_msg() {
   m_buffer.clear();
   m_comp->finish(m_buffer);
   send(m_buffer);
}

Decompression_Filter::Decompression_Filter(std::string_view type, size_t bs) :
      m_comp(Decompression_Algorithm::create(type)), m_buffersize(std::max<size_t>(bs, 256)) {
   if(!m_comp) {
      throw Invalid_Argument(fmt("Compression type '{}' not found", type));
   }
}

Decompression_Filter::~Decompression_Filter() = default;

std::string Decompression_Filter::name() const {
   return m_comp->name();
}

void Decompression_Filter::start_msg() {
   m_comp->start();
}

void Decompression_Filter::write(const uint8_t input[], size_t input_length) {
   while(input_length) {
      const size_t take = std::min(m_buffersize, input_length);
      BOTAN_ASSERT(take > 0, "Consumed something");

      m_buffer.assign(input, input + take);
      m_comp->update(m_buffer);

      send(m_buffer);

      input += take;
      input_length -= take;
   }
}

void Decompression_Filter::end_msg() {
   m_buffer.clear();
   m_comp->finish(m_buffer);
   send(m_buffer);
}

#endif

}  // namespace Botan

1	/*
2	* Filter interface for compression
3	* (C) 2014,2015,2016 Jack Lloyd
4	* (C) 2015 Matej Kenda
5	*
6	* Botan is released under the Simplified BSD License (see license.txt)
7	*/
8
9	#include <botan/filters.h>
10
11	#include <botan/assert.h>
12	#include <botan/exceptn.h>
13	#include <botan/internal/fmt.h>
14
15	#if defined(BOTAN_HAS_COMPRESSION)
16	#include <botan/compression.h>
17	#endif
18
19	namespace Botan {
20
21	#if defined(BOTAN_HAS_COMPRESSION)
22
23	Compression_Filter::Compression_Filter(std::string_view type, size_t level, size_t bs) :	2✔
24	m_comp(Compression_Algorithm::create(type)), m_buffersize(std::max<size_t>(bs, 256)), m_level(level) {	2✔
25	if(!m_comp) {	2✔
26	throw Invalid_Argument(fmt("Compression type '{}' not found", type));	×
27	}
28	}	2✔
29
30	Compression_Filter::~Compression_Filter() = default;	8✔
31
32	std::string Compression_Filter::name() const {	2✔
33	return m_comp->name();	2✔
34	}
35
36	void Compression_Filter::start_msg() {	2✔
37	m_comp->start(m_level);	2✔
38	}	2✔
39
40	void Compression_Filter::write(const uint8_t input[], size_t input_length) {	2✔
41	while(input_length) {	4✔
42	const size_t take = std::min(m_buffersize, input_length);	2✔
43	BOTAN_ASSERT(take > 0, "Consumed something");	2✔
44
45	m_buffer.assign(input, input + take);	2✔
46	m_comp->update(m_buffer);	2✔
47
48	send(m_buffer);	2✔
49
50	input += take;	2✔
51	input_length -= take;	2✔
52	}
53	}	2✔
54
55	void Compression_Filter::flush() {	×
56	m_buffer.clear();	×
57	m_comp->update(m_buffer, 0, true);	×
58	send(m_buffer);	×
59	}	×
60
61	void Compression_Filter::end_msg() {	2✔
62	m_buffer.clear();	2✔
63	m_comp->finish(m_buffer);	2✔
64	send(m_buffer);	2✔
65	}	2✔
66
67	Decompression_Filter::Decompression_Filter(std::string_view type, size_t bs) :	2✔
68	m_comp(Decompression_Algorithm::create(type)), m_buffersize(std::max<size_t>(bs, 256)) {	2✔
69	if(!m_comp) {	2✔
70	throw Invalid_Argument(fmt("Compression type '{}' not found", type));	×
71	}
72	}	2✔
73
74	Decompression_Filter::~Decompression_Filter() = default;	8✔
75
76	std::string Decompression_Filter::name() const {	2✔
77	return m_comp->name();	2✔
78	}
79
80	void Decompression_Filter::start_msg() {	2✔
81	m_comp->start();	2✔
82	}	2✔
83
84	void Decompression_Filter::write(const uint8_t input[], size_t input_length) {	2✔
85	while(input_length) {	4✔
86	const size_t take = std::min(m_buffersize, input_length);	2✔
87	BOTAN_ASSERT(take > 0, "Consumed something");	2✔
88
89	m_buffer.assign(input, input + take);	2✔
90	m_comp->update(m_buffer);	2✔
91
92	send(m_buffer);	2✔
93
94	input += take;	2✔
95	input_length -= take;	2✔
96	}
97	}	2✔
98
99	void Decompression_Filter::end_msg() {	2✔
100	m_buffer.clear();	2✔
101	m_comp->finish(m_buffer);	2✔
102	send(m_buffer);	2✔
103	}	2✔
104
105	#endif
106
107	} // namespace Botan

randombit / botan / 13274522654

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