Add binary option to WebSockets

projects/core/src/main/java/dan200/computercraft/core/apis/HTTPAPI.java

@@ -150,24 +150,27 @@ public final Object[] websocket(IArguments args) throws LuaException {
         String address;
         Map<?, ?> headerTable;
         Optional<Double> timeoutArg;
+        boolean binary;
 
         if (args.get(0) instanceof Map) {
             var options = args.getTable(0);
             address = getStringField(options, "url");
             headerTable = optTableField(options, "headers", Collections.emptyMap());
             timeoutArg = optRealField(options, "timeout");
+            binary = optBooleanField(options, "binary", false);
         } else {
             address = args.getString(0);
             headerTable = args.optTable(1, Collections.emptyMap());
             timeoutArg = Optional.empty();
+            binary = args.optBoolean(2, false);
         }
 
         var headers = getHeaders(headerTable);
         var timeout = getTimeout(timeoutArg);
 
         try {
             var uri = WebsocketClient.parseUri(address);
-            if (!new Websocket(websockets, apiEnvironment, uri, address, headers, timeout).queue(Websocket::connect)) {
+            if (!new Websocket(websockets, apiEnvironment, uri, address, headers, timeout, binary).queue(Websocket::connect)) {
                 throw new LuaException("Too many websockets already open");
             }
 

projects/core/src/main/java/dan200/computercraft/core/apis/http/websocket/Websocket.java

@@ -56,14 +56,16 @@ public class Websocket extends Resource<Websocket> implements WebsocketClient {
     private final String address;
     private final HttpHeaders headers;
     private final int timeout;
+    private final boolean binary;
 
-    public Websocket(ResourceGroup<Websocket> limiter, IAPIEnvironment environment, URI uri, String address, HttpHeaders headers, int timeout) {
+    public Websocket(ResourceGroup<Websocket> limiter, IAPIEnvironment environment, URI uri, String address, HttpHeaders headers, int timeout, boolean binary) {
         super(limiter);
         this.environment = environment;
         this.uri = uri;
         this.address = address;
         this.headers = headers;
         this.timeout = timeout;
+        this.binary = binary;
     }
 
     public void connect() {
@@ -184,4 +186,9 @@ public void sendBinary(ByteBuffer message) {
         var channel = channel();
         if (channel != null) channel.writeAndFlush(new BinaryWebSocketFrame(Unpooled.wrappedBuffer(message)));
     }
+
+    @Override
+    public boolean isBinary() {
+        return binary;
+    }
 }

projects/core/src/main/java/dan200/computercraft/core/apis/http/websocket/WebsocketClient.java

@@ -49,6 +49,15 @@ public interface WebsocketClient extends Closeable {
      */
     void sendBinary(ByteBuffer message);
 
+    /**
+     * Determine whether the websocket sends binary messages by default.
+     *
+     * @return Whether the websocket sends binary messages by default.
+     */
+    default boolean isBinary() {
+        return false;
+    }
+
     /**
      * Parse an address, ensuring it is a valid websocket URI.
      *

projects/core/src/main/java/dan200/computercraft/core/apis/http/websocket/WebsocketHandle.java

@@ -9,6 +9,8 @@
 import dan200.computercraft.core.apis.IAPIEnvironment;
 import dan200.computercraft.core.apis.http.options.Options;
 
+import java.nio.charset.StandardCharsets;
+import java.nio.charset.UnsupportedCharsetException;
 import java.util.Arrays;
 import java.util.Optional;
 
@@ -79,7 +81,21 @@ public final void send(Coerced<String> message, Optional<Boolean> binary) throws
         if (binary.orElse(false)) {
             websocket.sendBinary(LuaValues.encode(text));
         } else {
-            websocket.sendText(text);
+            var data = text;
+            if (websocket.isBinary()) {
+                // Try to convert the string from UTF-8 bytes to UTF-16 codepoints.
+                // If this fails, fall back to normal ANSI.
+                try {
+                    var buf = LuaValues.encode(text);
+                    var bytes = new byte[buf.capacity()];
+                    buf.get(bytes);
+                    data = new String(bytes, StandardCharsets.UTF_8);
+                } catch (UnsupportedCharsetException ignored) {
+                    // Suppress warnings.
+                    data = text;
+                }
+            }
+            websocket.sendText(data);
         }
     }
 

projects/core/src/main/java/dan200/computercraft/core/apis/http/websocket/WebsocketHandler.java

@@ -50,16 +50,16 @@ public void channelRead0(ChannelHandlerContext ctx, Object msg) {
         }
 
         var frame = (WebSocketFrame) msg;
-        if (frame instanceof TextWebSocketFrame textFrame) {
+        if (websocket.isBinary() || frame instanceof BinaryWebSocketFrame) {
+            var converted = NetworkUtils.toBytes(frame.content());
+
+            websocket.environment().observe(Metrics.WEBSOCKET_INCOMING, converted.length);
+            websocket.environment().queueEvent(MESSAGE_EVENT, websocket.address(), converted, frame instanceof BinaryWebSocketFrame);
+        } else if (frame instanceof TextWebSocketFrame textFrame) {
             var data = textFrame.text();
 
             websocket.environment().observe(Metrics.WEBSOCKET_INCOMING, data.length());
             websocket.environment().queueEvent(MESSAGE_EVENT, websocket.address(), data, false);
-        } else if (frame instanceof BinaryWebSocketFrame) {
-            var converted = NetworkUtils.toBytes(frame.content());
-
-            websocket.environment().observe(Metrics.WEBSOCKET_INCOMING, converted.length);
-            websocket.environment().queueEvent(MESSAGE_EVENT, websocket.address(), converted, true);
         } else if (frame instanceof CloseWebSocketFrame closeFrame) {
             websocket.close(closeFrame.statusCode(), closeFrame.reasonText());
         }

projects/core/src/main/resources/data/computercraft/lua/rom/apis/http/http.lua

@@ -275,6 +275,7 @@ local function check_websocket_options(options, body)
     check_key(options, "url", "string")
     check_key(options, "headers", "table", true)
     check_key(options, "timeout", "number", true)
+    check_key(options, "binary", "boolean", true)
 end
 
 
@@ -299,18 +300,19 @@ these options behave.
 @see websocket_success
 @see websocket_failure
 ]]
-function websocketAsync(url, headers)
+function websocketAsync(url, headers, binary)
     local actual_url
     if type(url) == "table" then
         check_websocket_options(url)
         actual_url = url.url
     else
         expect(1, url, "string")
         expect(2, headers, "table", "nil")
+        expect(3, binary, "boolean", "nil")
         actual_url = url
     end
 
-    local ok, err = nativeWebsocket(url, headers)
+    local ok, err = nativeWebsocket(url, headers, binary)
     if not ok then
         os.queueEvent("websocket_failure", actual_url, err)
     end
@@ -355,18 +357,19 @@ from above are passed in as fields instead (for instance,
     ws.close()
 
 ]]
-function websocket(url, headers)
+function websocket(url, headers, binary)
     local actual_url
     if type(url) == "table" then
         check_websocket_options(url)
         actual_url = url.url
     else
         expect(1, url, "string")
         expect(2, headers, "table", "nil")
+        expect(3, binary, "boolean", "nil")
         actual_url = url
     end
 
-    local ok, err = nativeWebsocket(url, headers)
+    local ok, err = nativeWebsocket(url, headers, binary)
     if not ok then return ok, err end
 
     while true do

projects/core/src/test/kotlin/dan200/computercraft/core/apis/http/TestHttpApi.kt

@@ -88,6 +88,32 @@ class TestHttpApi {
         }
     }
 
+    @Test
+    fun `Supports binary websockets`() {
+        runServer {
+            LuaTaskRunner.runTest {
+                val httpApi = addApi(HTTPAPI(environment))
+                assertThat("http.websocket succeeded", httpApi.websocket(ObjectArguments(WS_URL, null, true)), array(equalTo(true)))
+
+                val connectEvent = pullEvent()
+                assertThat(connectEvent, array(equalTo("websocket_success"), equalTo(WS_URL), isA(WebsocketHandle::class.java)))
+
+                val websocket = connectEvent[2] as WebsocketHandle
+                websocket.send(Coerced("Hello \u00E2\u0098\u00BA"), Optional.of(false))
+
+                val message = websocket.receive(Optional.empty()).await()
+                // The string is converted to bytes because it's technically sent as a byte array.
+                // This difference doesn't matter in Lua, but it does here.
+                assertThat("Received a return message", message, array(equalTo("HELLO \u263A".toByteArray()), equalTo(false)))
+
+                websocket.close()
+
+                val closeEvent = pullEventOrTimeout(500.milliseconds, "websocket_closed")
+                assertThat("No event was queued", closeEvent, equalTo(null))
+            }
+        }
+    }
+
     @Test
     fun `Queues an event when the socket is externally closed`() {
         runServer { stop ->

projects/web/src/main/java/dan200/computercraft/core/apis/http/websocket/TWebsocket.java

@@ -27,14 +27,16 @@ public class TWebsocket extends Resource<TWebsocket> implements WebsocketClient
     private final IAPIEnvironment environment;
     private final URI uri;
     private final String address;
+    private final boolean binary;
 
     private @Nullable WebSocket websocket;
 
-    public TWebsocket(ResourceGroup<TWebsocket> limiter, IAPIEnvironment environment, URI uri, String address, HttpHeaders headers, int timeout) {
+    public TWebsocket(ResourceGroup<TWebsocket> limiter, IAPIEnvironment environment, URI uri, String address, HttpHeaders headers, int timeout, boolean binary) {
         super(limiter);
         this.environment = environment;
         this.uri = uri;
         this.address = address;
+        this.binary = binary;
     }
 
     public void connect() {
@@ -76,6 +78,11 @@ public void sendBinary(ByteBuffer message) {
         websocket.send(array);
     }
 
+    @Override
+    public boolean isBinary() {
+        return binary;
+    }
+
     @Override
     protected void dispose() {
         super.dispose();