Commit d574875f00db32c40019c69465d450a6a58da67f | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-02-16 17:12:03-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-02-23 02:37:11-07:00
log	d574875f00db32c40019c69465d450a6a58da67f
tree	c19f6263bd774f08a28d17666a41495333eb4f89
parent	3d61890d2405dc861db1e9e5a334ea6f2415a8f1

Revert "std.http: remove 'done' flag"

This reverts commit 42be972a72c86b32ad8403d082ab42763c6facec.

Using a bit to distinguish between headers and trailers is fine. It was
just named and documented poorly.

4 files changed, 71 insertions(+), 76 deletions(-)

lib
- std
  - http
    Client.zig
    Server.zig
    protocol.zig
test
- standalone
  - http.zig

lib/std/http/Client.zig+9-9

...	...	@@ -649,7 +649,7 @@ pub const Request = struct {
649	649	/// Frees all resources associated with the request.
650	650	pub fn deinit(req: *Request) void {
651	651	if (req.connection) \|connection\| {
652		if (req.response.parser.state != .complete) {
	652	if (!req.response.parser.done) {
653	653	// If the response wasn't fully read, then we need to close the connection.
654	654	connection.closing = true;
655	655	}
...	...	@@ -664,7 +664,7 @@ pub const Request = struct {
664	664	// or keep those which will be used.
665	665	// This needs to be kept in sync with deinit and request.
666	666	fn redirect(req: *Request, uri: Uri) !void {
667		assert(req.response.parser.state == .complete);
	667	assert(req.response.parser.done);
668	668
669	669	req.client.connection_pool.release(req.client.allocator, req.connection.?);
670	670	req.connection = null;
...	...	@@ -823,12 +823,12 @@ pub const Request = struct {
823	823	}
824	824
825	825	fn transferRead(req: *Request, buf: []u8) TransferReadError!usize {
826		if (req.response.parser.state == .complete) return 0;
	826	if (req.response.parser.done) return 0;
827	827
828	828	var index: usize = 0;
829	829	while (index == 0) {
830	830	const amt = try req.response.parser.read(req.connection.?, buf[index..], req.response.skip);
831		if (amt == 0 and req.response.parser.state == .complete) break;
	831	if (amt == 0 and req.response.parser.done) break;
832	832	index += amt;
833	833	}
834	834
...	...	@@ -873,7 +873,7 @@ pub const Request = struct {
873	873	if (req.response.status == .@"continue") {
874	874	// We're done parsing the continue response; reset to prepare
875	875	// for the real response.
876		req.response.parser.state = .complete;
	876	req.response.parser.done = true;
877	877	req.response.parser.reset();
878	878
879	879	if (req.handle_continue)
...	...	@@ -885,7 +885,7 @@ pub const Request = struct {
885	885	// we're switching protocols, so this connection is no longer doing http
886	886	if (req.method == .CONNECT and req.response.status.class() == .success) {
887	887	connection.closing = false;
888		req.response.parser.state = .complete;
	888	req.response.parser.done = true;
889	889	return; // the connection is not HTTP past this point
890	890	}
891	891
...	...	@@ -899,7 +899,7 @@ pub const Request = struct {
899	899	if (req.method == .HEAD or req.response.status.class() == .informational or
900	900	req.response.status == .no_content or req.response.status == .not_modified)
901	901	{
902		req.response.parser.state = .complete;
	902	req.response.parser.done = true;
903	903	return; // The response is empty; no further setup or redirection is necessary.
904	904	}
905	905
...	...	@@ -914,7 +914,7 @@ pub const Request = struct {
914	914	} else if (req.response.content_length) \|cl\| {
915	915	req.response.parser.next_chunk_length = cl;
916	916
917		if (cl == 0) req.response.parser.state = .complete;
	917	if (cl == 0) req.response.parser.done = true;
918	918	} else {
919	919	// read until the connection is closed
920	920	req.response.parser.next_chunk_length = std.math.maxInt(u64);
...	...	@@ -973,7 +973,7 @@ pub const Request = struct {
973	973	try req.send(.{});
974	974	} else {
975	975	req.response.skip = false;
976		if (req.response.parser.state != .complete) {
	976	if (!req.response.parser.done) {
977	977	switch (req.response.transfer_compression) {
978	978	.identity => req.response.compression = .none,
979	979	.compress, .@"x-compress" => return error.CompressionUnsupported,

lib/std/http/Server.zig+6-6

...	...	@@ -352,7 +352,7 @@ pub const Response = struct {
352	352	return .reset;
353	353	}
354	354
355		if (res.request.parser.state != .complete) {
	355	if (!res.request.parser.done) {
356	356	// If the response wasn't fully read, then we need to close the connection.
357	357	res.connection.closing = true;
358	358	return .closing;
...	...	@@ -447,12 +447,12 @@ pub const Response = struct {
447	447	}
448	448
449	449	fn transferRead(res: *Response, buf: []u8) TransferReadError!usize {
450		if (res.request.parser.state == .complete) return 0;
	450	if (res.request.parser.done) return 0;
451	451
452	452	var index: usize = 0;
453	453	while (index == 0) {
454	454	const amt = try res.request.parser.read(&res.connection, buf[index..], false);
455		if (amt == 0 and res.request.parser.state == .complete) break;
	455	if (amt == 0 and res.request.parser.done) break;
456	456	index += amt;
457	457	}
458	458
...	...	@@ -502,9 +502,9 @@ pub const Response = struct {
502	502	if (res.request.content_length) \|len\| {
503	503	res.request.parser.next_chunk_length = len;
504	504
505		if (len == 0) res.request.parser.state = .complete;
	505	if (len == 0) res.request.parser.done = true;
506	506	} else {
507		res.request.parser.state = .complete;
	507	res.request.parser.done = true;
508	508	}
509	509	},
510	510	.chunked => {
...	...	@@ -513,7 +513,7 @@ pub const Response = struct {
513	513	},
514	514	}
515	515
516		if (res.request.parser.state != .complete) {
	516	if (!res.request.parser.done) {
517	517	switch (res.request.transfer_compression) {
518	518	.identity => res.request.compression = .none,
519	519	.compress, .@"x-compress" => return error.CompressionUnsupported,

lib/std/http/protocol.zig+55-60

...	...	@@ -7,76 +7,64 @@ const assert = std.debug.assert;
7	7	const use_vectors = builtin.zig_backend != .stage2_x86_64;
8	8
9	9	pub const State = enum {
10		/// Begin header parsing states.
11	10	invalid,
	11
	12	// Begin header and trailer parsing states.
	13
12	14	start,
13	15	seen_n,
14	16	seen_r,
15	17	seen_rn,
16	18	seen_rnr,
17		headers_end,
18		/// Begin transfer-encoding: chunked parsing states.
	19	finished,
	20
	21	// Begin transfer-encoding: chunked parsing states.
	22
19	23	chunk_head_size,
20	24	chunk_head_ext,
21	25	chunk_head_r,
22	26	chunk_data,
23	27	chunk_data_suffix,
24	28	chunk_data_suffix_r,
25		/// When the parser has finished parsing a complete message. A message is
26		/// only complete after the entire body has been read and any trailing
27		/// headers have been parsed.
28		complete,
29	29
30	30	/// Returns true if the parser is in a content state (ie. not waiting for more headers).
31	31	pub fn isContent(self: State) bool {
32	32	return switch (self) {
33		.invalid,
34		.start,
35		.seen_n,
36		.seen_r,
37		.seen_rn,
38		.seen_rnr,
39		=> false,
40
41		.headers_end,
42		.chunk_head_size,
43		.chunk_head_ext,
44		.chunk_head_r,
45		.chunk_data,
46		.chunk_data_suffix,
47		.chunk_data_suffix_r,
48		.complete,
49		=> true,
	33	.invalid, .start, .seen_n, .seen_r, .seen_rn, .seen_rnr => false,
	34	.finished, .chunk_head_size, .chunk_head_ext, .chunk_head_r, .chunk_data, .chunk_data_suffix, .chunk_data_suffix_r => true,
50	35	};
51	36	}
52	37	};
53	38
54	39	pub const HeadersParser = struct {
55		state: State,
	40	state: State = .start,
56	41	/// A fixed buffer of len `max_header_bytes`.
57	42	/// Pointers into this buffer are not stable until after a message is complete.
58	43	header_bytes_buffer: []u8,
59	44	header_bytes_len: u32,
60	45	next_chunk_length: u64,
	46	/// `false`: headers. `true`: trailers.
	47	done: bool,
61	48
62	49	/// Initializes the parser with a provided buffer `buf`.
63	50	pub fn init(buf: []u8) HeadersParser {
64	51	return .{
65		.state = .start,
66	52	.header_bytes_buffer = buf,
67	53	.header_bytes_len = 0,
	54	.done = false,
68	55	.next_chunk_length = 0,
69	56	};
70	57	}
71	58
72	59	/// Reinitialize the parser.
73		/// Asserts the parser is in the `complete` state.
	60	/// Asserts the parser is in the "done" state.
74	61	pub fn reset(hp: *HeadersParser) void {
75		assert(hp.state == .complete);
	62	assert(hp.done);
76	63	hp.* = .{
77	64	.state = .start,
78	65	.header_bytes_buffer = hp.header_bytes_buffer,
79	66	.header_bytes_len = 0,
	67	.done = false,
80	68	.next_chunk_length = 0,
81	69	};
82	70	}
...	...	@@ -101,8 +89,7 @@ pub const HeadersParser = struct {
101	89	while (true) {
102	90	switch (r.state) {
103	91	.invalid => unreachable,
104		.complete => unreachable,
105		.headers_end => return index,
	92	.finished => return index,
106	93	.start => switch (len - index) {
107	94	0 => return index,
108	95	1 => {
...	...	@@ -126,7 +113,7 @@ pub const HeadersParser = struct {
126	113
127	114	switch (b16) {
128	115	int16("\r\n") => r.state = .seen_rn,
129		int16("\n\n") => r.state = .headers_end,
	116	int16("\n\n") => r.state = .finished,
130	117	else => {},
131	118	}
132	119
...	...	@@ -145,7 +132,7 @@ pub const HeadersParser = struct {
145	132
146	133	switch (b16) {
147	134	int16("\r\n") => r.state = .seen_rn,
148		int16("\n\n") => r.state = .headers_end,
	135	int16("\n\n") => r.state = .finished,
149	136	else => {},
150	137	}
151	138
...	...	@@ -170,7 +157,7 @@ pub const HeadersParser = struct {
170	157
171	158	switch (b16) {
172	159	int16("\r\n") => r.state = .seen_rn,
173		int16("\n\n") => r.state = .headers_end,
	160	int16("\n\n") => r.state = .finished,
174	161	else => {},
175	162	}
176	163
...	...	@@ -180,7 +167,7 @@ pub const HeadersParser = struct {
180	167	}
181	168
182	169	switch (b32) {
183		int32("\r\n\r\n") => r.state = .headers_end,
	170	int32("\r\n\r\n") => r.state = .finished,
184	171	else => {},
185	172	}
186	173
...	...	@@ -228,7 +215,7 @@ pub const HeadersParser = struct {
228	215
229	216	switch (b16) {
230	217	int16("\r\n") => r.state = .seen_rn,
231		int16("\n\n") => r.state = .headers_end,
	218	int16("\n\n") => r.state = .finished,
232	219	else => {},
233	220	}
234	221	},
...	...	@@ -245,7 +232,7 @@ pub const HeadersParser = struct {
245	232
246	233	switch (b16) {
247	234	int16("\r\n") => r.state = .seen_rn,
248		int16("\n\n") => r.state = .headers_end,
	235	int16("\n\n") => r.state = .finished,
249	236	else => {},
250	237	}
251	238
...	...	@@ -262,10 +249,10 @@ pub const HeadersParser = struct {
262	249	const b16 = intShift(u16, b32);
263	250
264	251	if (b32 == int32("\r\n\r\n")) {
265		r.state = .headers_end;
	252	r.state = .finished;
266	253	return index + i + 4;
267	254	} else if (b16 == int16("\n\n")) {
268		r.state = .headers_end;
	255	r.state = .finished;
269	256	return index + i + 2;
270	257	}
271	258	}
...	...	@@ -282,7 +269,7 @@ pub const HeadersParser = struct {
282	269
283	270	switch (b16) {
284	271	int16("\r\n") => r.state = .seen_rn,
285		int16("\n\n") => r.state = .headers_end,
	272	int16("\n\n") => r.state = .finished,
286	273	else => {},
287	274	}
288	275
...	...	@@ -302,7 +289,7 @@ pub const HeadersParser = struct {
302	289	0 => return index,
303	290	else => {
304	291	switch (bytes[index]) {
305		'\n' => r.state = .headers_end,
	292	'\n' => r.state = .finished,
306	293	else => r.state = .start,
307	294	}
308	295
...	...	@@ -334,7 +321,7 @@ pub const HeadersParser = struct {
334	321	switch (b16) {
335	322	int16("\r\n") => r.state = .seen_rn,
336	323	int16("\n\r") => r.state = .seen_rnr,
337		int16("\n\n") => r.state = .headers_end,
	324	int16("\n\n") => r.state = .finished,
338	325	else => {},
339	326	}
340	327
...	...	@@ -353,12 +340,12 @@ pub const HeadersParser = struct {
353	340
354	341	switch (b16) {
355	342	int16("\r\n") => r.state = .seen_rn,
356		int16("\n\n") => r.state = .headers_end,
	343	int16("\n\n") => r.state = .finished,
357	344	else => {},
358	345	}
359	346
360	347	switch (b24) {
361		int24("\n\r\n") => r.state = .headers_end,
	348	int24("\n\r\n") => r.state = .finished,
362	349	else => {},
363	350	}
364	351
...	...	@@ -388,8 +375,8 @@ pub const HeadersParser = struct {
388	375	}
389	376
390	377	switch (b16) {
391		int16("\r\n") => r.state = .headers_end,
392		int16("\n\n") => r.state = .headers_end,
	378	int16("\r\n") => r.state = .finished,
	379	int16("\n\n") => r.state = .finished,
393	380	else => {},
394	381	}
395	382
...	...	@@ -401,7 +388,7 @@ pub const HeadersParser = struct {
401	388	0 => return index,
402	389	else => {
403	390	switch (bytes[index]) {
404		'\n' => r.state = .headers_end,
	391	'\n' => r.state = .finished,
405	392	else => r.state = .start,
406	393	}
407	394
...	...	@@ -502,6 +489,13 @@ pub const HeadersParser = struct {
502	489	return len;
503	490	}
504	491
	492	/// Returns whether or not the parser has finished parsing a complete
	493	/// message. A message is only complete after the entire body has been read
	494	/// and any trailing headers have been parsed.
	495	pub fn isComplete(r: *HeadersParser) bool {
	496	return r.done and r.state == .finished;
	497	}
	498
505	499	pub const CheckCompleteHeadError = error{HttpHeadersOversize};
506	500
507	501	/// Pushes `in` into the parser. Returns the number of bytes consumed by
...	...	@@ -532,12 +526,13 @@ pub const HeadersParser = struct {
532	526	/// See `std.http.Client.Connection for an example of `conn`.
533	527	pub fn read(r: *HeadersParser, conn: anytype, buffer: []u8, skip: bool) !usize {
534	528	assert(r.state.isContent());
	529	if (r.done) return 0;
	530
535	531	var out_index: usize = 0;
536	532	while (true) {
537	533	switch (r.state) {
538		.complete => return out_index,
539	534	.invalid, .start, .seen_n, .seen_r, .seen_rn, .seen_rnr => unreachable,
540		.headers_end => {
	535	.finished => {
541	536	const data_avail = r.next_chunk_length;
542	537
543	538	if (skip) {
...	...	@@ -547,8 +542,7 @@ pub const HeadersParser = struct {
547	542	conn.drop(@intCast(nread));
548	543	r.next_chunk_length -= nread;
549	544
550		if (r.next_chunk_length == 0 or nread == 0)
551		r.state = .complete;
	545	if (r.next_chunk_length == 0 or nread == 0) r.done = true;
552	546
553	547	return out_index;
554	548	} else if (out_index < buffer.len) {
...	...	@@ -558,8 +552,7 @@ pub const HeadersParser = struct {
558	552	const nread = try conn.read(buffer[0..can_read]);
559	553	r.next_chunk_length -= nread;
560	554
561		if (r.next_chunk_length == 0 or nread == 0)
562		r.state = .complete;
	555	if (r.next_chunk_length == 0 or nread == 0) r.done = true;
563	556
564	557	return nread;
565	558	} else {
...	...	@@ -576,12 +569,14 @@ pub const HeadersParser = struct {
576	569	.invalid => return error.HttpChunkInvalid,
577	570	.chunk_data => if (r.next_chunk_length == 0) {
578	571	if (std.mem.eql(u8, conn.peek(), "\r\n")) {
579		r.state = .complete;
	572	r.state = .finished;
	573	r.done = true;
580	574	} else {
581		// The trailer section is formatted identically
582		// to the header section.
	575	// The trailer section is formatted identically to the header section.
583	576	r.state = .seen_rn;
584	577	}
	578	r.done = true;
	579
585	580	return out_index;
586	581	},
587	582	else => return out_index,
...	...	@@ -619,21 +614,21 @@ pub const HeadersParser = struct {
619	614	};
620	615
621	616	inline fn int16(array: *const [2]u8) u16 {
622		return @bitCast(array.*);
	617	return @as(u16, @bitCast(array.*));
623	618	}
624	619
625	620	inline fn int24(array: *const [3]u8) u24 {
626		return @bitCast(array.*);
	621	return @as(u24, @bitCast(array.*));
627	622	}
628	623
629	624	inline fn int32(array: *const [4]u8) u32 {
630		return @bitCast(array.*);
	625	return @as(u32, @bitCast(array.*));
631	626	}
632	627
633	628	inline fn intShift(comptime T: type, x: anytype) T {
634	629	switch (@import("builtin").cpu.arch.endian()) {
635		.little => return @truncate(x >> (@bitSizeOf(@TypeOf(x)) - @bitSizeOf(T))),
636		.big => return @truncate(x),
	630	.little => return @as(T, @truncate(x >> (@bitSizeOf(@TypeOf(x)) - @bitSizeOf(T)))),
	631	.big => return @as(T, @truncate(x)),
637	632	}
638	633	}
639	634

test/standalone/http.zig+1-1

...	...	@@ -673,7 +673,7 @@ pub fn main() !void {
673	673	var req = try client.open(.GET, uri, .{
674	674	.server_header_buffer = headers_buf,
675	675	});
676		req.response.parser.state = .complete;
	676	req.response.parser.done = true;
677	677	req.connection.?.closing = false;
678	678	requests[i] = req;
679	679	}