1//! Parser for transfer-encoding: chunked.
2
3const ChunkParser = @This();
4const std = @import("std");
5
6state: State,
7chunk_len: u64,
8
9pub const init: ChunkParser = .{
10 .state = .head_size,
11 .chunk_len = 0,
12};
13
14pub const State = enum {
15 head_size,
16 head_ext,
17 head_r,
18 data,
19 data_suffix,
20 data_suffix_r,
21 invalid,
22};
23
24/// Returns the number of bytes consumed by the chunk size. This is always
25/// less than or equal to `bytes.len`.
26///
27/// After this function returns, `chunk_len` will contain the parsed chunk size
28/// in bytes when `state` is `data`. Alternately, `state` may become `invalid`,
29/// indicating a syntax error in the input stream.
30///
31/// If the amount returned is less than `bytes.len`, the parser is in the
32/// `chunk_data` state and the first byte of the chunk is at `bytes[result]`.
33///
34/// Asserts `state` is neither `data` nor `invalid`.
35pub fn feed(p: *ChunkParser, bytes: []const u8) usize {
36 for (bytes, 0..) |c, i| switch (p.state) {
37 .data_suffix => switch (c) {
38 '\r' => p.state = .data_suffix_r,
39 '\n' => p.state = .head_size,
40 else => {
41 p.state = .invalid;
42 return i;
43 },
44 },
45 .data_suffix_r => switch (c) {
46 '\n' => p.state = .head_size,
47 else => {
48 p.state = .invalid;
49 return i;
50 },
51 },
52 .head_size => {
53 const digit = switch (c) {
54 '0'...'9' => |b| b - '0',
55 'A'...'Z' => |b| b - 'A' + 10,
56 'a'...'z' => |b| b - 'a' + 10,
57 '\r' => {
58 p.state = .head_r;
59 continue;
60 },
61 '\n' => {
62 p.state = .data;
63 return i + 1;
64 },
65 else => {
66 p.state = .head_ext;
67 continue;
68 },
69 };
70
71 const new_len = p.chunk_len *% 16 +% digit;
72 if (new_len <= p.chunk_len and p.chunk_len != 0) {
73 p.state = .invalid;
74 return i;
75 }
76
77 p.chunk_len = new_len;
78 },
79 .head_ext => switch (c) {
80 '\r' => p.state = .head_r,
81 '\n' => {
82 p.state = .data;
83 return i + 1;
84 },
85 else => continue,
86 },
87 .head_r => switch (c) {
88 '\n' => {
89 p.state = .data;
90 return i + 1;
91 },
92 else => {
93 p.state = .invalid;
94 return i;
95 },
96 },
97 .data => unreachable,
98 .invalid => unreachable,
99 };
100 return bytes.len;
101}
102
103test feed {
104 const testing = std.testing;
105
106 const data = "Ff\r\nf0f000 ; ext\n0\r\nffffffffffffffffffffffffffffffffffffffff\r\n";
107
108 var p = init;
109 const first = p.feed(data[0..]);
110 try testing.expectEqual(@as(u32, 4), first);
111 try testing.expectEqual(@as(u64, 0xff), p.chunk_len);
112 try testing.expectEqual(.data, p.state);
113
114 p = init;
115 const second = p.feed(data[first..]);
116 try testing.expectEqual(@as(u32, 13), second);
117 try testing.expectEqual(@as(u64, 0xf0f000), p.chunk_len);
118 try testing.expectEqual(.data, p.state);
119
120 p = init;
121 const third = p.feed(data[first + second ..]);
122 try testing.expectEqual(@as(u32, 3), third);
123 try testing.expectEqual(@as(u64, 0), p.chunk_len);
124 try testing.expectEqual(.data, p.state);
125
126 p = init;
127 const fourth = p.feed(data[first + second + third ..]);
128 try testing.expectEqual(@as(u32, 16), fourth);
129 try testing.expectEqual(@as(u64, 0xffffffffffffffff), p.chunk_len);
130 try testing.expectEqual(.invalid, p.state);
131}