refactor(webzockets): pass mask keys by value in mask api

Author: jbuckmccready

src/rpc/webzockets/src/client/connection.zig

@@ -488,7 +488,7 @@ pub fn ClientConnection(
 
             // Mask payload in-place in the caller's buffer
             if (payload.len > 0) {
-                mask_mod.mask(&mask_key, payload);
+                mask_mod.mask(mask_key, payload);
             }
             self.write.payload = payload;
 
@@ -546,7 +546,7 @@ pub fn ClientConnection(
             if (payload.len > 0) {
                 @memcpy(self.write.control_buf[header_len..][0..payload.len], payload);
                 // Mask control payload in-place
-                mask_mod.mask(&mask_key, self.write.control_buf[header_len..][0..payload.len]);
+                mask_mod.mask(mask_key, self.write.control_buf[header_len..][0..payload.len]);
             }
             self.write.control_len = header_len + payload.len;
             self.write.in_flight = .{ .control = .{ .offset = 0 } };

src/rpc/webzockets/src/frame.zig

@@ -40,7 +40,7 @@ pub const FrameHeader = struct {
     /// No-op if the frame is not masked.
     pub fn unmaskPayload(self: FrameHeader, payload: []u8) void {
         if (self.masked) {
-            mask_mod.mask(&self.mask_key, payload);
+            mask_mod.mask(self.mask_key, payload);
         }
     }
 

src/rpc/webzockets/src/mask.zig

@@ -1,51 +1,42 @@
 const std = @import("std");
 
-/// Whether the current backend supports SIMD vector operations.
-const backend_supports_vectors = switch (@import("builtin").zig_backend) {
-    .stage2_llvm, .stage2_c => true,
-    else => false,
-};
-
 /// Applies XOR masking/unmasking to payload in-place using the 4-byte mask key.
 /// The same function works for both masking and unmasking (XOR is its own inverse).
-/// Uses SIMD acceleration when available, with scalar fallback.
-pub fn mask(m: []const u8, payload: []u8) void {
-    std.debug.assert(m.len == 4);
+pub fn mask(mask_key: [4]u8, payload: []u8) void {
     var data = payload;
 
-    if (!comptime backend_supports_vectors) return scalarMask(m, data);
-
     const vector_size = comptime std.simd.suggestVectorLength(u8) orelse @sizeOf(usize);
     if (data.len >= vector_size) {
-        const mask_vector: @Vector(vector_size, u8) = std.simd.repeat(vector_size, m[0..4].*);
+        const mask_vector: @Vector(vector_size, u8) = std.simd.repeat(vector_size, mask_key);
         while (data.len >= vector_size) {
             const slice = data[0..vector_size];
             const masked: @Vector(vector_size, u8) = slice.*;
             slice.* = masked ^ mask_vector;
             data = data[vector_size..];
         }
     }
-    scalarMask(m, data);
+
+    scalarMask(mask_key, data);
 }
 
 /// Scalar byte-by-byte XOR mask fallback for remaining bytes or unsupported backends.
-fn scalarMask(m: []const u8, payload: []u8) void {
+fn scalarMask(mask_key: [4]u8, payload: []u8) void {
     @setRuntimeSafety(false);
     for (payload, 0..) |b, i| {
-        payload[i] = b ^ m[i & 3];
+        payload[i] = b ^ mask_key[i & 3];
     }
 }
 
 const testing = std.testing;
 
 test "mask: empty payload is no-op" {
     var buf = [_]u8{};
-    mask(&.{ 0xAA, 0xBB, 0xCC, 0xDD }, &buf);
+    mask(.{ 0xAA, 0xBB, 0xCC, 0xDD }, &buf);
 }
 
 test "mask: single byte" {
     var buf = [_]u8{0x42};
-    mask(&.{ 0xFF, 0x00, 0x00, 0x00 }, &buf);
+    mask(.{ 0xFF, 0x00, 0x00, 0x00 }, &buf);
     try testing.expectEqual(@as(u8, 0x42 ^ 0xFF), buf[0]);
 }
 
@@ -57,18 +48,18 @@ test "mask: round-trip produces original" {
     const key = [_]u8{ 0x37, 0xFA, 0x21, 0x3D };
 
     // Mask
-    mask(&key, &buf);
+    mask(key, &buf);
     // Should differ from original
     try testing.expect(!std.mem.eql(u8, &buf, original));
     // Unmask (same operation)
-    mask(&key, &buf);
+    mask(key, &buf);
     try testing.expectEqualSlices(u8, original, &buf);
 }
 
 test "mask: exact 4-byte alignment" {
     var buf = [_]u8{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
     const key = [_]u8{ 0xFF, 0xFF, 0xFF, 0xFF };
-    mask(&key, &buf);
+    mask(key, &buf);
     const expected = [_]u8{ 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8, 0xF7 };
     try testing.expectEqualSlices(u8, &expected, &buf);
 }
@@ -94,22 +85,22 @@ test "mask: SIMD boundary sizes" {
         @memcpy(expected, buf);
 
         // Mask then unmask should round-trip
-        mask(&key, buf);
-        mask(&key, buf);
+        mask(key, buf);
+        mask(key, buf);
         try testing.expectEqualSlices(u8, expected, buf);
     }
 }
 
 test "mask: all-zero mask is identity" {
     const original = [_]u8{ 0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE };
     var buf = original;
-    mask(&.{ 0x00, 0x00, 0x00, 0x00 }, &buf);
+    mask(.{ 0x00, 0x00, 0x00, 0x00 }, &buf);
     try testing.expectEqualSlices(u8, &original, &buf);
 }
 
 test "mask: all-ones mask inverts all bits" {
     var buf = [_]u8{ 0x00, 0xFF, 0xAA, 0x55 };
-    mask(&.{ 0xFF, 0xFF, 0xFF, 0xFF }, &buf);
+    mask(.{ 0xFF, 0xFF, 0xFF, 0xFF }, &buf);
     try testing.expectEqualSlices(u8, &[_]u8{ 0xFF, 0x00, 0x55, 0xAA }, &buf);
 }
 
@@ -120,15 +111,15 @@ test "mask: RFC 6455 example verification" {
     // masked = { 0x48^0x37, 0x65^0xfa, 0x6c^0x21, 0x6c^0x3d, 0x6f^0x37 }
     //        = { 0x7f, 0x9f, 0x4d, 0x51, 0x58 }
     var buf = [_]u8{ 0x48, 0x65, 0x6c, 0x6c, 0x6f };
-    mask(&.{ 0x37, 0xfa, 0x21, 0x3d }, &buf);
+    mask(.{ 0x37, 0xfa, 0x21, 0x3d }, &buf);
     try testing.expectEqualSlices(u8, &[_]u8{ 0x7f, 0x9f, 0x4d, 0x51, 0x58 }, &buf);
 }
 
 test "mask: fuzz round-trip" {
     const Context = struct {
         fn testOne(_: @This(), input: []const u8) anyerror!void {
             if (input.len < 4) return;
-            const key = input[0..4];
+            const key: [4]u8 = input[0..4].*;
             const buf = try testing.allocator.alloc(u8, input.len - 4);
             defer testing.allocator.free(buf);
             @memcpy(buf, input[4..]);

src/rpc/webzockets/src/reader.zig

@@ -512,7 +512,7 @@ fn buildMaskedFrame(
     header_len += 4;
 
     @memcpy(out[header_len..][0..payload.len], payload);
-    mask_mod.mask(&mask_key, out[header_len..][0..payload.len]);
+    mask_mod.mask(mask_key, out[header_len..][0..payload.len]);
 
     return out[0 .. header_len + payload.len];
 }