tickets

21.4 KB

1. // Shared WebSocket core — RFC 6455 framing, transport-agnostic (decision D8).
2. // Compiled into each HTTP plugin like http_common.zig; NOT a standalone .so.
3. //
4. // Responsibilities:
5. // - Sec-WebSocket-Accept computation (SHA1 + base64 of key + RFC GUID)
6. // - Frame encoding (unmasked, server → client) via a write callback
7. // - Frame decoding + message assembly (client-masked inbound), fragmentation,
8. // ping/pong surfacing, close handshake with codes, UTF-8 validation
9. //
10. // The per-protocol handshakes stay in each plugin: h1 = Upgrade/101 (http1.zig),
11. // h2 = RFC 8441 extended CONNECT (future), h3 = RFC 9220 (future). Everything
12. // after the handshake — the byte stream — goes through this module unchanged.
13. //
14. // Transport neutrality: encoding writes through `WriteFn` callbacks and decoding
15. // consumes raw bytes via `Decoder.feed()`; the module never touches a socket.
17. const std = @import("std");
19. pub const GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
21. /// Write callback: return false on transport failure (peer gone).
22. pub const WriteFn = *const fn (ctx: ?*anyopaque, data: []const u8) bool;
24. pub const Opcode = enum(u4) {
25. continuation = 0x0,
26. text = 0x1,
27. binary = 0x2,
28. close = 0x8,
29. ping = 0x9,
30. pong = 0xA,
31. _,
33. pub fn isControl(self: Opcode) bool {
34. return @intFromEnum(self) >= 0x8;
35. }
36. };
38. // Close codes used by the core
39. pub const CLOSE_NORMAL: u16 = 1000;
40. pub const CLOSE_GOING_AWAY: u16 = 1001;
41. pub const CLOSE_PROTOCOL_ERROR: u16 = 1002;
42. pub const CLOSE_INVALID_PAYLOAD: u16 = 1007;
43. pub const CLOSE_TOO_BIG: u16 = 1009;
44. pub const CLOSE_NO_STATUS: u16 = 1005; // synthesized when close frame has no code — never sent on the wire
46. /// Sec-WebSocket-Accept: base64(SHA1(key ++ GUID)). Output is always 28 chars.
47. pub fn computeAcceptKey(key: []const u8, out: *[28]u8) []const u8 {
48. var sha = std.crypto.hash.Sha1.init(.{});
49. sha.update(key);
50. sha.update(GUID);
51. var digest: [20]u8 = undefined;
52. sha.final(&digest);
53. return std.base64.standard.Encoder.encode(out, &digest);
54. }
56. /// Encode a frame header into `buf` (needs >= 10 bytes). Returns header length.
57. /// Server frames are unmasked (RFC 6455 §5.1).
58. pub fn encodeFrameHeader(buf: *[10]u8, opcode: Opcode, payload_len: usize, fin: bool) usize {
59. buf[0] = (if (fin) @as(u8, 0x80) else 0) | @as(u8, @intFromEnum(opcode));
60. if (payload_len <= 125) {
61. buf[1] = @intCast(payload_len);
62. return 2;
63. } else if (payload_len <= 65535) {
64. buf[1] = 126;
65. std.mem.writeInt(u16, buf[2..4], @intCast(payload_len), .big);
66. return 4;
67. } else {
68. buf[1] = 127;
69. std.mem.writeInt(u64, buf[2..10], payload_len, .big);
70. return 10;
71. }
72. }
74. /// Write one complete unmasked frame through the callback. True on success.
75. pub fn writeFrame(write: WriteFn, ctx: ?*anyopaque, opcode: Opcode, payload: []const u8) bool {
76. var hdr: [10]u8 = undefined;
77. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, true);
78. if (!write(ctx, hdr[0..hlen])) return false;
79. if (payload.len > 0 and !write(ctx, payload)) return false;
80. return true;
81. }
83. /// Write a close frame with a code and optional reason (reason truncated to 123).
84. pub fn writeClose(write: WriteFn, ctx: ?*anyopaque, code: u16, reason: []const u8) bool {
85. var payload: [125]u8 = undefined;
86. std.mem.writeInt(u16, payload[0..2], code, .big);
87. const rlen = @min(reason.len, 123);
88. @memcpy(payload[2 .. 2 + rlen], reason[0..rlen]);
89. return writeFrame(write, ctx, .close, payload[0 .. 2 + rlen]);
90. }
92. /// Write one complete MASKED frame — the client's half of RFC 6455 §5.1 ("a
93. /// client MUST mask all frames"). The mask is fresh per frame from the kernel
94. /// CSPRNG (`getrandom(2)`, not a seeded generator: a predictable mask is not
95. /// a security property this module is willing to guess wrong about — same
96. /// reasoning as hl:http1's session-token `randomToken`). A getrandom() short
97. /// read is vanishingly rare for 4 bytes; the leftover is zeroed rather than
98. /// left uninitialized, which only ever makes the mask weaker, never wrong.
99. /// Masking is applied through a small stack buffer so a large payload needs
100. /// no allocation.
101. pub fn writeFrameMasked(write: WriteFn, ctx: ?*anyopaque, opcode: Opcode, payload: []const u8) bool {
102. var hdr: [10]u8 = undefined;
103. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, true);
104. hdr[1] |= 0x80; // mask bit
105. var mask: [4]u8 = .{ 0, 0, 0, 0 };
106. _ = std.os.linux.getrandom(&mask, mask.len, 0);
107. if (!write(ctx, hdr[0..hlen])) return false;
108. if (!write(ctx, &mask)) return false;
109. if (payload.len == 0) return true;
111. var buf: [4096]u8 = undefined;
112. var i: usize = 0;
113. while (i < payload.len) {
114. const n = @min(buf.len, payload.len - i);
115. for (0..n) |j| buf[j] = payload[i + j] ^ mask[(i + j) % 4];
116. if (!write(ctx, buf[0..n])) return false;
117. i += n;
118. }
119. return true;
120. }
122. /// Masked `writeClose` — see `writeFrameMasked`.
123. pub fn writeCloseMasked(write: WriteFn, ctx: ?*anyopaque, code: u16, reason: []const u8) bool {
124. var payload: [125]u8 = undefined;
125. std.mem.writeInt(u16, payload[0..2], code, .big);
126. const rlen = @min(reason.len, 123);
127. @memcpy(payload[2 .. 2 + rlen], reason[0..rlen]);
128. return writeFrameMasked(write, ctx, .close, payload[0 .. 2 + rlen]);
129. }
131. /// A decoded inbound event. Payload slices are allocated with the decoder's
132. /// allocator and owned by the CALLER (free after use).
133. pub const Event = union(enum) {
134. text: []u8,
135. binary: []u8,
136. ping: []u8, // payload to echo in the pong
137. pong: []u8,
138. close: Close,
139. /// Protocol violation — caller should send a close frame with this code
140. /// and drop the connection.
141. protocol_error: u16,
143. pub const Close = struct {
144. code: u16, // CLOSE_NO_STATUS when the frame carried no code
145. reason: []u8,
146. };
148. pub fn deinitPayload(self: *Event, alloc: std.mem.Allocator) void {
149. switch (self.*) {
150. .text, .binary, .ping, .pong => |p| alloc.free(p),
151. .close => |cl| alloc.free(cl.reason),
152. .protocol_error => {},
153. }
154. }
155. };
157. fn validCloseCode(code: u16) bool {
158. return switch (code) {
159. 1000...1003, 1007...1011 => true,
160. 3000...4999 => true,
161. else => false,
162. };
163. }
165. /// Streaming frame decoder + message assembler. One per connection.
166. /// feed() raw transport bytes, then loop next() until it returns null.
167. pub const Decoder = struct {
168. alloc: std.mem.Allocator,
169. /// Client frames must be masked (server side). Set false for client use.
170. require_masked: bool = true,
171. max_message_size: usize = 16 * 1024 * 1024,
173. buf: std.ArrayListUnmanaged(u8) = .empty, // raw incoming bytes
174. read_pos: usize = 0,
175. msg: std.ArrayListUnmanaged(u8) = .empty, // fragmented-message assembly
176. msg_opcode: ?Opcode = null,
177. failed: bool = false, // after a protocol error the stream is dead
179. pub fn init(alloc: std.mem.Allocator) Decoder {
180. return .{ .alloc = alloc };
181. }
183. pub fn deinit(self: *Decoder) void {
184. self.buf.deinit(self.alloc);
185. self.msg.deinit(self.alloc);
186. }
188. pub fn feed(self: *Decoder, bytes: []const u8) !void {
189. // Compact consumed prefix before growing
190. if (self.read_pos > 0) {
191. const remaining = self.buf.items.len - self.read_pos;
192. std.mem.copyForwards(u8, self.buf.items[0..remaining], self.buf.items[self.read_pos..]);
193. self.buf.shrinkRetainingCapacity(remaining);
194. self.read_pos = 0;
195. }
196. try self.buf.appendSlice(self.alloc, bytes);
197. }
199. fn fail(self: *Decoder, code: u16) Event {
200. self.failed = true;
201. return .{ .protocol_error = code };
202. }
204. /// Pop the next complete event, or null if more bytes are needed.
205. pub fn next(self: *Decoder) !?Event {
206. if (self.failed) return null;
207. const data = self.buf.items[self.read_pos..];
208. if (data.len < 2) return null;
210. const b0 = data[0];
211. const b1 = data[1];
212. const fin = (b0 & 0x80) != 0;
213. const rsv = b0 & 0x70;
214. const opcode: Opcode = @enumFromInt(@as(u4, @truncate(b0 & 0x0F)));
215. const masked = (b1 & 0x80) != 0;
216. const len7: u8 = b1 & 0x7F;
218. if (rsv != 0) return self.fail(CLOSE_PROTOCOL_ERROR); // no extensions negotiated
219. switch (@intFromEnum(opcode)) {
220. 0x0, 0x1, 0x2, 0x8, 0x9, 0xA => {},
221. else => return self.fail(CLOSE_PROTOCOL_ERROR),
222. }
223. if (self.require_masked and !masked) return self.fail(CLOSE_PROTOCOL_ERROR);
224. if (opcode.isControl() and (!fin or len7 > 125)) return self.fail(CLOSE_PROTOCOL_ERROR);
226. var offset: usize = 2;
227. var payload_len: u64 = len7;
228. if (len7 == 126) {
229. if (data.len < offset + 2) return null;
230. payload_len = std.mem.readInt(u16, data[offset..][0..2], .big);
231. offset += 2;
232. if (payload_len <= 125) return self.fail(CLOSE_PROTOCOL_ERROR); // non-minimal encoding
233. } else if (len7 == 127) {
234. if (data.len < offset + 8) return null;
235. payload_len = std.mem.readInt(u64, data[offset..][0..8], .big);
236. offset += 8;
237. if (payload_len <= 65535) return self.fail(CLOSE_PROTOCOL_ERROR);
238. if (payload_len > (1 << 62)) return self.fail(CLOSE_PROTOCOL_ERROR); // MSB must be 0
239. }
240. if (payload_len > self.max_message_size or
241. self.msg.items.len + payload_len > self.max_message_size)
242. return self.fail(CLOSE_TOO_BIG);
244. var mask: [4]u8 = .{ 0, 0, 0, 0 };
245. if (masked) {
246. if (data.len < offset + 4) return null;
247. mask = data[offset..][0..4].*;
248. offset += 4;
249. }
251. const plen: usize = @intCast(payload_len);
252. if (data.len < offset + plen) return null; // frame incomplete
254. // Unmask into an owned copy
255. const payload = try self.alloc.alloc(u8, plen);
256. errdefer self.alloc.free(payload);
257. for (0..plen) |i| {
258. payload[i] = data[offset + i] ^ mask[i % 4];
259. }
260. self.read_pos += offset + plen;
262. switch (opcode) {
263. .ping => return .{ .ping = payload },
264. .pong => return .{ .pong = payload },
265. .close => {
266. if (plen == 0) return .{ .close = .{ .code = CLOSE_NO_STATUS, .reason = payload } };
267. if (plen == 1) {
268. self.alloc.free(payload);
269. return self.fail(CLOSE_PROTOCOL_ERROR);
270. }
271. const code = std.mem.readInt(u16, payload[0..2], .big);
272. if (!validCloseCode(code)) {
273. self.alloc.free(payload);
274. return self.fail(CLOSE_PROTOCOL_ERROR);
275. }
276. if (!std.unicode.utf8ValidateSlice(payload[2..])) {
277. self.alloc.free(payload);
278. return self.fail(CLOSE_INVALID_PAYLOAD);
279. }
280. const reason = try self.alloc.alloc(u8, plen - 2);
281. @memcpy(reason, payload[2..]);
282. self.alloc.free(payload);
283. return .{ .close = .{ .code = code, .reason = reason } };
284. },
285. .text, .binary => {
286. if (self.msg_opcode != null) {
287. self.alloc.free(payload);
288. return self.fail(CLOSE_PROTOCOL_ERROR); // new data frame while assembling
289. }
290. if (fin) {
291. if (opcode == .text and !std.unicode.utf8ValidateSlice(payload)) {
292. self.alloc.free(payload);
293. return self.fail(CLOSE_INVALID_PAYLOAD);
294. }
295. return if (opcode == .text) .{ .text = payload } else .{ .binary = payload };
296. }
297. // First fragment
298. self.msg_opcode = opcode;
299. try self.msg.appendSlice(self.alloc, payload);
300. self.alloc.free(payload);
301. return self.next(); // more frames may already be buffered
302. },
303. .continuation => {
304. const start_op = self.msg_opcode orelse {
305. self.alloc.free(payload);
306. return self.fail(CLOSE_PROTOCOL_ERROR); // continuation without a message
307. };
308. try self.msg.appendSlice(self.alloc, payload);
309. self.alloc.free(payload);
310. if (!fin) return self.next();
311. // Message complete
312. const full = try self.msg.toOwnedSlice(self.alloc);
313. self.msg_opcode = null;
314. if (start_op == .text and !std.unicode.utf8ValidateSlice(full)) {
315. self.alloc.free(full);
316. return self.fail(CLOSE_INVALID_PAYLOAD);
317. }
318. return if (start_op == .text) .{ .text = full } else .{ .binary = full };
319. },
320. _ => return self.fail(CLOSE_PROTOCOL_ERROR), // unreachable — filtered above
321. }
322. }
323. };
325. // ===========================================================================
326. // Tests
327. // ===========================================================================
329. const t = std.testing;
331. test "computeAcceptKey RFC 6455 sample" {
332. var out: [28]u8 = undefined;
333. const accept = computeAcceptKey("dGhlIHNhbXBsZSBub25jZQ==", &out);
334. try t.expectEqualStrings("s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", accept);
335. }
337. fn maskedFrame(alloc: std.mem.Allocator, fin: bool, opcode: Opcode, payload: []const u8, mask: [4]u8) ![]u8 {
338. var out = std.ArrayListUnmanaged(u8).empty;
339. var hdr: [10]u8 = undefined;
340. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, fin);
341. hdr[1] |= 0x80; // set mask bit
342. try out.appendSlice(alloc, hdr[0..hlen]);
343. try out.appendSlice(alloc, &mask);
344. for (payload, 0..) |b, i| try out.append(alloc, b ^ mask[i % 4]);
345. return out.toOwnedSlice(alloc);
346. }
348. test "decode masked text frame" {
349. var dec = Decoder.init(t.allocator);
350. defer dec.deinit();
351. const frame = try maskedFrame(t.allocator, true, .text, "Hello", .{ 0x37, 0xfa, 0x21, 0x3d });
352. defer t.allocator.free(frame);
353. try dec.feed(frame);
354. var ev = (try dec.next()).?;
355. defer ev.deinitPayload(t.allocator);
356. try t.expectEqualStrings("Hello", ev.text);
357. try t.expectEqual(@as(?Event, null), try dec.next());
358. }
360. test "decode split across feeds" {
361. var dec = Decoder.init(t.allocator);
362. defer dec.deinit();
363. const frame = try maskedFrame(t.allocator, true, .text, "chunked delivery", .{ 1, 2, 3, 4 });
364. defer t.allocator.free(frame);
365. try dec.feed(frame[0..3]);
366. try t.expectEqual(@as(?Event, null), try dec.next());
367. try dec.feed(frame[3..]);
368. var ev = (try dec.next()).?;
369. defer ev.deinitPayload(t.allocator);
370. try t.expectEqualStrings("chunked delivery", ev.text);
371. }
373. test "fragmented message assembly" {
374. var dec = Decoder.init(t.allocator);
375. defer dec.deinit();
376. const f1 = try maskedFrame(t.allocator, false, .text, "Hel", .{ 9, 8, 7, 6 });
377. defer t.allocator.free(f1);
378. const f2 = try maskedFrame(t.allocator, false, .continuation, "lo ", .{ 5, 4, 3, 2 });
379. defer t.allocator.free(f2);
380. const f3 = try maskedFrame(t.allocator, true, .continuation, "WS", .{ 1, 1, 1, 1 });
381. defer t.allocator.free(f3);
382. try dec.feed(f1);
383. try dec.feed(f2);
384. try t.expectEqual(@as(?Event, null), try dec.next());
385. try dec.feed(f3);
386. var ev = (try dec.next()).?;
387. defer ev.deinitPayload(t.allocator);
388. try t.expectEqualStrings("Hello WS", ev.text);
389. }
391. test "control frame interleaved with fragments" {
392. var dec = Decoder.init(t.allocator);
393. defer dec.deinit();
394. const f1 = try maskedFrame(t.allocator, false, .text, "par", .{ 2, 2, 2, 2 });
395. defer t.allocator.free(f1);
396. const ping = try maskedFrame(t.allocator, true, .ping, "hb", .{ 3, 3, 3, 3 });
397. defer t.allocator.free(ping);
398. const f2 = try maskedFrame(t.allocator, true, .continuation, "tial", .{ 4, 4, 4, 4 });
399. defer t.allocator.free(f2);
400. try dec.feed(f1);
401. try dec.feed(ping);
402. var ev1 = (try dec.next()).?;
403. defer ev1.deinitPayload(t.allocator);
404. try t.expectEqualStrings("hb", ev1.ping);
405. try dec.feed(f2);
406. var ev2 = (try dec.next()).?;
407. defer ev2.deinitPayload(t.allocator);
408. try t.expectEqualStrings("partial", ev2.text);
409. }
411. test "unmasked client frame is a protocol error" {
412. var dec = Decoder.init(t.allocator);
413. defer dec.deinit();
414. var hdr: [10]u8 = undefined;
415. const hlen = encodeFrameHeader(&hdr, .text, 2, true);
416. try dec.feed(hdr[0..hlen]);
417. try dec.feed("hi");
418. const ev = (try dec.next()).?;
419. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
420. try t.expectEqual(@as(?Event, null), try dec.next()); // stream dead
421. }
423. test "invalid UTF-8 in text is 1007" {
424. var dec = Decoder.init(t.allocator);
425. defer dec.deinit();
426. const bad = [_]u8{ 0xC3, 0x28 }; // invalid 2-byte sequence
427. const frame = try maskedFrame(t.allocator, true, .text, &bad, .{ 7, 7, 7, 7 });
428. defer t.allocator.free(frame);
429. try dec.feed(frame);
430. const ev = (try dec.next()).?;
431. try t.expectEqual(CLOSE_INVALID_PAYLOAD, ev.protocol_error);
432. }
434. test "close with code and reason" {
435. var dec = Decoder.init(t.allocator);
436. defer dec.deinit();
437. var payload: [7]u8 = undefined;
438. std.mem.writeInt(u16, payload[0..2], 1000, .big);
439. @memcpy(payload[2..], "done!");
440. const frame = try maskedFrame(t.allocator, true, .close, &payload, .{ 6, 6, 6, 6 });
441. defer t.allocator.free(frame);
442. try dec.feed(frame);
443. var ev = (try dec.next()).?;
444. defer ev.deinitPayload(t.allocator);
445. try t.expectEqual(@as(u16, 1000), ev.close.code);
446. try t.expectEqualStrings("done!", ev.close.reason);
447. }
449. test "close with invalid code is 1002" {
450. var dec = Decoder.init(t.allocator);
451. defer dec.deinit();
452. var payload: [2]u8 = undefined;
453. std.mem.writeInt(u16, payload[0..2], 1006, .big); // 1006 must never appear on the wire
454. const frame = try maskedFrame(t.allocator, true, .close, &payload, .{ 1, 2, 3, 4 });
455. defer t.allocator.free(frame);
456. try dec.feed(frame);
457. const ev = (try dec.next()).?;
458. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
459. }
461. test "fragmented control frame is 1002" {
462. var dec = Decoder.init(t.allocator);
463. defer dec.deinit();
464. const frame = try maskedFrame(t.allocator, false, .ping, "x", .{ 1, 2, 3, 4 });
465. defer t.allocator.free(frame);
466. try dec.feed(frame);
467. const ev = (try dec.next()).?;
468. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
469. }
471. test "continuation without message is 1002" {
472. var dec = Decoder.init(t.allocator);
473. defer dec.deinit();
474. const frame = try maskedFrame(t.allocator, true, .continuation, "x", .{ 1, 2, 3, 4 });
475. defer t.allocator.free(frame);
476. try dec.feed(frame);
477. const ev = (try dec.next()).?;
478. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
479. }
481. test "new data frame while assembling is 1002" {
482. var dec = Decoder.init(t.allocator);
483. defer dec.deinit();
484. const f1 = try maskedFrame(t.allocator, false, .text, "a", .{ 1, 2, 3, 4 });
485. defer t.allocator.free(f1);
486. const f2 = try maskedFrame(t.allocator, true, .text, "b", .{ 1, 2, 3, 4 });
487. defer t.allocator.free(f2);
488. try dec.feed(f1);
489. try dec.feed(f2);
490. const ev = (try dec.next()).?;
491. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
492. }
494. test "oversize message is 1009" {
495. var dec = Decoder.init(t.allocator);
496. defer dec.deinit();
497. dec.max_message_size = 8;
498. const frame = try maskedFrame(t.allocator, true, .text, "123456789", .{ 1, 2, 3, 4 });
499. defer t.allocator.free(frame);
500. try dec.feed(frame);
501. const ev = (try dec.next()).?;
502. try t.expectEqual(CLOSE_TOO_BIG, ev.protocol_error);
503. }
505. test "16-bit extended length round trip" {
506. var dec = Decoder.init(t.allocator);
507. defer dec.deinit();
508. const big = try t.allocator.alloc(u8, 300);
509. defer t.allocator.free(big);
510. @memset(big, 'A');
511. const frame = try maskedFrame(t.allocator, true, .binary, big, .{ 9, 9, 9, 9 });
512. defer t.allocator.free(frame);
513. try dec.feed(frame);
514. var ev = (try dec.next()).?;
515. defer ev.deinitPayload(t.allocator);
516. try t.expectEqual(@as(usize, 300), ev.binary.len);
517. try t.expectEqual(@as(u8, 'A'), ev.binary[150]);
518. }
520. test "writeFrame emits parseable frame" {
521. const Sink = struct {
522. var buf: std.ArrayListUnmanaged(u8) = .empty;
523. fn write(_: ?*anyopaque, data: []const u8) bool {
524. buf.appendSlice(t.allocator, data) catch return false;
525. return true;
526. }
527. };
528. defer Sink.buf.deinit(t.allocator);
529. try t.expect(writeFrame(&Sink.write, null, .text, "server says hi"));
530. // Parse it back with an unmasked-tolerant decoder (client role)
531. var dec = Decoder.init(t.allocator);
532. dec.require_masked = false;
533. defer dec.deinit();
534. try dec.feed(Sink.buf.items);
535. var ev = (try dec.next()).?;
536. defer ev.deinitPayload(t.allocator);
537. try t.expectEqualStrings("server says hi", ev.text);
538. }
540. test "writeClose encodes code and reason" {
541. const Sink = struct {
542. var buf: std.ArrayListUnmanaged(u8) = .empty;
543. fn write(_: ?*anyopaque, data: []const u8) bool {
544. buf.appendSlice(t.allocator, data) catch return false;
545. return true;
546. }
547. };
548. defer Sink.buf.deinit(t.allocator);
549. try t.expect(writeClose(&Sink.write, null, 1000, "bye"));
550. var dec = Decoder.init(t.allocator);
551. dec.require_masked = false;
552. defer dec.deinit();
553. try dec.feed(Sink.buf.items);
554. var ev = (try dec.next()).?;
555. defer ev.deinitPayload(t.allocator);
556. try t.expectEqual(@as(u16, 1000), ev.close.code);
557. try t.expectEqualStrings("bye", ev.close.reason);
558. }