src/rfc/detail/rules.cpp

95.8% Lines (159/0/166) 100.0% List of functions (10/0/10)

[ ] prev/next file n p prev/next uncovered line

rules.cpp

f(x) Functions (10)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2021 Vinnie Falco ([email protected])
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
8		//
9
10		#include "src/rfc/detail/rules.hpp"
11
12		#include <boost/http/error.hpp>
13		#include <boost/http/detail/config.hpp>
14		#include <boost/http/rfc/token_rule.hpp>
15
16		#include <boost/core/detail/string_view.hpp>
17		#include <boost/url/grammar/delim_rule.hpp>
18		#include <boost/url/grammar/digit_chars.hpp>
19		#include <boost/url/grammar/error.hpp>
20		#include <boost/url/grammar/hexdig_chars.hpp>
21		#include <boost/url/grammar/lut_chars.hpp>
22		#include <boost/url/grammar/parse.hpp>
23		#include <boost/url/grammar/tuple_rule.hpp>
24
25		#include "src/rfc/detail/rules.hpp"
26
27		namespace boost {
28		namespace http {
29		namespace detail {
30
31		auto
32	28324x	crlf_rule_t::
33		parse(
34		char const*& it,
35		char const* end) const noexcept ->
36		system::result<value_type>
37		{
38	28324x	if(it == end)
39	6145x	return grammar::error::need_more;
40	22179x	if(*it != '\r')
41	29x	return grammar::error::mismatch;
42	22150x	++it;
43	22150x	if(it == end)
44	887x	return grammar::error::need_more;
45	21263x	if(*it != '\n')
46	51x	return grammar::error::mismatch;
47	21212x	++it;
48	21212x	return {};
49		}
50
51		//------------------------------------------------
52
53		auto
54	26902x	version_rule_t::
55		parse(
56		char const*& it,
57		char const* end) const noexcept ->
58		system::result<value_type>
59		{
60	26902x	value_type v = 0;
61	26902x	if(it == end)
62		{
63		// expected "HTTP/"
64	1511x	BOOST_HTTP_RETURN_EC(
65		grammar::error::need_more);
66		}
67	25391x	if(end - it >= 5)
68		{
69	21085x	if(std::memcmp(
70		it, "HTTP/", 5) != 0)
71		{
72	✗	BOOST_HTTP_RETURN_EC(
73		grammar::error::mismatch);
74		}
75	21085x	it += 5;
76		}
77	25391x	if(it == end)
78		{
79		// expected DIGIT
80	991x	BOOST_HTTP_RETURN_EC(
81		grammar::error::need_more);
82		}
83	24400x	if(! grammar::digit_chars(*it))
84		{
85		// expected DIGIT
86	4306x	BOOST_HTTP_RETURN_EC(
87		grammar::error::need_more);
88		}
89	20094x	v = 10 * (*it++ - '0');
90	20094x	if(it == end)
91		{
92		// expected "."
93	1119x	BOOST_HTTP_RETURN_EC(
94		grammar::error::need_more);
95		}
96	18975x	if(*it != '.')
97		{
98		// expected "."
99	✗	BOOST_HTTP_RETURN_EC(
100		grammar::error::need_more);
101		}
102	18975x	++it;
103	18975x	if(it == end)
104		{
105		// expected DIGIT
106	959x	BOOST_HTTP_RETURN_EC(
107		grammar::error::need_more);
108		}
109	18016x	if(! grammar::digit_chars(*it))
110		{
111		// expected DIGIT
112	✗	BOOST_HTTP_RETURN_EC(
113		grammar::error::need_more);
114		}
115	18016x	v += *it++ - '0';
116	18016x	return v;
117		}
118
119		//------------------------------------------------
120
121		auto
122	7464x	status_code_rule_t::
123		parse(
124		char const*& it,
125		char const* end) const noexcept ->
126		system::result<value_type>
127		{
128		auto const dig =
129	17380x	[](char c) -> int
130		{
131	17380x	unsigned char uc(c - '0');
132	17380x	if(uc > 9)
133	✗	return -1;
134	17380x	return uc;
135		};
136
137	7464x	if(it == end)
138		{
139		// end
140	846x	BOOST_HTTP_RETURN_EC(
141		grammar::error::need_more);
142		}
143	6618x	auto it0 = it;
144	6618x	int v = dig(*it);
145	6618x	if(v == -1)
146		{
147		// expected DIGIT
148	✗	BOOST_HTTP_RETURN_EC(
149		grammar::error::mismatch);
150		}
151	6618x	value_type t;
152	6618x	t.v = 100 * v;
153	6618x	++it;
154	6618x	if(it == end)
155		{
156		// end
157	830x	BOOST_HTTP_RETURN_EC(
158		grammar::error::need_more);
159		}
160	5788x	v = dig(*it);
161	5788x	if(v == -1)
162		{
163		// expected DIGIT
164	✗	BOOST_HTTP_RETURN_EC(
165		grammar::error::mismatch);
166		}
167	5788x	t.v = t.v + (10 * v);
168	5788x	++it;
169	5788x	if(it == end)
170		{
171		// end
172	814x	BOOST_HTTP_RETURN_EC(
173		grammar::error::need_more);
174		}
175	4974x	v = dig(*it);
176	4974x	if(v == -1)
177		{
178		// expected DIGIT
179	✗	BOOST_HTTP_RETURN_EC(
180		grammar::error::need_more);
181		}
182	4974x	t.v = t.v + v;
183	4974x	++it;
184
185	4974x	t.s = core::string_view(it0, it - it0);
186	4974x	t.st = int_to_status(t.v);
187	4974x	return t;
188		}
189
190		//------------------------------------------------
191
192		auto
193	4176x	reason_phrase_rule_t::
194		parse(
195		char const*& it,
196		char const* end) const noexcept ->
197		system::result<value_type>
198		{
199	4176x	auto begin = it;
200	4176x	it = grammar::find_if_not(it, end, ws_vchars);
201	4176x	return core::string_view(begin, it);
202		}
203
204		//------------------------------------------------
205
206		auto
207	25315x	field_name_rule_t::
208		parse(
209		char const*& it,
210		char const* end) const noexcept ->
211		system::result<value_type>
212		{
213	25315x	if( it == end )
214	1x	BOOST_HTTP_RETURN_EC(
215		grammar::error::need_more);
216
217	25314x	value_type v;
218
219	25314x	auto begin = it;
220	25314x	auto rv = grammar::parse(
221		it, end, token_rule);
222	25314x	if( rv.has_error() \|\| (it != end) )
223		{
224	15689x	if( it != begin )
225		{
226	15623x	v = core::string_view(begin, it - begin);
227	15623x	return v;
228		}
229	66x	return error::bad_field_name;
230		}
231
232	9625x	v = core::string_view(begin, end - begin);
233	9625x	return v;
234		}
235
236		auto
237	15892x	field_value_rule_t::
238		parse(
239		char const*& it,
240		char const* end) const noexcept ->
241		system::result<value_type>
242		{
243	15892x	value_type v;
244	15892x	if( it == end )
245		{
246	651x	v.value = core::string_view(it, 0);
247	651x	return v;
248		}
249
250		// field-line = field-name ":" OWS field-value OWS
251		// field-value = *field-content
252		// field-content = field-vchar
253		// [ 1*( SP / HTAB / field-vchar ) field-vchar ]
254		// field-vchar = VCHAR / obs-text
255		// obs-text = %x80-FF
256		// VCHAR = %x21-7E
257		// ; visible (printing) characters
258
259	66283x	auto is_field_vchar = [](unsigned char ch)
260		{
261	66283x	return (ch >= 0x21 && ch <= 0x7e) \|\| ch >= 0x80;
262		};
263
264	15241x	char const* s0 = nullptr;
265	15241x	char const* s1 = nullptr;
266
267	15241x	bool has_crlf = false;
268	15241x	bool has_obs_fold = false;
269
270	99373x	while( it < end )
271		{
272	95991x	auto ch = *it;
273	95991x	if( ws(ch) )
274		{
275	17153x	++it;
276	17153x	continue;
277		}
278
279	78838x	if( ch == '\r' )
280		{
281		// too short to know if we have a potential obs-fold
282		// occurrence
283	12555x	if( end - it < 2 )
284	558x	BOOST_HTTP_RETURN_EC(
285		grammar::error::need_more);
286
287	11997x	if( it[1] != '\n' )
288	53x	goto done;
289
290	11944x	if( end - it < 3 )
291	514x	BOOST_HTTP_RETURN_EC(
292		grammar::error::need_more);
293
294	11430x	if(! ws(it[2]) )
295		{
296	10700x	has_crlf = true;
297	10700x	goto done;
298		}
299
300	730x	has_obs_fold = true;
301	730x	it = it + 3;
302	730x	continue;
303	730x	}
304
305	66283x	if(! is_field_vchar(ch) )
306		{
307	34x	goto done;
308		}
309
310	66249x	if(! s0 )
311	14178x	s0 = it;
312
313	66249x	++it;
314	66249x	s1 = it;
315		}
316
317	3382x	done:
318		// later routines wind up doing pointer
319		// subtraction using the .data() member
320		// of the value so we need a valid 0-len range
321	14169x	if(! s0 )
322		{
323	899x	s0 = it;
324	899x	s1 = s0;
325		}
326
327	14169x	v.value = core::string_view(s0, s1 - s0);
328	14169x	v.has_crlf = has_crlf;
329	14169x	v.has_obs_fold = has_obs_fold;
330	14169x	return v;
331		}
332
333		auto
334	36564x	field_rule_t::
335		parse(
336		char const*& it,
337		char const* end) const noexcept ->
338		system::result<value_type>
339		{
340	36564x	if(it == end)
341		{
342	907x	BOOST_HTTP_RETURN_EC(
343		grammar::error::need_more);
344		}
345		// check for leading CRLF
346	35657x	if(it[0] == '\r')
347		{
348	10583x	++it;
349	10583x	if(it == end)
350		{
351	459x	BOOST_HTTP_RETURN_EC(
352		grammar::error::need_more);
353		}
354	10124x	if(*it != '\n')
355		{
356	21x	BOOST_HTTP_RETURN_EC(
357		grammar::error::mismatch);
358		}
359		// end of fields
360	10103x	++it;
361	10103x	BOOST_HTTP_RETURN_EC(
362		grammar::error::end_of_range);
363		}
364
365	25074x	value_type v;
366		auto rv = grammar::parse(
367	25074x	it, end, grammar::tuple_rule(
368		field_name_rule,
369	25074x	grammar::delim_rule(':'),
370		field_value_rule,
371	25074x	crlf_rule));
372
373	25074x	if( rv.has_error() )
374	14390x	return rv.error();
375
376	10684x	auto val = rv.value();
377	10684x	v.name = std::get<0>(val);
378	10684x	v.value = std::get<2>(val).value;
379	10684x	v.has_obs_fold = std::get<2>(val).has_obs_fold;
380
381	10684x	return v;
382		}
383
384		//------------------------------------------------
385
386		void
387	244x	remove_obs_fold(
388		char* it,
389		char const* const end) noexcept
390		{
391	2262x	while(it != end)
392		{
393	2236x	if(*it != '\r')
394		{
395	1637x	++it;
396	1637x	continue;
397		}
398	599x	if(end - it < 3)
399	218x	break;
400	381x	BOOST_ASSERT(it[1] == '\n');
401	762x	if( it[1] == '\n' &&
402	381x	ws(it[2]))
403		{
404	378x	it[0] = ' ';
405	378x	it[1] = ' ';
406	378x	it += 3;
407		}
408		else
409		{
410	3x	++it;
411		}
412		}
413	244x	}
414
415		} // detail
416		} // http
417		} // boost
418