Line data Source code
1 : //
2 : // Copyright (c) 2021 Vinnie Falco (vinnie.falco@gmail.com)
3 : // Copyright (c) 2024 Mohammad Nejati
4 : //
5 : // Distributed under the Boost Software License, Version 1.0. (See accompanying
6 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7 : //
8 : // Official repository: https://github.com/cppalliance/http_proto
9 : //
10 :
11 : #include <boost/http_proto/service/zlib_service.hpp>
12 :
13 : #include <boost/assert/source_location.hpp>
14 : #include <boost/config.hpp>
15 : #include <boost/system/result.hpp>
16 : #include <boost/throw_exception.hpp>
17 :
18 : #include <zlib.h>
19 :
20 : namespace boost {
21 : namespace http_proto {
22 : namespace zlib {
23 :
24 : namespace {
25 :
26 : BOOST_NOINLINE BOOST_NORETURN
27 : void
28 0 : throw_zlib_error(
29 : int e,
30 : source_location const& loc = BOOST_CURRENT_LOCATION)
31 : {
32 0 : throw_exception(
33 0 : system::system_error(static_cast<error>(e)), loc);
34 : }
35 :
36 : // probes memory usage for a config
37 : class probe
38 : {
39 : public:
40 : explicit
41 : probe() noexcept
42 : {
43 : zs_.zalloc = &zalloc;
44 : zs_.zfree = &zfree;
45 : zs_.opaque = this;
46 : }
47 :
48 : system::result<std::size_t>
49 : deflate_init(
50 : int level)
51 : {
52 : n_ = 0;
53 : system::error_code ec;
54 : ec = static_cast<error>(
55 : deflateInit(&zs_, level));
56 : if(ec.failed())
57 : return ec;
58 : Bytef tmp[24]{};
59 : zs_.next_in = &tmp[0];
60 : zs_.avail_in = 1;
61 : zs_.next_out = &tmp[1];
62 : zs_.avail_out = 23;
63 : ec = static_cast<error>(
64 : deflate(&zs_,
65 : Z_FINISH));
66 : if( ec.failed() &&
67 : ec != error::stream_end)
68 : return ec;
69 : ec = static_cast<error>(
70 : deflateEnd(&zs_));
71 : if(ec.failed())
72 : return ec;
73 : return n_;
74 : }
75 :
76 : system::result<std::size_t>
77 : deflate_init2(
78 : int level,
79 : int method,
80 : int windowBits,
81 : int memLevel,
82 : int strategy)
83 : {
84 : n_ = 0;
85 : system::error_code ec;
86 : ec = static_cast<error>(
87 : deflateInit2(&zs_,
88 : level,
89 : method,
90 : windowBits,
91 : memLevel,
92 : strategy));
93 : if(ec.failed())
94 : return ec;
95 : Bytef tmp[2];
96 : zs_.next_in = &tmp[0];
97 : zs_.avail_in = 0;
98 : zs_.next_out = &tmp[1];
99 : zs_.avail_out = 0;
100 : ec = static_cast<error>(
101 : deflate(&zs_,
102 : Z_FULL_FLUSH));
103 : if(ec.failed())
104 : return ec;
105 : ec = static_cast<error>(
106 : deflateEnd(&zs_));
107 : if(ec.failed())
108 : return ec;
109 : return n_;
110 : }
111 :
112 : private:
113 : static void* zalloc(void* opaque,
114 : uInt num, uInt size)
115 : {
116 : auto& self =
117 : *reinterpret_cast<
118 : probe*>(opaque);
119 : self.n_ += num * size;
120 : return new char[num * size];
121 : }
122 :
123 : static void zfree(
124 : void*, void* address)
125 : {
126 : delete[] reinterpret_cast<
127 : char*>(address);
128 : }
129 :
130 : z_stream_s zs_{};
131 : std::size_t n_ = 0;
132 : };
133 :
134 348 : void* zalloc(
135 : void* opaque,
136 : unsigned items,
137 : unsigned size)
138 : {
139 : try
140 : {
141 348 : auto n = items * size;
142 348 : auto* ws =
143 : reinterpret_cast<
144 : http_proto::detail::workspace*>(opaque);
145 :
146 348 : return ws->reserve_front(n);
147 : }
148 0 : catch(std::length_error const&) // represents OOM
149 : {
150 0 : return Z_NULL;
151 0 : }
152 : }
153 :
154 0 : void zfree(void* /* opaque */, void* /* addr */)
155 : {
156 : // we call ws_.clear() before the serializer is reused
157 : // so all the allocations are passively freed
158 0 : }
159 :
160 : ::uInt
161 661296 : clamp(std::size_t x) noexcept
162 : {
163 661296 : if(x >= (std::numeric_limits<::uInt>::max)())
164 0 : return (std::numeric_limits<::uInt>::max)();
165 661296 : return static_cast<::uInt>(x);
166 : }
167 :
168 : void
169 165324 : sync(z_stream* zs, params const& p) noexcept
170 : {
171 165324 : zs->next_in = reinterpret_cast<::Bytef*>(
172 165324 : const_cast<void*>(p.next_in));
173 165324 : zs->avail_in = clamp(p.avail_in);
174 165324 : zs->next_out = reinterpret_cast<::Bytef*>(p.next_out);
175 165324 : zs->avail_out = clamp(p.avail_out);
176 165324 : }
177 :
178 : void
179 165324 : sync(z_stream const& zs, params* p) noexcept
180 : {
181 165324 : p->next_in = zs.next_in;
182 165324 : p->avail_in -= clamp(p->avail_in) - zs.avail_in;
183 165324 : p->next_out = zs.next_out;
184 165324 : p->avail_out -= clamp(p->avail_out) - zs.avail_out;
185 165324 : }
186 :
187 : class deflator
188 : : public stream
189 : {
190 : z_stream zs_;
191 :
192 : public:
193 48 : deflator(
194 : http_proto::detail::workspace& ws,
195 : int level,
196 : int window_bits,
197 : int mem_level)
198 48 : {
199 48 : zs_.zalloc = &zalloc;
200 48 : zs_.zfree = &zfree;
201 48 : zs_.opaque = &ws;
202 :
203 48 : auto ret = deflateInit2(&zs_, level, Z_DEFLATED,
204 : window_bits, mem_level, Z_DEFAULT_STRATEGY);
205 48 : if(ret != Z_OK)
206 0 : throw_zlib_error(ret);
207 48 : }
208 :
209 : system::error_code
210 45712 : write(params& p, flush f) noexcept override
211 : {
212 45712 : sync(&zs_, p);
213 45712 : auto ret = deflate(&zs_, static_cast<int>(f));
214 45712 : sync(zs_, &p);
215 45712 : return static_cast<error>(ret);
216 : }
217 : };
218 :
219 : class inflator
220 : : public stream
221 : {
222 : z_stream zs_;
223 :
224 : public:
225 72 : inflator(
226 : http_proto::detail::workspace& ws,
227 : int window_bits)
228 72 : {
229 72 : zs_.zalloc = &zalloc;
230 72 : zs_.zfree = &zfree;
231 72 : zs_.opaque = &ws;
232 :
233 72 : auto ret = inflateInit2(&zs_, window_bits);
234 72 : if(ret != Z_OK)
235 0 : throw_zlib_error(ret);
236 72 : }
237 :
238 : system::error_code
239 119612 : write(params& p, flush f) noexcept override
240 : {
241 119612 : sync(&zs_, p);
242 119612 : auto ret = inflate(&zs_, static_cast<int>(f));
243 119612 : sync(zs_, &p);
244 119612 : return static_cast<error>(ret);
245 : }
246 : };
247 :
248 : struct service_impl
249 : : public service
250 : {
251 : using key_type = service;
252 :
253 : explicit
254 27 : service_impl(context&) noexcept
255 27 : {
256 27 : }
257 :
258 : std::size_t
259 24 : deflator_space_needed(
260 : int window_bits,
261 : int mem_level) const noexcept override
262 : {
263 : // TODO: Account for the number of allocations and
264 : // their overhead in the workspace.
265 :
266 : // https://www.zlib.net/zlib_tech.html
267 : return
268 24 : (1 << (window_bits + 2)) +
269 24 : (1 << (mem_level + 9)) +
270 : (6 * 1024) +
271 : #ifdef __s390x__
272 : 5768 +
273 : #endif
274 : http_proto::detail::
275 24 : workspace::space_needed<deflator>();
276 : }
277 :
278 : std::size_t
279 2 : inflator_space_needed(
280 : int window_bits) const noexcept override
281 : {
282 : // TODO: Account for the number of allocations and
283 : // their overhead in the workspace.
284 :
285 : // https://www.zlib.net/zlib_tech.html
286 : return
287 2 : (1 << window_bits) +
288 : (7 * 1024) +
289 : #ifdef __s390x__
290 : 5768 +
291 : #endif
292 : http_proto::detail::
293 2 : workspace::space_needed<inflator>();
294 : }
295 :
296 : stream&
297 48 : make_deflator(
298 : http_proto::detail::workspace& ws,
299 : int level,
300 : int window_bits,
301 : int mem_level) const override
302 : {
303 48 : return ws.emplace<deflator>(
304 48 : ws, level, window_bits, mem_level);
305 : }
306 :
307 : stream&
308 72 : make_inflator(
309 : http_proto::detail::workspace& ws,
310 : int window_bits) const override
311 : {
312 72 : return ws.emplace<inflator>(ws, window_bits);
313 : }
314 : };
315 :
316 : } // namespace
317 :
318 : void
319 27 : install_service(context& ctx)
320 : {
321 27 : ctx.make_service<service_impl>();
322 27 : }
323 :
324 : } // zlib
325 : } // http_proto
326 : } // boost
|
