Line | Branch | Exec | Source |
---|---|---|---|
1 | // | ||
2 | // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com) | ||
3 | // | ||
4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | ||
5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | ||
6 | // | ||
7 | // Official repository: https://github.com/cppalliance/http_proto | ||
8 | // | ||
9 | |||
10 | #include <boost/http_proto/parser.hpp> | ||
11 | |||
12 | #include <boost/http_proto/context.hpp> | ||
13 | #include <boost/http_proto/error.hpp> | ||
14 | #include <boost/http_proto/rfc/detail/rules.hpp> | ||
15 | #include <boost/http_proto/service/zlib_service.hpp> | ||
16 | |||
17 | #include <boost/http_proto/detail/except.hpp> | ||
18 | |||
19 | #include <boost/buffers/algorithm.hpp> | ||
20 | #include <boost/buffers/buffer_copy.hpp> | ||
21 | #include <boost/buffers/buffer_size.hpp> | ||
22 | #include <boost/buffers/make_buffer.hpp> | ||
23 | |||
24 | #include <boost/url/grammar/ci_string.hpp> | ||
25 | #include <boost/url/grammar/hexdig_chars.hpp> | ||
26 | |||
27 | #include <boost/assert.hpp> | ||
28 | |||
29 | #include <array> | ||
30 | #include <iostream> | ||
31 | #include <memory> | ||
32 | |||
33 | #include "rfc/detail/rules.hpp" | ||
34 | #include "zlib_service.hpp" | ||
35 | |||
36 | namespace boost { | ||
37 | namespace http_proto { | ||
38 | |||
39 | /* | ||
40 | Principles for fixed-size buffer design | ||
41 | |||
42 | axiom 1: | ||
43 | To read data you must have a buffer. | ||
44 | |||
45 | axiom 2: | ||
46 | The size of the HTTP header is not | ||
47 | known in advance. | ||
48 | |||
49 | conclusion 3: | ||
50 | A single I/O can produce a complete | ||
51 | HTTP header and additional payload | ||
52 | data. | ||
53 | |||
54 | conclusion 4: | ||
55 | A single I/O can produce multiple | ||
56 | complete HTTP headers, complete | ||
57 | payloads, and a partial header or | ||
58 | payload. | ||
59 | |||
60 | axiom 5: | ||
61 | A process is in one of two states: | ||
62 | 1. at or below capacity | ||
63 | 2. above capacity | ||
64 | |||
65 | axiom 6: | ||
66 | A program which can allocate an | ||
67 | unbounded number of resources can | ||
68 | go above capacity. | ||
69 | |||
70 | conclusion 7: | ||
71 | A program can guarantee never going | ||
72 | above capacity if all resources are | ||
73 | provisioned at program startup. | ||
74 | |||
75 | corollary 8: | ||
76 | `parser` and `serializer` should each | ||
77 | allocate a single buffer of calculated | ||
78 | size, and never resize it. | ||
79 | |||
80 | axiom #: | ||
81 | A parser and a serializer are always | ||
82 | used in pairs. | ||
83 | |||
84 | Buffer Usage | ||
85 | |||
86 | | | begin | ||
87 | | H | p | | f | read headers | ||
88 | | H | p | | T | f | set T body | ||
89 | | H | p | | C | T | f | make codec C | ||
90 | | H | p | b | C | T | f | decode p into b | ||
91 | | H | p | b | C | T | f | read/parse loop | ||
92 | | H | | T | f | destroy codec | ||
93 | | H | | T | f | finished | ||
94 | |||
95 | H headers | ||
96 | C codec | ||
97 | T body | ||
98 | f table | ||
99 | p partial payload | ||
100 | b body data | ||
101 | |||
102 | "payload" is the bytes coming in from | ||
103 | the stream. | ||
104 | |||
105 | "body" is the logical body, after transfer | ||
106 | encoding is removed. This can be the | ||
107 | same as the payload. | ||
108 | |||
109 | A "plain payload" is when the payload and | ||
110 | body are identical (no transfer encodings). | ||
111 | |||
112 | A "buffered payload" is any payload which is | ||
113 | not plain. A second buffer is required | ||
114 | for reading. | ||
115 | |||
116 | "overread" is additional data received past | ||
117 | the end of the headers when reading headers, | ||
118 | or additional data received past the end of | ||
119 | the message payload. | ||
120 | */ | ||
121 | //----------------------------------------------- | ||
122 | |||
123 | class chained_sequence | ||
124 | { | ||
125 | char const* pos_; | ||
126 | char const* end_; | ||
127 | char const* begin_b_; | ||
128 | char const* end_b_; | ||
129 | |||
130 | public: | ||
131 | 69628 | chained_sequence(buffers::const_buffer_pair const& cbp) | |
132 | 69628 | : pos_(static_cast<char const*>(cbp[0].data())) | |
133 | 69628 | , end_(pos_ + cbp[0].size()) | |
134 | 69628 | , begin_b_(static_cast<char const*>(cbp[1].data())) | |
135 | 69628 | , end_b_(begin_b_ + cbp[1].size()) | |
136 | { | ||
137 | 69628 | } | |
138 | |||
139 | char const* | ||
140 | 315966 | next() noexcept | |
141 | { | ||
142 | 315966 | ++pos_; | |
143 | // most frequently taken branch | ||
144 |
2/2✓ Branch 0 taken 294799 times.
✓ Branch 1 taken 21167 times.
|
315966 | if(pos_ < end_) |
145 | 294799 | return pos_; | |
146 | |||
147 | // swap with the second range | ||
148 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21167 times.
|
21167 | if(begin_b_ != end_b_) |
149 | { | ||
150 | ✗ | pos_ = begin_b_; | |
151 | ✗ | end_ = end_b_; | |
152 | ✗ | begin_b_ = end_b_; | |
153 | ✗ | return pos_; | |
154 | } | ||
155 | |||
156 | // undo the increament | ||
157 | 21167 | pos_ = end_; | |
158 | 21167 | return nullptr; | |
159 | } | ||
160 | |||
161 | bool | ||
162 | 208643 | empty() const noexcept | |
163 | { | ||
164 | 208643 | return pos_ == end_; | |
165 | } | ||
166 | |||
167 | char | ||
168 | 301410 | value() const noexcept | |
169 | { | ||
170 | 301410 | return *pos_; | |
171 | } | ||
172 | |||
173 | std::size_t | ||
174 | 223471 | size() const noexcept | |
175 | { | ||
176 | 223471 | return (end_ - pos_) + (end_b_ - begin_b_); | |
177 | } | ||
178 | }; | ||
179 | |||
180 | static | ||
181 | system::result<std::uint64_t> | ||
182 | 65458 | parse_hex(chained_sequence& cs) | |
183 | { | ||
184 | 65458 | std::uint64_t v = 0; | |
185 | 65458 | std::size_t init_size = cs.size(); | |
186 |
2/2✓ Branch 1 taken 132538 times.
✓ Branch 2 taken 19109 times.
|
151647 | while(!cs.empty()) |
187 | { | ||
188 | 132538 | auto n = grammar::hexdig_value(cs.value()); | |
189 |
2/2✓ Branch 0 taken 46348 times.
✓ Branch 1 taken 86190 times.
|
132538 | if(n < 0) |
190 | { | ||
191 |
2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 46347 times.
|
46348 | if(init_size == cs.size()) |
192 | 1 | BOOST_HTTP_PROTO_RETURN_EC( | |
193 | error::bad_payload); | ||
194 | 46347 | return v; | |
195 | } | ||
196 | |||
197 | // at least 4 significant bits are free | ||
198 |
2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 86189 times.
|
86190 | if(v > (std::numeric_limits<std::uint64_t>::max)() >> 4) |
199 | 1 | BOOST_HTTP_PROTO_RETURN_EC( | |
200 | error::bad_payload); | ||
201 | |||
202 | 86189 | v = (v << 4) | static_cast<std::uint64_t>(n); | |
203 | 86189 | cs.next(); | |
204 | } | ||
205 | 19109 | BOOST_HTTP_PROTO_RETURN_EC( | |
206 | error::need_data); | ||
207 | } | ||
208 | |||
209 | static | ||
210 | system::result<void> | ||
211 | 46641 | find_eol(chained_sequence& cs) | |
212 | { | ||
213 |
2/2✓ Branch 1 taken 52531 times.
✓ Branch 2 taken 44 times.
|
52575 | while(!cs.empty()) |
214 | { | ||
215 |
2/2✓ Branch 1 taken 46597 times.
✓ Branch 2 taken 5934 times.
|
52531 | if(cs.value() == '\r') |
216 | { | ||
217 |
2/2✓ Branch 1 taken 5 times.
✓ Branch 2 taken 46592 times.
|
46597 | if(!cs.next()) |
218 | 5 | break; | |
219 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 46590 times.
|
46592 | if(cs.value() != '\n') |
220 | 2 | BOOST_HTTP_PROTO_RETURN_EC( | |
221 | error::bad_payload); | ||
222 | 46590 | cs.next(); | |
223 | 46590 | return {}; | |
224 | } | ||
225 | 5934 | cs.next(); | |
226 | } | ||
227 | 49 | BOOST_HTTP_PROTO_RETURN_EC( | |
228 | error::need_data); | ||
229 | } | ||
230 | |||
231 | static | ||
232 | system::result<void> | ||
233 | 61214 | parse_eol(chained_sequence& cs) | |
234 | { | ||
235 |
2/2✓ Branch 1 taken 61208 times.
✓ Branch 2 taken 6 times.
|
61214 | if(cs.size() >= 2) |
236 | { | ||
237 | // we are sure size is at least 2 | ||
238 |
6/6✓ Branch 1 taken 61206 times.
✓ Branch 2 taken 2 times.
✓ Branch 4 taken 61205 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 61205 times.
✓ Branch 7 taken 3 times.
|
61208 | if(cs.value() == '\r' && *cs.next() == '\n') |
239 | { | ||
240 | 61205 | cs.next(); | |
241 | 61205 | return {}; | |
242 | } | ||
243 | 3 | BOOST_HTTP_PROTO_RETURN_EC( | |
244 | error::bad_payload); | ||
245 | } | ||
246 | 6 | BOOST_HTTP_PROTO_RETURN_EC( | |
247 | error::need_data); | ||
248 | } | ||
249 | |||
250 | static | ||
251 | system::result<void> | ||
252 | 4161 | skip_trailer_headers(chained_sequence& cs) | |
253 | { | ||
254 |
2/2✓ Branch 1 taken 4418 times.
✓ Branch 2 taken 3 times.
|
4421 | while(!cs.empty()) |
255 | { | ||
256 |
2/2✓ Branch 1 taken 4124 times.
✓ Branch 2 taken 294 times.
|
4418 | if(cs.value() == '\r') |
257 | { | ||
258 |
2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 4123 times.
|
4124 | if(!cs.next()) |
259 | 1 | break; | |
260 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 4121 times.
|
4123 | if(cs.value() != '\n') |
261 | 2 | BOOST_HTTP_PROTO_RETURN_EC( | |
262 | error::bad_payload); | ||
263 | 4121 | cs.next(); | |
264 | 4121 | return {}; | |
265 | } | ||
266 | // skip to the end of field | ||
267 | 294 | auto rv = find_eol(cs); | |
268 |
2/2✓ Branch 1 taken 34 times.
✓ Branch 2 taken 260 times.
|
294 | if(rv.has_error()) |
269 | 34 | return rv.error(); | |
270 | } | ||
271 | 4 | BOOST_HTTP_PROTO_RETURN_EC( | |
272 | error::need_data); | ||
273 | } | ||
274 | |||
275 | template <class ElasticBuffer> | ||
276 | system::result<void> | ||
277 | 69741 | parse_chunked( | |
278 | buffers::circular_buffer& input, | ||
279 | ElasticBuffer& output, | ||
280 | std::uint64_t& chunk_remain_, | ||
281 | std::uint64_t& body_avail_, | ||
282 | bool& needs_chunk_close_, | ||
283 | bool& trailer_headers_) | ||
284 | { | ||
285 | 46384 | for(;;) | |
286 | { | ||
287 |
2/2✓ Branch 0 taken 69628 times.
✓ Branch 1 taken 113 times.
|
69741 | if(chunk_remain_ == 0) |
288 | { | ||
289 | 69628 | auto cs = chained_sequence(input.data()); | |
290 | |||
291 |
2/2✓ Branch 0 taken 4161 times.
✓ Branch 1 taken 65467 times.
|
69628 | if(trailer_headers_) |
292 | { | ||
293 | 4161 | auto rv = skip_trailer_headers(cs); | |
294 |
2/2✓ Branch 1 taken 40 times.
✓ Branch 2 taken 4121 times.
|
4161 | if(rv.has_error()) |
295 | 40 | return rv; | |
296 | 4121 | input.consume(input.size() - cs.size()); | |
297 | 4121 | return {}; | |
298 | } | ||
299 | |||
300 |
2/2✓ Branch 0 taken 61214 times.
✓ Branch 1 taken 4253 times.
|
65467 | if(needs_chunk_close_) |
301 | { | ||
302 | 61214 | auto rv = parse_eol(cs); | |
303 |
2/2✓ Branch 1 taken 9 times.
✓ Branch 2 taken 61205 times.
|
61214 | if(rv.has_error()) |
304 | 9 | return rv; | |
305 | } | ||
306 | |||
307 | 65458 | auto chunk_size = parse_hex(cs); | |
308 |
2/2✓ Branch 1 taken 19111 times.
✓ Branch 2 taken 46347 times.
|
65458 | if(chunk_size.has_error()) |
309 | 19111 | return chunk_size.error(); | |
310 | |||
311 | // chunk extensions are skipped | ||
312 | 46347 | auto rv = find_eol(cs); | |
313 |
2/2✓ Branch 1 taken 17 times.
✓ Branch 2 taken 46330 times.
|
46347 | if(rv.has_error()) |
314 | 17 | return rv; | |
315 | |||
316 | 46330 | input.consume(input.size() - cs.size()); | |
317 |
1/2✓ Branch 2 taken 46330 times.
✗ Branch 3 not taken.
|
46330 | chunk_remain_ = chunk_size.value(); |
318 | |||
319 | 46330 | needs_chunk_close_ = true; | |
320 |
2/2✓ Branch 0 taken 4123 times.
✓ Branch 1 taken 42207 times.
|
46330 | if(chunk_remain_ == 0) |
321 | { | ||
322 | 4123 | trailer_headers_ = true; | |
323 | 4123 | continue; | |
324 | } | ||
325 | } | ||
326 | |||
327 | // we've successfully parsed a chunk-size and have | ||
328 | // consume()d the entire buffer | ||
329 |
2/2✓ Branch 1 taken 59 times.
✓ Branch 2 taken 42261 times.
|
42320 | if( input.size() == 0 ) |
330 | 59 | BOOST_HTTP_PROTO_RETURN_EC( | |
331 | error::need_data); | ||
332 | |||
333 | // TODO: this is an open-ended design space with no | ||
334 | // clear answer at time of writing. | ||
335 | // revisit this later | ||
336 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 42261 times.
|
42261 | if( output.capacity() == 0 ) |
337 | ✗ | detail::throw_length_error(); | |
338 | |||
339 | 84522 | auto n = (std::min)( | |
340 | chunk_remain_, | ||
341 | 42261 | static_cast<std::uint64_t>(input.size())); | |
342 | |||
343 | 42261 | auto m = buffers::buffer_copy( | |
344 |
1/2✓ Branch 2 taken 42261 times.
✗ Branch 3 not taken.
|
42261 | output.prepare(output.capacity()), |
345 | 42261 | buffers::prefix(input.data(), static_cast<std::size_t>(n))); | |
346 | |||
347 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42261 times.
|
42261 | BOOST_ASSERT(m <= chunk_remain_); |
348 | 42261 | chunk_remain_ -= m; | |
349 | 42261 | input.consume(m); | |
350 | 42261 | output.commit(m); | |
351 | 42261 | body_avail_ += m; | |
352 | } | ||
353 | } | ||
354 | |||
355 | //----------------------------------------------- | ||
356 | |||
357 | class parser_service | ||
358 | : public service | ||
359 | { | ||
360 | public: | ||
361 | parser::config_base cfg; | ||
362 | std::size_t space_needed = 0; | ||
363 | std::size_t max_codec = 0; | ||
364 | zlib::detail::deflate_decoder_service const* | ||
365 | deflate_svc = nullptr; | ||
366 | |||
367 | parser_service( | ||
368 | context& ctx, | ||
369 | parser::config_base const& cfg_); | ||
370 | |||
371 | std::size_t | ||
372 | 35215 | max_overread() const noexcept | |
373 | { | ||
374 | return | ||
375 | 35215 | cfg.headers.max_size + | |
376 | 35215 | cfg.min_buffer; | |
377 | } | ||
378 | }; | ||
379 | |||
380 | 35 | parser_service:: | |
381 | parser_service( | ||
382 | context& ctx, | ||
383 | 35 | parser::config_base const& cfg_) | |
384 | 35 | : cfg(cfg_) | |
385 | { | ||
386 | /* | ||
387 | | fb | cb0 | cb1 | C | T | f | | ||
388 | |||
389 | fb flat_buffer headers.max_size | ||
390 | cb0 circular_buffer min_buffer | ||
391 | cb1 circular_buffer min_buffer | ||
392 | C codec max_codec | ||
393 | T body max_type_erase | ||
394 | f table max_table_space | ||
395 | |||
396 | */ | ||
397 | // validate | ||
398 | //if(cfg.min_prepare > cfg.max_prepare) | ||
399 | //detail::throw_invalid_argument(); | ||
400 | |||
401 |
1/2✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
|
35 | if( cfg.min_buffer < 1 || |
402 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
|
35 | cfg.min_buffer > cfg.body_limit) |
403 | ✗ | detail::throw_invalid_argument(); | |
404 | |||
405 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
|
35 | if(cfg.max_prepare < 1) |
406 | ✗ | detail::throw_invalid_argument(); | |
407 | |||
408 | // VFALCO TODO OVERFLOW CHECING | ||
409 | { | ||
410 | //fb_.size() - h_.size + | ||
411 | //svc_.cfg.min_buffer + | ||
412 | //svc_.cfg.min_buffer + | ||
413 | //svc_.max_codec; | ||
414 | } | ||
415 | |||
416 | // VFALCO OVERFLOW CHECKING ON THIS | ||
417 | 35 | space_needed += | |
418 |
1/2✓ Branch 1 taken 35 times.
✗ Branch 2 not taken.
|
35 | cfg.headers.valid_space_needed(); |
419 | |||
420 | // cb0_, cb1_ | ||
421 | // VFALCO OVERFLOW CHECKING ON THIS | ||
422 | 35 | space_needed += | |
423 | 35 | cfg.min_buffer + | |
424 | cfg.min_buffer; | ||
425 | |||
426 | // T | ||
427 | 35 | space_needed += cfg.max_type_erase; | |
428 | |||
429 | // max_codec | ||
430 | { | ||
431 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 34 times.
|
35 | if(cfg.apply_deflate_decoder) |
432 | { | ||
433 | 1 | deflate_svc = &ctx.get_service< | |
434 |
1/2✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
|
1 | zlib::detail::deflate_decoder_service>(); |
435 | auto const n = | ||
436 | 1 | deflate_svc->space_needed(); | |
437 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if( max_codec < n) |
438 | ✗ | max_codec = n; | |
439 | } | ||
440 | } | ||
441 | 35 | space_needed += max_codec; | |
442 | |||
443 | // round up to alignof(detail::header::entry) | ||
444 | 35 | auto const al = alignof( | |
445 | detail::header::entry); | ||
446 | 35 | space_needed = al * (( | |
447 | 35 | space_needed + al - 1) / al); | |
448 | 35 | } | |
449 | |||
450 | void | ||
451 | 35 | install_parser_service( | |
452 | context& ctx, | ||
453 | parser::config_base const& cfg) | ||
454 | { | ||
455 | ctx.make_service< | ||
456 | 35 | parser_service>(cfg); | |
457 | 35 | } | |
458 | |||
459 | //------------------------------------------------ | ||
460 | // | ||
461 | // Special Members | ||
462 | // | ||
463 | //------------------------------------------------ | ||
464 | |||
465 | 1047 | parser:: | |
466 | parser( | ||
467 | context& ctx, | ||
468 | 1047 | detail::kind k) | |
469 | 1047 | : ctx_(ctx) | |
470 | 1047 | , svc_(ctx.get_service< | |
471 | 1047 | parser_service>()) | |
472 | 1047 | , h_(detail::empty{k}) | |
473 | 1047 | , eb_(nullptr) | |
474 | 2094 | , st_(state::reset) | |
475 | { | ||
476 | 1047 | auto const n = | |
477 | 1047 | svc_.space_needed; | |
478 |
1/2✓ Branch 1 taken 1047 times.
✗ Branch 2 not taken.
|
1047 | ws_.allocate(n); |
479 | 1047 | h_.cap = n; | |
480 | 1047 | } | |
481 | |||
482 | //------------------------------------------------ | ||
483 | |||
484 | 1047 | parser:: | |
485 | ~parser() | ||
486 | { | ||
487 | 1047 | } | |
488 | |||
489 | //------------------------------------------------ | ||
490 | // | ||
491 | // Modifiers | ||
492 | // | ||
493 | //------------------------------------------------ | ||
494 | |||
495 | // prepare for a new stream | ||
496 | void | ||
497 | 1644 | parser:: | |
498 | reset() noexcept | ||
499 | { | ||
500 | 1644 | ws_.clear(); | |
501 | 1644 | eb_ = nullptr; | |
502 | 1644 | st_ = state::start; | |
503 | 1644 | got_eof_ = false; | |
504 | 1644 | } | |
505 | |||
506 | void | ||
507 | 9872 | parser:: | |
508 | start_impl( | ||
509 | bool head_response) | ||
510 | { | ||
511 | 9872 | std::size_t leftover = 0; | |
512 |
5/5✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1629 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 8238 times.
|
9872 | switch(st_) |
513 | { | ||
514 | 1 | default: | |
515 | case state::reset: | ||
516 | // reset must be called first | ||
517 | 1 | detail::throw_logic_error(); | |
518 | |||
519 | 1629 | case state::start: | |
520 | // reset required on eof | ||
521 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1629 times.
|
1629 | if(got_eof_) |
522 | ✗ | detail::throw_logic_error(); | |
523 | 1629 | break; | |
524 | |||
525 | 3 | case state::header: | |
526 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 times.
|
3 | if(fb_.size() == 0) |
527 | { | ||
528 | // start() called twice | ||
529 | 2 | detail::throw_logic_error(); | |
530 | } | ||
531 | BOOST_FALLTHROUGH; | ||
532 | |||
533 | case state::body: | ||
534 | case state::set_body: | ||
535 | // current message is incomplete | ||
536 | 2 | detail::throw_logic_error(); | |
537 | |||
538 | 8238 | case state::complete: | |
539 | { | ||
540 | // remove partial body. | ||
541 |
6/6✓ Branch 1 taken 4239 times.
✓ Branch 2 taken 3999 times.
✓ Branch 3 taken 4174 times.
✓ Branch 4 taken 65 times.
✓ Branch 5 taken 4174 times.
✓ Branch 6 taken 4064 times.
|
8238 | if(is_plain() && (how_ == how::in_place)) |
542 | 4174 | cb0_.consume( | |
543 | 4174 | static_cast<std::size_t>(body_avail_)); | |
544 | |||
545 |
2/2✓ Branch 1 taken 4000 times.
✓ Branch 2 taken 4238 times.
|
8238 | if(cb0_.size() > 0) |
546 | { | ||
547 | // move unused octets to front | ||
548 | |||
549 | 4000 | ws_.clear(); | |
550 | 4000 | leftover = cb0_.size(); | |
551 | |||
552 | 4000 | auto* dest = reinterpret_cast<char*>(ws_.data()); | |
553 | 4000 | auto cbp = cb0_.data(); | |
554 | 4000 | auto* a = static_cast<char const*>(cbp[0].data()); | |
555 | 4000 | auto* b = static_cast<char const*>(cbp[1].data()); | |
556 | 4000 | auto an = cbp[0].size(); | |
557 | 4000 | auto bn = cbp[1].size(); | |
558 | |||
559 |
2/2✓ Branch 0 taken 3847 times.
✓ Branch 1 taken 153 times.
|
4000 | if(bn == 0) |
560 | { | ||
561 | 3847 | std::memmove(dest, a, an); | |
562 | } | ||
563 | else | ||
564 | { | ||
565 | // if `a` can fit between `dest` and `b`, shift `b` to the left | ||
566 | // and copy `a` to its position. if `a` fits perfectly, the | ||
567 | // shift will be of size 0. | ||
568 | // if `a` requires more space, shift `b` to the right and | ||
569 | // copy `a` to its position. this process may require multiple | ||
570 | // iterations and should be done chunk by chunk to prevent `b` | ||
571 | // from overlapping with `a`. | ||
572 | do | ||
573 | { | ||
574 | // clamp right shifts to prevent overlap with `a` | ||
575 | 153 | auto* bp = (std::min)(dest + an, const_cast<char*>(a) - bn); | |
576 | 153 | b = static_cast<char const*>(std::memmove(bp, b, bn)); | |
577 | |||
578 | // a chunk or all of `a` based on available space | ||
579 | 153 | auto chunk_a = static_cast<std::size_t>(b - dest); | |
580 | 153 | std::memcpy(dest, a, chunk_a); // never overlap | |
581 | 153 | an -= chunk_a; | |
582 | 153 | dest += chunk_a; | |
583 | 153 | a += chunk_a; | |
584 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 153 times.
|
153 | } while(an); |
585 | } | ||
586 | } | ||
587 | else | ||
588 | { | ||
589 | // leftover data after body | ||
590 | } | ||
591 | 8238 | break; | |
592 | } | ||
593 | } | ||
594 | |||
595 | 9867 | ws_.clear(); | |
596 | |||
597 | 19734 | fb_ = { | |
598 | 9867 | ws_.data(), | |
599 | 9867 | svc_.cfg.headers.max_size + | |
600 | 9867 | svc_.cfg.min_buffer, | |
601 | leftover }; | ||
602 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 9867 times.
|
9867 | BOOST_ASSERT(fb_.capacity() == |
603 | svc_.max_overread() - leftover); | ||
604 | |||
605 | 19734 | h_ = detail::header( | |
606 | 9867 | detail::empty{h_.kind}); | |
607 | 9867 | h_.buf = reinterpret_cast< | |
608 | 9867 | char*>(ws_.data()); | |
609 | 9867 | h_.cbuf = h_.buf; | |
610 | 9867 | h_.cap = ws_.size(); | |
611 | |||
612 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 9867 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
9867 | BOOST_ASSERT(! head_response || |
613 | h_.kind == detail::kind::response); | ||
614 | 9867 | head_response_ = head_response; | |
615 | |||
616 | // begin with in_place mode | ||
617 | 9867 | how_ = how::in_place; | |
618 | 9867 | st_ = state::header; | |
619 | 9867 | nprepare_ = 0; | |
620 | 9867 | chunk_remain_ = 0; | |
621 | 9867 | needs_chunk_close_ = false; | |
622 | 9867 | trailer_headers_ = false; | |
623 | 9867 | body_avail_ = 0; | |
624 | 9867 | } | |
625 | |||
626 | auto | ||
627 | 47896 | parser:: | |
628 | prepare() -> | ||
629 | mutable_buffers_type | ||
630 | { | ||
631 | 47896 | nprepare_ = 0; | |
632 | |||
633 |
6/6✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 9625 times.
✓ Branch 3 taken 38239 times.
✓ Branch 4 taken 27 times.
✓ Branch 5 taken 3 times.
|
47896 | switch(st_) |
634 | { | ||
635 | 1 | default: | |
636 | case state::reset: | ||
637 | // reset must be called first | ||
638 | 1 | detail::throw_logic_error(); | |
639 | |||
640 | 1 | case state::start: | |
641 | // start must be called first | ||
642 | 1 | detail::throw_logic_error(); | |
643 | |||
644 | 9625 | case state::header: | |
645 | { | ||
646 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9625 times.
|
9625 | BOOST_ASSERT(h_.size < |
647 | svc_.cfg.headers.max_size); | ||
648 | 9625 | auto n = fb_.capacity() - fb_.size(); | |
649 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9625 times.
|
9625 | BOOST_ASSERT(n <= svc_.max_overread()); |
650 |
2/2✓ Branch 0 taken 29 times.
✓ Branch 1 taken 9596 times.
|
9625 | if( n > svc_.cfg.max_prepare) |
651 | 29 | n = svc_.cfg.max_prepare; | |
652 | 9625 | mbp_[0] = fb_.prepare(n); | |
653 | 9625 | nprepare_ = n; | |
654 | 9625 | return mutable_buffers_type( | |
655 | 19250 | &mbp_[0], 1); | |
656 | } | ||
657 | |||
658 | 38239 | case state::body: | |
659 | { | ||
660 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38239 times.
|
38239 | if(got_eof_) |
661 | ✗ | return mutable_buffers_type{}; | |
662 | |||
663 | 38239 | do_body: | |
664 |
2/2✓ Branch 1 taken 19226 times.
✓ Branch 2 taken 19037 times.
|
38263 | if(! is_plain()) |
665 | { | ||
666 | // buffered payload | ||
667 | 19226 | auto n = cb0_.capacity() - | |
668 | 19226 | cb0_.size(); | |
669 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19226 times.
|
19226 | if( n > svc_.cfg.max_prepare) |
670 | ✗ | n = svc_.cfg.max_prepare; | |
671 | 19226 | mbp_ = cb0_.prepare(n); | |
672 | 19226 | nprepare_ = n; | |
673 | 19226 | return mutable_buffers_type(mbp_); | |
674 | } | ||
675 | |||
676 | // plain payload | ||
677 | |||
678 |
2/2✓ Branch 0 taken 19010 times.
✓ Branch 1 taken 27 times.
|
19037 | if(how_ == how::in_place) |
679 | { | ||
680 | 19010 | auto n = cb0_.capacity(); | |
681 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 19009 times.
|
19010 | if( n > svc_.cfg.max_prepare) |
682 | 1 | n = svc_.cfg.max_prepare; | |
683 | 19010 | mbp_ = cb0_.prepare(n); | |
684 | 19010 | nprepare_ = n; | |
685 | 19010 | return mutable_buffers_type(mbp_); | |
686 | } | ||
687 | |||
688 |
1/2✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
|
27 | if(how_ == how::elastic) |
689 | { | ||
690 | // Overreads are not allowed, or | ||
691 | // else the caller will see extra | ||
692 | // unrelated data. | ||
693 | |||
694 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 18 times.
|
27 | if(h_.md.payload == payload::size) |
695 | { | ||
696 | // set_body moves avail to dyn | ||
697 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
|
9 | BOOST_ASSERT(body_buf_->size() == 0); |
698 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | BOOST_ASSERT(body_avail_ == 0); |
699 | 9 | auto n = static_cast<std::size_t>(payload_remain_); | |
700 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 8 times.
|
9 | if( n > svc_.cfg.max_prepare) |
701 | 1 | n = svc_.cfg.max_prepare; | |
702 | 9 | nprepare_ = n; | |
703 | 9 | return eb_->prepare(n); | |
704 | } | ||
705 | |||
706 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
|
18 | BOOST_ASSERT( |
707 | h_.md.payload == payload::to_eof); | ||
708 | 18 | std::size_t n = 0; | |
709 |
1/2✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
|
18 | if(! got_eof_) |
710 | { | ||
711 | // calculate n heuristically | ||
712 | 18 | n = svc_.cfg.min_buffer; | |
713 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 17 times.
|
18 | if( n > svc_.cfg.max_prepare) |
714 | 1 | n = svc_.cfg.max_prepare; | |
715 | { | ||
716 | // apply max_size() | ||
717 | auto avail = | ||
718 | 18 | eb_->max_size() - | |
719 | 18 | eb_->size(); | |
720 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
|
18 | if( n > avail) |
721 | 9 | n = avail; | |
722 | } | ||
723 | // fill capacity() first, | ||
724 | // to avoid an allocation | ||
725 | { | ||
726 | auto avail = | ||
727 | 18 | eb_->capacity() - | |
728 | 18 | eb_->size(); | |
729 |
3/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
|
18 | if( n > avail && |
730 | avail != 0) | ||
731 | 3 | n = avail; | |
732 | } | ||
733 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 16 times.
|
18 | if(n == 0) |
734 | { | ||
735 | // dynamic buffer is full | ||
736 | // attempt a 1 byte read so | ||
737 | // we can detect overflow | ||
738 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
|
2 | BOOST_ASSERT( |
739 | body_buf_->size() == 0); | ||
740 | // handled in init_dynamic | ||
741 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | BOOST_ASSERT( |
742 | body_avail_ == 0); | ||
743 | 2 | mbp_ = body_buf_->prepare(1); | |
744 | 2 | nprepare_ = 1; | |
745 | return | ||
746 | 2 | mutable_buffers_type(mbp_); | |
747 | } | ||
748 | } | ||
749 | 16 | nprepare_ = n; | |
750 | 16 | return eb_->prepare(n); | |
751 | } | ||
752 | |||
753 | // VFALCO TODO | ||
754 | ✗ | detail::throw_logic_error(); | |
755 | } | ||
756 | |||
757 | 27 | case state::set_body: | |
758 | { | ||
759 |
1/2✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
|
27 | if(how_ == how::elastic) |
760 | { | ||
761 | // attempt to transfer in-place | ||
762 | // body into the dynamic buffer. | ||
763 | 27 | system::error_code ec; | |
764 |
1/2✓ Branch 1 taken 27 times.
✗ Branch 2 not taken.
|
27 | init_dynamic(ec); |
765 |
2/2✓ Branch 1 taken 26 times.
✓ Branch 2 taken 1 times.
|
27 | if(! ec.failed()) |
766 | { | ||
767 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 2 times.
|
26 | if(st_ == state::body) |
768 | 24 | goto do_body; | |
769 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | BOOST_ASSERT( |
770 | st_ == state::complete); | ||
771 | 2 | return mutable_buffers_type{}; | |
772 | } | ||
773 | |||
774 | // not enough room, so we | ||
775 | // return this error from parse() | ||
776 | return | ||
777 | 1 | mutable_buffers_type{}; | |
778 | } | ||
779 | |||
780 | ✗ | if(how_ == how::sink) | |
781 | { | ||
782 | // this is a no-op, to get the | ||
783 | // caller to call parse next. | ||
784 | ✗ | return mutable_buffers_type{}; | |
785 | } | ||
786 | |||
787 | // VFALCO TODO | ||
788 | ✗ | detail::throw_logic_error(); | |
789 | } | ||
790 | |||
791 | 3 | case state::complete: | |
792 | // intended no-op | ||
793 | 3 | return mutable_buffers_type{}; | |
794 | } | ||
795 | } | ||
796 | |||
797 | void | ||
798 | 47887 | parser:: | |
799 | commit( | ||
800 | std::size_t n) | ||
801 | { | ||
802 |
6/6✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 9625 times.
✓ Branch 3 taken 38254 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 4 times.
|
47887 | switch(st_) |
803 | { | ||
804 | 1 | default: | |
805 | case state::reset: | ||
806 | { | ||
807 | // reset must be called first | ||
808 | 1 | detail::throw_logic_error(); | |
809 | } | ||
810 | |||
811 | 1 | case state::start: | |
812 | { | ||
813 | // forgot to call start() | ||
814 | 1 | detail::throw_logic_error(); | |
815 | } | ||
816 | |||
817 | 9625 | case state::header: | |
818 | { | ||
819 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 9624 times.
|
9625 | if(n > nprepare_) |
820 | { | ||
821 | // n can't be greater than size of | ||
822 | // the buffers returned by prepare() | ||
823 | 1 | detail::throw_invalid_argument(); | |
824 | } | ||
825 | |||
826 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 9623 times.
|
9624 | if(got_eof_) |
827 | { | ||
828 | // can't commit after EOF | ||
829 | 1 | detail::throw_logic_error(); | |
830 | } | ||
831 | |||
832 | 9623 | nprepare_ = 0; // invalidate | |
833 | 9623 | fb_.commit(n); | |
834 | 9623 | break; | |
835 | } | ||
836 | |||
837 | 38254 | case state::body: | |
838 | { | ||
839 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 38253 times.
|
38254 | if(n > nprepare_) |
840 | { | ||
841 | // n can't be greater than size of | ||
842 | // the buffers returned by prepare() | ||
843 | 1 | detail::throw_invalid_argument(); | |
844 | } | ||
845 | |||
846 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 38253 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
38253 | BOOST_ASSERT(! got_eof_ || n == 0); |
847 | |||
848 |
2/2✓ Branch 1 taken 19226 times.
✓ Branch 2 taken 19027 times.
|
38253 | if(! is_plain()) |
849 | { | ||
850 | // buffered payload | ||
851 | 19226 | cb0_.commit(n); | |
852 | 19226 | break; | |
853 | } | ||
854 | |||
855 | // plain payload | ||
856 | |||
857 |
2/2✓ Branch 0 taken 19007 times.
✓ Branch 1 taken 20 times.
|
19027 | if(how_ == how::in_place) |
858 | { | ||
859 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19007 times.
|
19007 | BOOST_ASSERT(body_buf_ == &cb0_); |
860 | 19007 | cb0_.commit(n); | |
861 |
2/2✓ Branch 0 taken 18993 times.
✓ Branch 1 taken 14 times.
|
19007 | if(h_.md.payload == payload::size) |
862 | { | ||
863 |
2/2✓ Branch 0 taken 17086 times.
✓ Branch 1 taken 1907 times.
|
18993 | if(n < payload_remain_) |
864 | { | ||
865 | 17086 | body_avail_ += n; | |
866 | 17086 | payload_remain_ -= n; | |
867 | 17086 | break; | |
868 | } | ||
869 | 1907 | body_avail_ += payload_remain_; | |
870 | 1907 | payload_remain_ = 0; | |
871 | 1907 | st_ = state::complete; | |
872 | 1907 | break; | |
873 | } | ||
874 | |||
875 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | BOOST_ASSERT( |
876 | h_.md.payload == payload::to_eof); | ||
877 | 14 | body_avail_ += n; | |
878 | 14 | break; | |
879 | } | ||
880 | |||
881 |
1/2✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.
|
20 | if(how_ == how::elastic) |
882 | { | ||
883 |
2/2✓ Branch 2 taken 19 times.
✓ Branch 3 taken 1 times.
|
20 | if(eb_->size() < eb_->max_size()) |
884 | { | ||
885 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
|
19 | BOOST_ASSERT(body_avail_ == 0); |
886 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
|
19 | BOOST_ASSERT( |
887 | body_buf_->size() == 0); | ||
888 | 19 | eb_->commit(n); | |
889 | } | ||
890 | else | ||
891 | { | ||
892 | // If we get here then either | ||
893 | // n==0 as a no-op, or n==1 for | ||
894 | // an intended one byte read. | ||
895 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | BOOST_ASSERT(n <= 1); |
896 | 1 | body_buf_->commit(n); | |
897 | 1 | body_avail_ += n; | |
898 | } | ||
899 | 20 | body_total_ += n; | |
900 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 14 times.
|
20 | if(h_.md.payload == payload::size) |
901 | { | ||
902 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | BOOST_ASSERT( |
903 | n <= payload_remain_); | ||
904 | 6 | payload_remain_ -= n; | |
905 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | if(payload_remain_ == 0) |
906 | 6 | st_ = state::complete; | |
907 | } | ||
908 | 20 | break; | |
909 | } | ||
910 | |||
911 | ✗ | if(how_ == how::sink) | |
912 | { | ||
913 | ✗ | cb0_.commit(n); | |
914 | ✗ | break; | |
915 | } | ||
916 | ✗ | break; | |
917 | } | ||
918 | |||
919 | 2 | case state::set_body: | |
920 | { | ||
921 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | if(n > nprepare_) |
922 | { | ||
923 | // n can't be greater than size of | ||
924 | // the buffers returned by prepare() | ||
925 | 1 | detail::throw_invalid_argument(); | |
926 | } | ||
927 | |||
928 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | BOOST_ASSERT(is_plain()); |
929 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | BOOST_ASSERT(n == 0); |
930 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if( how_ == how::elastic || |
931 | ✗ | how_ == how::sink) | |
932 | { | ||
933 | // intended no-op | ||
934 | break; | ||
935 | } | ||
936 | |||
937 | // VFALCO TODO | ||
938 | ✗ | detail::throw_logic_error(); | |
939 | } | ||
940 | |||
941 | 4 | case state::complete: | |
942 | { | ||
943 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | BOOST_ASSERT(nprepare_ == 0); |
944 | |||
945 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
|
4 | if(n > 0) |
946 | { | ||
947 | // n can't be greater than size of | ||
948 | // the buffers returned by prepare() | ||
949 | 1 | detail::throw_invalid_argument(); | |
950 | } | ||
951 | |||
952 | // intended no-op | ||
953 | 3 | break; | |
954 | } | ||
955 | } | ||
956 | 47880 | } | |
957 | |||
958 | void | ||
959 | 363 | parser:: | |
960 | commit_eof() | ||
961 | { | ||
962 | 363 | nprepare_ = 0; // invalidate | |
963 | |||
964 |
6/6✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 127 times.
✓ Branch 4 taken 212 times.
✓ Branch 5 taken 1 times.
|
363 | switch(st_) |
965 | { | ||
966 | 1 | default: | |
967 | case state::reset: | ||
968 | // reset must be called first | ||
969 | 1 | detail::throw_logic_error(); | |
970 | |||
971 | 1 | case state::start: | |
972 | // forgot to call prepare() | ||
973 | 1 | detail::throw_logic_error(); | |
974 | |||
975 | 21 | case state::header: | |
976 | 21 | got_eof_ = true; | |
977 | 21 | break; | |
978 | |||
979 | 127 | case state::body: | |
980 | 127 | got_eof_ = true; | |
981 | 127 | break; | |
982 | |||
983 | 212 | case state::set_body: | |
984 | 212 | got_eof_ = true; | |
985 | 212 | break; | |
986 | |||
987 | 1 | case state::complete: | |
988 | // can't commit eof when complete | ||
989 | 1 | detail::throw_logic_error(); | |
990 | } | ||
991 | 360 | } | |
992 | |||
993 | //----------------------------------------------- | ||
994 | |||
995 | // process input data then | ||
996 | // eof if input data runs out. | ||
997 | void | ||
998 | 52801 | parser:: | |
999 | parse( | ||
1000 | system::error_code& ec) | ||
1001 | { | ||
1002 | 52801 | ec = {}; | |
1003 |
6/6✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 13631 times.
✓ Branch 3 taken 36466 times.
✓ Branch 4 taken 211 times.
✓ Branch 5 taken 2491 times.
|
52801 | switch(st_) |
1004 | { | ||
1005 | 1 | default: | |
1006 | case state::reset: | ||
1007 | // reset must be called first | ||
1008 | 1 | detail::throw_logic_error(); | |
1009 | |||
1010 | 1 | case state::start: | |
1011 | // start must be called first | ||
1012 | 1 | detail::throw_logic_error(); | |
1013 | |||
1014 | 13631 | case state::header: | |
1015 | { | ||
1016 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 13631 times.
|
13631 | BOOST_ASSERT(h_.buf == static_cast< |
1017 | void const*>(ws_.data())); | ||
1018 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 13631 times.
|
13631 | BOOST_ASSERT(h_.cbuf == static_cast< |
1019 | void const*>(ws_.data())); | ||
1020 | |||
1021 | 13631 | h_.parse(fb_.size(), svc_.cfg.headers, ec); | |
1022 | |||
1023 |
2/2✓ Branch 2 taken 3792 times.
✓ Branch 3 taken 9839 times.
|
13631 | if(ec == condition::need_more_input) |
1024 | { | ||
1025 |
2/2✓ Branch 0 taken 3774 times.
✓ Branch 1 taken 18 times.
|
3792 | if(! got_eof_) |
1026 | { | ||
1027 | // headers incomplete | ||
1028 | 3774 | return; | |
1029 | } | ||
1030 | |||
1031 |
2/2✓ Branch 1 taken 8 times.
✓ Branch 2 taken 10 times.
|
18 | if(fb_.size() == 0) |
1032 | { | ||
1033 | // stream closed cleanly | ||
1034 | 8 | st_ = state::complete; | |
1035 | 16 | ec = BOOST_HTTP_PROTO_ERR( | |
1036 | error::end_of_stream); | ||
1037 | 8 | return; | |
1038 | } | ||
1039 | |||
1040 | // stream closed with a | ||
1041 | // partial message received | ||
1042 | 10 | st_ = state::reset; | |
1043 | 20 | ec = BOOST_HTTP_PROTO_ERR( | |
1044 | error::incomplete); | ||
1045 | 10 | return; | |
1046 | } | ||
1047 |
2/2✓ Branch 1 taken 259 times.
✓ Branch 2 taken 9580 times.
|
9839 | if(ec.failed()) |
1048 | { | ||
1049 | // other error, | ||
1050 | // | ||
1051 | // VFALCO map this to a bad | ||
1052 | // request or bad response error? | ||
1053 | // | ||
1054 | 259 | st_ = state::reset; // unrecoverable | |
1055 | 259 | return; | |
1056 | } | ||
1057 | |||
1058 | // headers are complete | ||
1059 | 9580 | on_headers(ec); | |
1060 |
2/2✓ Branch 1 taken 120 times.
✓ Branch 2 taken 9460 times.
|
9580 | if(ec.failed()) |
1061 | 120 | return; | |
1062 |
2/2✓ Branch 0 taken 865 times.
✓ Branch 1 taken 8595 times.
|
9460 | if(st_ == state::complete) |
1063 | 865 | break; | |
1064 | |||
1065 | BOOST_FALLTHROUGH; | ||
1066 | } | ||
1067 | |||
1068 | case state::body: | ||
1069 | { | ||
1070 | 8595 | do_body: | |
1071 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 45163 times.
|
45163 | BOOST_ASSERT(st_ == state::body); |
1072 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 45163 times.
|
45163 | BOOST_ASSERT( |
1073 | h_.md.payload != payload::none); | ||
1074 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 45163 times.
|
45163 | BOOST_ASSERT( |
1075 | h_.md.payload != payload::error); | ||
1076 | |||
1077 |
2/2✓ Branch 0 taken 23357 times.
✓ Branch 1 taken 21806 times.
|
45163 | if( h_.md.payload == payload::chunked ) |
1078 | { | ||
1079 |
1/2✓ Branch 0 taken 23357 times.
✗ Branch 1 not taken.
|
23357 | if( how_ == how::in_place ) |
1080 | { | ||
1081 | 23357 | auto& input = cb0_; | |
1082 | 23357 | auto& output = cb1_; | |
1083 | 23357 | auto rv = parse_chunked( | |
1084 | 23357 | input, output, chunk_remain_, body_avail_, | |
1085 |
1/2✓ Branch 1 taken 23357 times.
✗ Branch 2 not taken.
|
23357 | needs_chunk_close_, trailer_headers_); |
1086 |
2/2✓ Branch 1 taken 19236 times.
✓ Branch 2 taken 4121 times.
|
23357 | if(rv.has_error()) |
1087 | 19236 | ec = rv.error(); | |
1088 | else | ||
1089 | 4121 | st_ = state::complete; | |
1090 | 23357 | return; | |
1091 | } | ||
1092 | else | ||
1093 | ✗ | detail::throw_logic_error(); | |
1094 | |||
1095 | } | ||
1096 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21806 times.
|
21806 | else if( filt_ ) |
1097 | { | ||
1098 | // VFALCO TODO apply filter | ||
1099 | ✗ | detail::throw_logic_error(); | |
1100 | } | ||
1101 | |||
1102 |
2/2✓ Branch 0 taken 21679 times.
✓ Branch 1 taken 127 times.
|
21806 | if(how_ == how::in_place) |
1103 | { | ||
1104 |
2/2✓ Branch 0 taken 21316 times.
✓ Branch 1 taken 363 times.
|
21679 | if(h_.md.payload == payload::size) |
1105 | { | ||
1106 | 21316 | if(body_avail_ < | |
1107 |
2/2✓ Branch 0 taken 19011 times.
✓ Branch 1 taken 2305 times.
|
21316 | h_.md.payload_size) |
1108 | { | ||
1109 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 19010 times.
|
19011 | if(got_eof_) |
1110 | { | ||
1111 | // incomplete | ||
1112 | 2 | ec = BOOST_HTTP_PROTO_ERR( | |
1113 | error::incomplete); | ||
1114 | 1 | return; | |
1115 | } | ||
1116 |
2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 19009 times.
|
19010 | if(body_buf_->capacity() == 0) |
1117 | { | ||
1118 | // in_place buffer limit | ||
1119 | 2 | ec = BOOST_HTTP_PROTO_ERR( | |
1120 | error::in_place_overflow); | ||
1121 | 1 | return; | |
1122 | } | ||
1123 | 38018 | ec = BOOST_HTTP_PROTO_ERR( | |
1124 | error::need_data); | ||
1125 | 19009 | return; | |
1126 | } | ||
1127 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2305 times.
|
2305 | BOOST_ASSERT(body_avail_ == |
1128 | h_.md.payload_size); | ||
1129 | 2305 | st_ = state::complete; | |
1130 | 2305 | break; | |
1131 | } | ||
1132 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 362 times.
|
363 | if(body_avail_ > svc_.cfg.body_limit) |
1133 | { | ||
1134 | 2 | ec = BOOST_HTTP_PROTO_ERR( | |
1135 | error::body_too_large); | ||
1136 | 1 | st_ = state::reset; // unrecoverable | |
1137 | 1 | return; | |
1138 | } | ||
1139 |
1/2✓ Branch 0 taken 362 times.
✗ Branch 1 not taken.
|
362 | if( h_.md.payload == payload::chunked || |
1140 |
2/2✓ Branch 0 taken 248 times.
✓ Branch 1 taken 114 times.
|
362 | ! got_eof_) |
1141 | { | ||
1142 | 496 | ec = BOOST_HTTP_PROTO_ERR( | |
1143 | error::need_data); | ||
1144 | 248 | return; | |
1145 | } | ||
1146 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 114 times.
|
114 | BOOST_ASSERT(got_eof_); |
1147 | 114 | st_ = state::complete; | |
1148 | 114 | break; | |
1149 | } | ||
1150 | |||
1151 |
1/2✓ Branch 0 taken 127 times.
✗ Branch 1 not taken.
|
127 | if(how_ == how::elastic) |
1152 | { | ||
1153 | // state already updated in commit | ||
1154 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 127 times.
|
127 | if(h_.md.payload == payload::size) |
1155 | { | ||
1156 | ✗ | BOOST_ASSERT(body_total_ < | |
1157 | h_.md.payload_size); | ||
1158 | ✗ | BOOST_ASSERT(payload_remain_ > 0); | |
1159 | ✗ | if(body_avail_ != 0) | |
1160 | { | ||
1161 | ✗ | BOOST_ASSERT( | |
1162 | eb_->max_size() - | ||
1163 | eb_->size() < | ||
1164 | payload_remain_); | ||
1165 | ✗ | ec = BOOST_HTTP_PROTO_ERR( | |
1166 | error::buffer_overflow); | ||
1167 | ✗ | st_ = state::reset; // unrecoverable | |
1168 | ✗ | return; | |
1169 | } | ||
1170 | ✗ | if(got_eof_) | |
1171 | { | ||
1172 | ✗ | ec = BOOST_HTTP_PROTO_ERR( | |
1173 | error::incomplete); | ||
1174 | ✗ | st_ = state::reset; // unrecoverable | |
1175 | ✗ | return; | |
1176 | } | ||
1177 | ✗ | return; | |
1178 | } | ||
1179 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 127 times.
|
127 | BOOST_ASSERT( |
1180 | h_.md.payload == payload::to_eof); | ||
1181 |
3/4✓ Branch 2 taken 46 times.
✓ Branch 3 taken 81 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 127 times.
|
173 | if( eb_->size() == eb_->max_size() && |
1182 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.
|
46 | body_avail_ > 0) |
1183 | { | ||
1184 | // got here from the 1-byte read | ||
1185 | ✗ | ec = BOOST_HTTP_PROTO_ERR( | |
1186 | error::buffer_overflow); | ||
1187 | ✗ | st_ = state::reset; // unrecoverable | |
1188 | ✗ | return; | |
1189 | } | ||
1190 |
2/2✓ Branch 0 taken 113 times.
✓ Branch 1 taken 14 times.
|
127 | if(got_eof_) |
1191 | { | ||
1192 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 113 times.
|
113 | BOOST_ASSERT(body_avail_ == 0); |
1193 | 113 | st_ = state::complete; | |
1194 | 113 | break; | |
1195 | } | ||
1196 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | BOOST_ASSERT(body_avail_ == 0); |
1197 | 14 | break; | |
1198 | } | ||
1199 | |||
1200 | // VFALCO TODO | ||
1201 | ✗ | detail::throw_logic_error(); | |
1202 | } | ||
1203 | |||
1204 | 211 | case state::set_body: | |
1205 | { | ||
1206 | // transfer in_place data into set body | ||
1207 | |||
1208 |
1/2✓ Branch 0 taken 211 times.
✗ Branch 1 not taken.
|
211 | if(how_ == how::elastic) |
1209 | { | ||
1210 | 211 | init_dynamic(ec); | |
1211 |
1/2✓ Branch 1 taken 211 times.
✗ Branch 2 not taken.
|
211 | if(! ec.failed()) |
1212 | { | ||
1213 |
2/2✓ Branch 0 taken 102 times.
✓ Branch 1 taken 109 times.
|
211 | if(st_ == state::body) |
1214 | 102 | goto do_body; | |
1215 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 109 times.
|
109 | BOOST_ASSERT( |
1216 | st_ == state::complete); | ||
1217 | 109 | break; | |
1218 | } | ||
1219 | ✗ | st_ = state::reset; // unrecoverable | |
1220 | ✗ | return; | |
1221 | } | ||
1222 | |||
1223 | ✗ | if(how_ == how::sink) | |
1224 | { | ||
1225 | ✗ | auto n = body_buf_->size(); | |
1226 | ✗ | if(h_.md.payload == payload::size) | |
1227 | { | ||
1228 | // sink_->size_hint(h_.md.payload_size, ec); | ||
1229 | |||
1230 | ✗ | if(n < h_.md.payload_size) | |
1231 | { | ||
1232 | ✗ | auto rv = sink_->write( | |
1233 | ✗ | body_buf_->data(), false); | |
1234 | ✗ | BOOST_ASSERT(rv.ec.failed() || | |
1235 | rv.bytes == body_buf_->size()); | ||
1236 | ✗ | BOOST_ASSERT( | |
1237 | rv.bytes >= body_avail_); | ||
1238 | ✗ | BOOST_ASSERT( | |
1239 | rv.bytes < payload_remain_); | ||
1240 | ✗ | body_buf_->consume(rv.bytes); | |
1241 | ✗ | body_avail_ -= rv.bytes; | |
1242 | ✗ | body_total_ += rv.bytes; | |
1243 | ✗ | payload_remain_ -= rv.bytes; | |
1244 | ✗ | if(rv.ec.failed()) | |
1245 | { | ||
1246 | ✗ | ec = rv.ec; | |
1247 | ✗ | st_ = state::reset; // unrecoverable | |
1248 | ✗ | return; | |
1249 | } | ||
1250 | ✗ | st_ = state::body; | |
1251 | ✗ | goto do_body; | |
1252 | } | ||
1253 | |||
1254 | ✗ | n = static_cast<std::size_t>(h_.md.payload_size); | |
1255 | } | ||
1256 | // complete | ||
1257 | ✗ | BOOST_ASSERT(body_buf_ == &cb0_); | |
1258 | ✗ | auto rv = sink_->write( | |
1259 | ✗ | body_buf_->data(), true); | |
1260 | ✗ | BOOST_ASSERT(rv.ec.failed() || | |
1261 | rv.bytes == body_buf_->size()); | ||
1262 | ✗ | body_buf_->consume(rv.bytes); | |
1263 | ✗ | if(rv.ec.failed()) | |
1264 | { | ||
1265 | ✗ | ec = rv.ec; | |
1266 | ✗ | st_ = state::reset; // unrecoverable | |
1267 | ✗ | return; | |
1268 | } | ||
1269 | ✗ | st_ = state::complete; | |
1270 | ✗ | return; | |
1271 | } | ||
1272 | |||
1273 | // VFALCO TODO | ||
1274 | ✗ | detail::throw_logic_error(); | |
1275 | } | ||
1276 | |||
1277 | 2491 | case state::complete: | |
1278 | { | ||
1279 | // This is a no-op except when set_body | ||
1280 | // was called and we have in-place data. | ||
1281 |
2/3✓ Branch 0 taken 2195 times.
✓ Branch 1 taken 296 times.
✗ Branch 2 not taken.
|
2491 | switch(how_) |
1282 | { | ||
1283 | 2195 | default: | |
1284 | case how::in_place: | ||
1285 | 2195 | break; | |
1286 | |||
1287 | 296 | case how::elastic: | |
1288 | { | ||
1289 |
1/2✓ Branch 1 taken 296 times.
✗ Branch 2 not taken.
|
296 | if(body_buf_->size() == 0) |
1290 | 296 | break; | |
1291 | ✗ | BOOST_ASSERT(eb_->size() == 0); | |
1292 | ✗ | auto n = buffers::buffer_copy( | |
1293 | ✗ | eb_->prepare( | |
1294 | ✗ | body_buf_->size()), | |
1295 | ✗ | body_buf_->data()); | |
1296 | ✗ | body_buf_->consume(n); | |
1297 | ✗ | break; | |
1298 | } | ||
1299 | |||
1300 | ✗ | case how::sink: | |
1301 | { | ||
1302 | ✗ | if(body_buf_->size() == 0) | |
1303 | ✗ | break; | |
1304 | ✗ | auto rv = sink_->write( | |
1305 | ✗ | body_buf_->data(), false); | |
1306 | ✗ | body_buf_->consume(rv.bytes); | |
1307 | ✗ | if(rv.ec.failed()) | |
1308 | { | ||
1309 | ✗ | ec = rv.ec; | |
1310 | ✗ | st_ = state::reset; // unrecoverable | |
1311 | ✗ | return; | |
1312 | } | ||
1313 | ✗ | break; | |
1314 | } | ||
1315 | } | ||
1316 | } | ||
1317 | } | ||
1318 | } | ||
1319 | |||
1320 | //------------------------------------------------ | ||
1321 | |||
1322 | auto | ||
1323 | 37962 | parser:: | |
1324 | pull_body() -> | ||
1325 | const_buffers_type | ||
1326 | { | ||
1327 |
1/2✓ Branch 0 taken 37962 times.
✗ Branch 1 not taken.
|
37962 | switch(st_) |
1328 | { | ||
1329 | 37962 | case state::body: | |
1330 | case state::complete: | ||
1331 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37962 times.
|
37962 | if(how_ != how::in_place) |
1332 | ✗ | detail::throw_logic_error(); | |
1333 | 37962 | cbp_ = buffers::prefix(body_buf_->data(), | |
1334 | 37962 | static_cast<std::size_t>(body_avail_)); | |
1335 | 37962 | return const_buffers_type{ cbp_ }; | |
1336 | ✗ | default: | |
1337 | ✗ | detail::throw_logic_error(); | |
1338 | } | ||
1339 | } | ||
1340 | |||
1341 | void | ||
1342 | 37962 | parser:: | |
1343 | consume_body(std::size_t n) | ||
1344 | { | ||
1345 |
1/2✓ Branch 0 taken 37962 times.
✗ Branch 1 not taken.
|
37962 | switch(st_) |
1346 | { | ||
1347 | 37962 | case state::body: | |
1348 | case state::complete: | ||
1349 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37962 times.
|
37962 | if(how_ != how::in_place) |
1350 | ✗ | detail::throw_logic_error(); | |
1351 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37962 times.
|
37962 | BOOST_ASSERT(n <= body_avail_); |
1352 | 37962 | body_buf_->consume(n); | |
1353 | 37962 | body_avail_ -= n; | |
1354 | 37962 | return; | |
1355 | ✗ | default: | |
1356 | ✗ | detail::throw_logic_error(); | |
1357 | } | ||
1358 | } | ||
1359 | |||
1360 | core::string_view | ||
1361 | 1392 | parser:: | |
1362 | body() const noexcept | ||
1363 | { | ||
1364 |
2/2✓ Branch 0 taken 349 times.
✓ Branch 1 taken 1043 times.
|
1392 | switch(st_) |
1365 | { | ||
1366 | 349 | default: | |
1367 | case state::reset: | ||
1368 | case state::start: | ||
1369 | case state::header: | ||
1370 | case state::body: | ||
1371 | case state::set_body: | ||
1372 | // not complete | ||
1373 | 349 | return {}; | |
1374 | |||
1375 | 1043 | case state::complete: | |
1376 |
2/2✓ Branch 0 taken 346 times.
✓ Branch 1 taken 697 times.
|
1043 | if(how_ != how::in_place) |
1377 | { | ||
1378 | // not in_place | ||
1379 | 346 | return {}; | |
1380 | } | ||
1381 | 697 | auto cbp = body_buf_->data(); | |
1382 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 697 times.
|
697 | BOOST_ASSERT(cbp[1].size() == 0); |
1383 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 697 times.
|
697 | BOOST_ASSERT(cbp[0].size() == body_avail_); |
1384 | 697 | return core::string_view( | |
1385 | static_cast<char const*>( | ||
1386 | 697 | cbp[0].data()), | |
1387 | 1394 | static_cast<std::size_t>(body_avail_)); | |
1388 | } | ||
1389 | } | ||
1390 | |||
1391 | core::string_view | ||
1392 | ✗ | parser:: | |
1393 | release_buffered_data() noexcept | ||
1394 | { | ||
1395 | ✗ | return {}; | |
1396 | } | ||
1397 | |||
1398 | //------------------------------------------------ | ||
1399 | // | ||
1400 | // Implementation | ||
1401 | // | ||
1402 | //------------------------------------------------ | ||
1403 | |||
1404 | auto | ||
1405 | 314 | parser:: | |
1406 | safe_get_header() const -> | ||
1407 | detail::header const* | ||
1408 | { | ||
1409 | // headers must be received | ||
1410 |
3/6✓ Branch 1 taken 314 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 314 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 314 times.
|
628 | if( ! got_header() || |
1411 | 314 | fb_.size() == 0) // happens on eof | |
1412 | ✗ | detail::throw_logic_error(); | |
1413 | |||
1414 | 314 | return &h_; | |
1415 | } | ||
1416 | |||
1417 | bool | ||
1418 | 93350 | parser:: | |
1419 | is_plain() const noexcept | ||
1420 | { | ||
1421 |
1/2✓ Branch 0 taken 93350 times.
✗ Branch 1 not taken.
|
186700 | return ! filt_ && |
1422 |
2/2✓ Branch 0 taken 46768 times.
✓ Branch 1 taken 46582 times.
|
93350 | h_.md.payload != |
1423 | 93350 | payload::chunked; | |
1424 | } | ||
1425 | |||
1426 | // Called immediately after complete headers are received | ||
1427 | // to setup the circular buffers for subsequent operations. | ||
1428 | // We leave fb_ as-is to indicate whether any data was | ||
1429 | // received before eof. | ||
1430 | // | ||
1431 | void | ||
1432 | 9580 | parser:: | |
1433 | on_headers( | ||
1434 | system::error_code& ec) | ||
1435 | { | ||
1436 | // overread currently includes any and all octets that | ||
1437 | // extend beyond the current end of the header | ||
1438 | // this can include associated body octets for the | ||
1439 | // current message or octets of the next message in the | ||
1440 | // stream, e.g. pipelining is being used | ||
1441 | 9580 | auto const overread = fb_.size() - h_.size; | |
1442 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9580 times.
|
9580 | BOOST_ASSERT( |
1443 | overread <= svc_.max_overread()); | ||
1444 | |||
1445 | // metadata error | ||
1446 |
2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 9460 times.
|
9580 | if(h_.md.payload == payload::error) |
1447 | { | ||
1448 | // VFALCO This needs looking at | ||
1449 | 240 | ec = BOOST_HTTP_PROTO_ERR( | |
1450 | error::bad_payload); | ||
1451 | 120 | st_ = state::reset; // unrecoverable | |
1452 | 5449 | return; | |
1453 | } | ||
1454 | |||
1455 | // reserve headers + table | ||
1456 |
1/2✓ Branch 1 taken 9460 times.
✗ Branch 2 not taken.
|
9460 | ws_.reserve_front(h_.size); |
1457 |
1/2✓ Branch 2 taken 9460 times.
✗ Branch 3 not taken.
|
9460 | ws_.reserve_back(h_.table_space()); |
1458 | |||
1459 | // no payload | ||
1460 |
2/2✓ Branch 0 taken 8595 times.
✓ Branch 1 taken 865 times.
|
9460 | if( h_.md.payload == payload::none || |
1461 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8595 times.
|
8595 | head_response_ ) |
1462 | { | ||
1463 | // set cb0_ to overread | ||
1464 | 1730 | cb0_ = { | |
1465 | 865 | ws_.data(), | |
1466 |
1/2✓ Branch 2 taken 865 times.
✗ Branch 3 not taken.
|
865 | overread + fb_.capacity(), |
1467 | overread }; | ||
1468 | 865 | body_avail_ = 0; | |
1469 | 865 | body_total_ = 0; | |
1470 | 865 | body_buf_ = &cb0_; | |
1471 | 865 | st_ = state::complete; | |
1472 | 865 | return; | |
1473 | } | ||
1474 | |||
1475 | // calculate filter | ||
1476 | 8595 | filt_ = nullptr; // VFALCO TODO | |
1477 | |||
1478 |
2/2✓ Branch 1 taken 4464 times.
✓ Branch 2 taken 4131 times.
|
8595 | if(is_plain()) |
1479 | { | ||
1480 | // plain payload | ||
1481 |
2/2✓ Branch 0 taken 4229 times.
✓ Branch 1 taken 235 times.
|
4464 | if(h_.md.payload == payload::size) |
1482 | { | ||
1483 | 4229 | if(h_.md.payload_size > | |
1484 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4229 times.
|
4229 | svc_.cfg.body_limit) |
1485 | { | ||
1486 | ✗ | ec = BOOST_HTTP_PROTO_ERR( | |
1487 | error::body_too_large); | ||
1488 | ✗ | st_ = state::reset; // unrecoverable | |
1489 | ✗ | return; | |
1490 | } | ||
1491 | |||
1492 | // for plain messages with a known size,, we can | ||
1493 | // get away with only using cb0_ as our input | ||
1494 | // area and leaving cb1_ blank | ||
1495 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4229 times.
|
4229 | BOOST_ASSERT(fb_.max_size() >= h_.size); |
1496 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 4229 times.
|
4229 | BOOST_ASSERT( |
1497 | fb_.max_size() - h_.size == | ||
1498 | overread + fb_.capacity()); | ||
1499 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 4229 times.
|
4229 | BOOST_ASSERT(fb_.data().data() == h_.buf); |
1500 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4229 times.
|
4229 | BOOST_ASSERT(svc_.max_codec == 0); |
1501 | auto cap = | ||
1502 | 4229 | (overread + fb_.capacity()) + // reuse previously designated storage | |
1503 | 4229 | svc_.cfg.min_buffer + // minimum buffer size for prepare() calls | |
1504 | 4229 | svc_.max_codec; // tentatively we can delete this | |
1505 | |||
1506 |
6/6✓ Branch 0 taken 3688 times.
✓ Branch 1 taken 541 times.
✓ Branch 2 taken 2455 times.
✓ Branch 3 taken 1233 times.
✓ Branch 4 taken 2455 times.
✓ Branch 5 taken 1774 times.
|
7917 | if( cap > h_.md.payload_size && |
1507 | 3688 | cap - h_.md.payload_size >= svc_.max_overread() ) | |
1508 | { | ||
1509 | // we eagerly process octets as they arrive, | ||
1510 | // so it's important to limit potential | ||
1511 | // overread as applying a transformation algo | ||
1512 | // can be prohibitively expensive | ||
1513 | 2455 | cap = | |
1514 | 2455 | static_cast<std::size_t>(h_.md.payload_size) + | |
1515 | 2455 | svc_.max_overread(); | |
1516 | } | ||
1517 | |||
1518 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4229 times.
|
4229 | BOOST_ASSERT(cap <= ws_.size()); |
1519 | |||
1520 |
1/2✓ Branch 2 taken 4229 times.
✗ Branch 3 not taken.
|
4229 | cb0_ = { ws_.data(), cap, overread }; |
1521 | 4229 | cb1_ = {}; | |
1522 | |||
1523 | 4229 | body_buf_ = &cb0_; | |
1524 | 4229 | body_avail_ = cb0_.size(); | |
1525 |
2/2✓ Branch 0 taken 2305 times.
✓ Branch 1 taken 1924 times.
|
4229 | if( body_avail_ >= h_.md.payload_size) |
1526 | 2305 | body_avail_ = h_.md.payload_size; | |
1527 | |||
1528 | 4229 | body_total_ = body_avail_; | |
1529 | 4229 | payload_remain_ = | |
1530 | 4229 | h_.md.payload_size - body_total_; | |
1531 | |||
1532 | 4229 | st_ = state::body; | |
1533 | 4229 | return; | |
1534 | } | ||
1535 | |||
1536 | // overread is not applicable | ||
1537 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 235 times.
|
235 | BOOST_ASSERT( |
1538 | h_.md.payload == payload::to_eof); | ||
1539 | auto const n0 = | ||
1540 | 235 | fb_.capacity() - h_.size + | |
1541 | 235 | svc_.cfg.min_buffer + | |
1542 | 235 | svc_.max_codec; | |
1543 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 235 times.
|
235 | BOOST_ASSERT(n0 <= ws_.size()); |
1544 |
1/2✓ Branch 2 taken 235 times.
✗ Branch 3 not taken.
|
235 | cb0_ = { ws_.data(), n0, overread }; |
1545 | 235 | body_buf_ = &cb0_; | |
1546 | 235 | body_avail_ = cb0_.size(); | |
1547 | 235 | body_total_ = body_avail_; | |
1548 | 235 | st_ = state::body; | |
1549 | 235 | return; | |
1550 | } | ||
1551 | |||
1552 | // buffered payload | ||
1553 | |||
1554 | // TODO: need to handle the case where we have so much | ||
1555 | // overread or such an initially large chunk that we | ||
1556 | // don't have enough room in cb1_ for the output | ||
1557 | // perhaps we just return with an error and ask the user | ||
1558 | // to attach a body style | ||
1559 | 4131 | auto size = ws_.size(); | |
1560 | |||
1561 | 4131 | auto n0 = (std::max)(svc_.cfg.min_buffer, overread); | |
1562 | 4131 | n0 = (std::max)(n0, size / 2); | |
1563 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4131 times.
|
4131 | if( filt_) |
1564 | ✗ | n0 += svc_.max_codec; | |
1565 | |||
1566 | 4131 | auto n1 = size - n0; | |
1567 | |||
1568 | // BOOST_ASSERT(n0 <= svc_.max_overread()); | ||
1569 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4131 times.
|
4131 | BOOST_ASSERT(n0 + n1 <= ws_.size()); |
1570 |
1/2✓ Branch 2 taken 4131 times.
✗ Branch 3 not taken.
|
4131 | cb0_ = { ws_.data(), n0, overread }; |
1571 | 4131 | cb1_ = { ws_.data() + n0, n1 }; | |
1572 | 4131 | body_buf_ = &cb1_; | |
1573 | // body_buf_ = nullptr; | ||
1574 | 4131 | body_avail_ = 0; | |
1575 | 4131 | body_total_ = 0; | |
1576 | 4131 | st_ = state::body; | |
1577 | } | ||
1578 | |||
1579 | // Called at the end of set_body | ||
1580 | void | ||
1581 | 299 | parser:: | |
1582 | on_set_body() | ||
1583 | { | ||
1584 | // This function is called after all | ||
1585 | // limit checking and calculation of | ||
1586 | // chunked or filter. | ||
1587 | |||
1588 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 299 times.
|
299 | BOOST_ASSERT(got_header()); |
1589 | |||
1590 | 299 | nprepare_ = 0; // invalidate | |
1591 | |||
1592 |
1/2✓ Branch 0 taken 299 times.
✗ Branch 1 not taken.
|
299 | if(how_ == how::elastic) |
1593 | { | ||
1594 |
2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 241 times.
|
299 | if(h_.md.payload == payload::none) |
1595 | { | ||
1596 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 58 times.
|
58 | BOOST_ASSERT(st_ == state::complete); |
1597 | 58 | return; | |
1598 | } | ||
1599 | |||
1600 | 241 | st_ = state::set_body; | |
1601 | 241 | return; | |
1602 | } | ||
1603 | |||
1604 | ✗ | if(how_ == how::sink) | |
1605 | { | ||
1606 | ✗ | if(h_.md.payload == payload::none) | |
1607 | { | ||
1608 | ✗ | BOOST_ASSERT(st_ == state::complete); | |
1609 | // force a trip through parse so | ||
1610 | // we can calculate any error. | ||
1611 | ✗ | st_ = state::set_body; | |
1612 | ✗ | return; | |
1613 | } | ||
1614 | |||
1615 | ✗ | st_ = state::set_body; | |
1616 | ✗ | return; | |
1617 | } | ||
1618 | |||
1619 | // VFALCO TODO | ||
1620 | ✗ | detail::throw_logic_error(); | |
1621 | } | ||
1622 | |||
1623 | void | ||
1624 | 238 | parser:: | |
1625 | init_dynamic( | ||
1626 | system::error_code& ec) | ||
1627 | { | ||
1628 | // attempt to transfer in-place | ||
1629 | // body into the dynamic buffer. | ||
1630 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 238 times.
|
238 | BOOST_ASSERT( |
1631 | body_avail_ == body_buf_->size()); | ||
1632 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 238 times.
|
238 | BOOST_ASSERT( |
1633 | body_total_ == body_avail_); | ||
1634 | auto const space_left = | ||
1635 | 238 | eb_->max_size() - eb_->size(); | |
1636 | |||
1637 |
2/2✓ Branch 0 taken 121 times.
✓ Branch 1 taken 117 times.
|
238 | if(h_.md.payload == payload::size) |
1638 | { | ||
1639 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 120 times.
|
121 | if(space_left < h_.md.payload_size) |
1640 | { | ||
1641 | 2 | ec = BOOST_HTTP_PROTO_ERR( | |
1642 | error::buffer_overflow); | ||
1643 | 1 | return; | |
1644 | } | ||
1645 | // reserve the full size | ||
1646 | 120 | eb_->prepare(static_cast<std::size_t>(h_.md.payload_size)); | |
1647 | // transfer in-place body | ||
1648 | 120 | auto n = static_cast<std::size_t>(body_avail_); | |
1649 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 120 times.
|
120 | if( n > h_.md.payload_size) |
1650 | ✗ | n = static_cast<std::size_t>(h_.md.payload_size); | |
1651 |
1/2✓ Branch 2 taken 120 times.
✗ Branch 3 not taken.
|
120 | eb_->commit( |
1652 | buffers::buffer_copy( | ||
1653 |
1/2✓ Branch 1 taken 120 times.
✗ Branch 2 not taken.
|
120 | eb_->prepare(n), |
1654 | 120 | body_buf_->data())); | |
1655 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 120 times.
|
120 | BOOST_ASSERT(body_avail_ == n); |
1656 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 120 times.
|
120 | BOOST_ASSERT(body_total_ == n); |
1657 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 120 times.
|
120 | BOOST_ASSERT(payload_remain_ == |
1658 | h_.md.payload_size - n); | ||
1659 | 120 | body_buf_->consume(n); | |
1660 | 120 | body_avail_ = 0; | |
1661 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 111 times.
|
120 | if(n < h_.md.payload_size) |
1662 | { | ||
1663 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
|
9 | BOOST_ASSERT( |
1664 | body_buf_->size() == 0); | ||
1665 | 9 | st_ = state::body; | |
1666 | 9 | return; | |
1667 | } | ||
1668 | // complete | ||
1669 | 111 | st_ = state::complete; | |
1670 | 111 | return; | |
1671 | } | ||
1672 | |||
1673 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 117 times.
|
117 | BOOST_ASSERT(h_.md.payload == |
1674 | payload::to_eof); | ||
1675 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 117 times.
|
117 | if(space_left < body_avail_) |
1676 | { | ||
1677 | ✗ | ec = BOOST_HTTP_PROTO_ERR( | |
1678 | error::buffer_overflow); | ||
1679 | ✗ | return; | |
1680 | } | ||
1681 |
1/2✓ Branch 2 taken 117 times.
✗ Branch 3 not taken.
|
117 | eb_->commit( |
1682 | buffers::buffer_copy( | ||
1683 |
1/2✓ Branch 1 taken 117 times.
✗ Branch 2 not taken.
|
117 | eb_->prepare(static_cast<std::size_t>(body_avail_)), |
1684 | 117 | body_buf_->data())); | |
1685 | 117 | body_buf_->consume(static_cast<std::size_t>(body_avail_)); | |
1686 | 117 | body_avail_ = 0; | |
1687 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 117 times.
|
117 | BOOST_ASSERT( |
1688 | body_buf_->size() == 0); | ||
1689 | 117 | st_ = state::body; | |
1690 | } | ||
1691 | |||
1692 | } // http_proto | ||
1693 | } // boost | ||
1694 |