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

91.94

/src/lib/compression/zlib/zlib.cpp

/*
* Zlib Compressor
* (C) 2001 Peter J Jones
*     2001-2007,2014 Jack Lloyd
*     2006 Matt Johnston
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/zlib.h>

#include <botan/exceptn.h>
#include <botan/internal/compress_utils.h>
#include <zlib.h>

namespace Botan {

namespace {

class Zlib_Stream : public Zlib_Style_Stream<z_stream, Bytef, unsigned int> {
   public:
      Zlib_Stream() {
         streamp()->opaque = alloc();
         streamp()->zalloc = Compression_Alloc_Info::malloc<unsigned int>;
         streamp()->zfree = Compression_Alloc_Info::free;
      }

      uint32_t run_flag() const override { return Z_NO_FLUSH; }

      uint32_t flush_flag() const override { return Z_SYNC_FLUSH; }

      uint32_t finish_flag() const override { return Z_FINISH; }

      int compute_window_bits(int wbits, int wbits_offset) const {
         if(wbits_offset == -1)
            return -wbits;
         else
            return wbits + wbits_offset;
      }
};

class Zlib_Compression_Stream : public Zlib_Stream {
   public:
      Zlib_Compression_Stream(size_t level, int wbits, int wbits_offset = 0) {
         wbits = compute_window_bits(wbits, wbits_offset);

         if(level >= 9)
            level = 9;
         else if(level == 0)
            level = 6;

         int rc = ::deflateInit2(streamp(), static_cast<int>(level), Z_DEFLATED, wbits, 8, Z_DEFAULT_STRATEGY);

         if(rc != Z_OK)
            throw Compression_Error("deflateInit2", ErrorType::ZlibError, rc);
      }

      ~Zlib_Compression_Stream() { ::deflateEnd(streamp()); }

      bool run(uint32_t flags) override {
         int rc = ::deflate(streamp(), flags);

         if(rc != Z_OK && rc != Z_STREAM_END && rc != Z_BUF_ERROR)
            throw Compression_Error("zlib deflate", ErrorType::ZlibError, rc);

         return (rc == Z_STREAM_END);
      }
};

class Zlib_Decompression_Stream : public Zlib_Stream {
   public:
      Zlib_Decompression_Stream(int wbits, int wbits_offset = 0) {
         int rc = ::inflateInit2(streamp(), compute_window_bits(wbits, wbits_offset));

         if(rc != Z_OK)
            throw Compression_Error("inflateInit2", ErrorType::ZlibError, rc);
      }

      ~Zlib_Decompression_Stream() { ::inflateEnd(streamp()); }

      bool run(uint32_t flags) override {
         int rc = ::inflate(streamp(), flags);

         if(rc != Z_OK && rc != Z_STREAM_END && rc != Z_BUF_ERROR)
            throw Compression_Error("zlib inflate", ErrorType::ZlibError, rc);

         return (rc == Z_STREAM_END);
      }
};

class Deflate_Compression_Stream final : public Zlib_Compression_Stream {
   public:
      Deflate_Compression_Stream(size_t level, int wbits) : Zlib_Compression_Stream(level, wbits, -1) {}
};

class Deflate_Decompression_Stream final : public Zlib_Decompression_Stream {
   public:
      explicit Deflate_Decompression_Stream(int wbits) : Zlib_Decompression_Stream(wbits, -1) {}
};

class Gzip_Compression_Stream final : public Zlib_Compression_Stream {
   public:
      Gzip_Compression_Stream(size_t level, int wbits, uint8_t os_code, uint64_t hdr_time) :
            Zlib_Compression_Stream(level, wbits, 16) {
         clear_mem(&m_header, 1);
         m_header.os = os_code;
         m_header.time = static_cast<uLong>(hdr_time);

         int rc = deflateSetHeader(streamp(), &m_header);
         if(rc != Z_OK)
            throw Compression_Error("deflateSetHeader", ErrorType::ZlibError, rc);
      }

   private:
      ::gz_header m_header;
};

class Gzip_Decompression_Stream final : public Zlib_Decompression_Stream {
   public:
      explicit Gzip_Decompression_Stream(int wbits) : Zlib_Decompression_Stream(wbits, 16) {}
};

}

std::unique_ptr<Compression_Stream> Zlib_Compression::make_stream(size_t level) const {
   return std::make_unique<Zlib_Compression_Stream>(level, 15);
}

std::unique_ptr<Compression_Stream> Zlib_Decompression::make_stream() const {
   return std::make_unique<Zlib_Decompression_Stream>(15);
}

std::unique_ptr<Compression_Stream> Deflate_Compression::make_stream(size_t level) const {
   return std::make_unique<Deflate_Compression_Stream>(level, 15);
}

std::unique_ptr<Compression_Stream> Deflate_Decompression::make_stream() const {
   return std::make_unique<Deflate_Decompression_Stream>(15);
}

std::unique_ptr<Compression_Stream> Gzip_Compression::make_stream(size_t level) const {
   return std::make_unique<Gzip_Compression_Stream>(level, 15, m_os_code, m_hdr_time);
}

std::unique_ptr<Compression_Stream> Gzip_Decompression::make_stream() const {
   return std::make_unique<Gzip_Decompression_Stream>(15);
}

}

1	/*
2	* Zlib Compressor
3	* (C) 2001 Peter J Jones
4	* 2001-2007,2014 Jack Lloyd
5	* 2006 Matt Johnston
6	*
7	* Botan is released under the Simplified BSD License (see license.txt)
8	*/
9
10	#include <botan/zlib.h>
11
12	#include <botan/exceptn.h>
13	#include <botan/internal/compress_utils.h>
14	#include <zlib.h>
15
16	namespace Botan {
17
18	namespace {
19
20	class Zlib_Stream : public Zlib_Style_Stream<z_stream, Bytef, unsigned int> {	57✔
21	public:
22	Zlib_Stream() {	139✔
23	streamp()->opaque = alloc();	139✔
24	streamp()->zalloc = Compression_Alloc_Info::malloc<unsigned int>;	139✔
25	streamp()->zfree = Compression_Alloc_Info::free;	139✔
26	}
27
28	uint32_t run_flag() const override { return Z_NO_FLUSH; }	228✔
29
30	uint32_t flush_flag() const override { return Z_SYNC_FLUSH; }	30✔
31
32	uint32_t finish_flag() const override { return Z_FINISH; }	77✔
33
34	int compute_window_bits(int wbits, int wbits_offset) const {	139✔
35	if(wbits_offset == -1)	139✔
36	return -wbits;	40✔
37	else
38	return wbits + wbits_offset;	99✔
39	}
40	};
41
42	class Zlib_Compression_Stream : public Zlib_Stream {
43	public:
44	Zlib_Compression_Stream(size_t level, int wbits, int wbits_offset = 0) {	77✔
45	wbits = compute_window_bits(wbits, wbits_offset);	77✔
46
47	if(level >= 9)	77✔
48	level = 9;
49	else if(level == 0)	35✔
50	level = 6;	4✔
51
52	int rc = ::deflateInit2(streamp(), static_cast<int>(level), Z_DEFLATED, wbits, 8, Z_DEFAULT_STRATEGY);	77✔
53
54	if(rc != Z_OK)	77✔
55	throw Compression_Error("deflateInit2", ErrorType::ZlibError, rc);	×
56	}	77✔
57
58	~Zlib_Compression_Stream() { ::deflateEnd(streamp()); }	36✔
59
60	bool run(uint32_t flags) override {	202✔
61	int rc = ::deflate(streamp(), flags);	202✔
62
63	if(rc != Z_OK && rc != Z_STREAM_END && rc != Z_BUF_ERROR)	202✔
64	throw Compression_Error("zlib deflate", ErrorType::ZlibError, rc);	×
65
66	return (rc == Z_STREAM_END);	202✔
67	}
68	};
69
70	class Zlib_Decompression_Stream : public Zlib_Stream {
71	public:
72	Zlib_Decompression_Stream(int wbits, int wbits_offset = 0) {	62✔
73	int rc = ::inflateInit2(streamp(), compute_window_bits(wbits, wbits_offset));	124✔
74
75	if(rc != Z_OK)	62✔
76	throw Compression_Error("inflateInit2", ErrorType::ZlibError, rc);	×
77	}	62✔
78
79	~Zlib_Decompression_Stream() { ::inflateEnd(streamp()); }	21✔
80
81	bool run(uint32_t flags) override {	136✔
82	int rc = ::inflate(streamp(), flags);	136✔
83
84	if(rc != Z_OK && rc != Z_STREAM_END && rc != Z_BUF_ERROR)	136✔
85	throw Compression_Error("zlib inflate", ErrorType::ZlibError, rc);	×
86
87	return (rc == Z_STREAM_END);	136✔
88	}
89	};
90
91	class Deflate_Compression_Stream final : public Zlib_Compression_Stream {
92	public:
93	Deflate_Compression_Stream(size_t level, int wbits) : Zlib_Compression_Stream(level, wbits, -1) {}	20✔
94	};
95
96	class Deflate_Decompression_Stream final : public Zlib_Decompression_Stream {
97	public:
98	explicit Deflate_Decompression_Stream(int wbits) : Zlib_Decompression_Stream(wbits, -1) {}	20✔
99	};
100
101	class Gzip_Compression_Stream final : public Zlib_Compression_Stream {
102	public:
103	Gzip_Compression_Stream(size_t level, int wbits, uint8_t os_code, uint64_t hdr_time) :	21✔
104	Zlib_Compression_Stream(level, wbits, 16) {	21✔
105	clear_mem(&m_header, 1);	21✔
106	m_header.os = os_code;	21✔
107	m_header.time = static_cast<uLong>(hdr_time);	21✔
108
109	int rc = deflateSetHeader(streamp(), &m_header);	21✔
110	if(rc != Z_OK)	21✔
111	throw Compression_Error("deflateSetHeader", ErrorType::ZlibError, rc);	×
112	}	21✔
113
114	private:
115	::gz_header m_header;
116	};
117
118	class Gzip_Decompression_Stream final : public Zlib_Decompression_Stream {
119	public:
120	explicit Gzip_Decompression_Stream(int wbits) : Zlib_Decompression_Stream(wbits, 16) {}	21✔
121	};
122
123	}
124
125	std::unique_ptr<Compression_Stream> Zlib_Compression::make_stream(size_t level) const {	36✔
126	return std::make_unique<Zlib_Compression_Stream>(level, 15);	36✔
127	}
128
129	std::unique_ptr<Compression_Stream> Zlib_Decompression::make_stream() const {	21✔
130	return std::make_unique<Zlib_Decompression_Stream>(15);	21✔
131	}
132
133	std::unique_ptr<Compression_Stream> Deflate_Compression::make_stream(size_t level) const {	20✔
134	return std::make_unique<Deflate_Compression_Stream>(level, 15);	20✔
135	}
136
137	std::unique_ptr<Compression_Stream> Deflate_Decompression::make_stream() const {	20✔
138	return std::make_unique<Deflate_Decompression_Stream>(15);	20✔
139	}
140
141	std::unique_ptr<Compression_Stream> Gzip_Compression::make_stream(size_t level) const {	21✔
142	return std::make_unique<Gzip_Compression_Stream>(level, 15, m_os_code, m_hdr_time);	21✔
143	}
144
145	std::unique_ptr<Compression_Stream> Gzip_Decompression::make_stream() const {	21✔
146	return std::make_unique<Gzip_Decompression_Stream>(15);	21✔
147	}
148
149	}

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