add WebSocket endpoint support

WebPlatform.alusus

@@ -31,12 +31,14 @@ import "Spp/Ast";
 import "Build";
 import "Apm";
 import "closure";
+Apm.importPackage("Alusus/Sle@0.2", "Srl/enums.alusus");
 Apm.importPackage("Alusus/Http@0.3");
 Apm.importPackage("Alusus/Json@0.2");
 Apm.importPackage("Alusus/MarkdownTranslator@0.1");
 Apm.importPackage("Alusus/Promises@0.1");
 
 import "WebPlatform/server";
+import "WebPlatform/WsConnection";
 import "WebPlatform/browser_api";
 import "WebPlatform/frontend_helpers";
 import "WebPlatform/Styling/Color";

WebPlatform/WsConnection.alusus

@@ -0,0 +1,212 @@
+@merge module WebPlatform {
+    class WsStatus {
+        setupStringEnum[];
+        enumStringValue[CONNECTING, "connecting"];
+        enumStringValue[OPENED, "opened"];
+        enumStringValue[CLOSING, "closing"];
+        enumStringValue[CLOSED, "closed"];
+    }
+
+    class WsConnection {
+        def wkThis: WkRef[this_type];
+        def connection: ptr[Http.Connection];
+
+        def status: WsStatus;
+        def closeCode: word[16] = 1006;
+        def closeReason: String;
+
+        def maxMessageSize: ArchInt = 1024;
+        def fragmentBuffer: StringBuilder();
+        def fragmentOpcode: Int;
+        def isFragmenting: Bool = 0;
+
+        handler this~init(conn: ptr[Http.Connection]) {
+            this.connection = conn;
+            this.status = WsStatus.CONNECTING;
+        }
+
+        handler this.getStatus(): WsStatus {
+            return this.status;
+        }
+
+        handler this.setMaxMessageSize(size: ArchInt) {
+            this.maxMessageSize = size;
+            fragmentBuffer.bufferGrowSize = (maxMessageSize / 2)~cast[ArchInt];
+        }
+
+        handler this.getMaxMessageSize(): ArchInt{
+            return this.maxMessageSize;
+        }
+
+        handler this.sendText(data: CharsPtr) {
+            if this.status != WsStatus.OPENED return ;
+
+            if Http.writeTextToWebSocket(this.connection, data) <= 0 {
+                this.status = WsStatus.CLOSED;
+            }
+        }
+
+        handler this.sendBinary(data: CharsPtr, dataLen: ArchWord) {
+            if this.status != WsStatus.OPENED return ;
+            if Http.writeBinaryToWebSocket(this.connection , data , dataLen) <= 0 {
+                this.status = WsStatus.CLOSED;
+            }
+        }
+
+        handler this.close () {
+            this.close(1000 , "")
+        }
+
+        handler this.close (statusCode : word[16] , reasonMessage : CharsPtr) {
+            if this.status != WsStatus.OPENED return;
+
+            this.closeCode = statusCode;
+            this.closeReason = reasonMessage;
+
+            def reasonLen : Int = String.getLength(reasonMessage);
+
+            def payloadLen : Int = 2 + reasonLen;
+
+            if (payloadLen > 125) {
+                reasonLen = 123;        // 125 - 2 bytes for the status code
+                payloadLen = 125;
+            }
+
+            // close frame payload max is 125 bytes as stated in RFC 6455 §5.5.1
+            def payload : array[Char, 125];
+
+            payload(0) = (statusCode >> 8)[ptr[Char]]  & 0xFF; // status code, high byte
+            payload(1) = statusCode & 0xFF;  // status code, low byte
+
+            if (reasonLen > 0) {
+                Memory.copy(payload~ptr~cast[ptr[Char]] + 2, reasonMessage, reasonLen~cast[ArchInt]);
+            }
+
+            this.status = WsStatus.CLOSING;
+
+            if Http.writeToWebSocket(this.connection, 8, payload~ptr, payloadLen) <= {
+                this.status = WsStatus.CLOSED;
+            }
+
+            return result;
+        }
+
+        // Called internally by the library to respond to a client-initiated
+        // close frame, completing the close handshake as stated in
+        // RFC 6455 §5.5.1 (a responder typically echoes the status code
+        // it received).
+        handler this.replyToClose (data : CharsPtr, dataLen : ArchWord) {
+            if this.status != WsStatus.OPENED return;
+
+            // Extract and store the close code/reason before replying,
+            // per RFC 6455 §5.5.1: first 2 bytes = status code, rest = reason.
+
+            if (dataLen~cast[Int] >= 2) {
+                this.closeCode = ((data~cnt(0)~cast[word[16]]) << 8) | data~cnt(1)~cast[word[16]];
+                if (dataLen~cast[Int] > 2) {
+                    def reasonLen: Int = (dataLen~cast[Int] - 2);
+                    this.closeReason = String(data + 2, reasonLen);
+                }
+            } else {
+                // client sent a close frame with no code at all — valid per spec
+                this.closeCode = 1005; // "No Status Received"
+                this.closeReason = "";
+            }
+
+            this.status = WsStatus.CLOSING;
+
+            if Http.writeToWebSocket(this.connection, 8, data, dataLen) <= 0 {
+                this.status = WsStatus.CLOSED;
+            }
+
+            return result;
+        }
+
+        handler this.onConnect(): Int as_ptr {
+            return 0;
+        }
+
+        handler this.onReady() as_ptr {
+        }
+
+        handler this.onData(bits: Int, data: CharsPtr, dataLen: ArchWord): Int {
+            def opcode : Int = bits & 0x0F;
+            def fin: Bool = (bits & 0x80) != 0;
+
+            // Safe to cast: CivetWeb rejects any frame exceeding ~2 GiB (0x7FFF0000),
+            // which is within ArchInt's range, so this cast can't overflow or go negative.
+
+            def dataLen : ArchInt = dataLen~cast[ArchInt];
+
+            if opcode == 1 or opcode == 2 {
+                if (this.isFragmenting) {
+                    this.close(1002, "unexpected new message mid-fragment");
+                    return 0;
+                }
+
+                this.fragmentOpcode = opcode;
+                this.fragmentBuffer.clear();
+
+                if (dataLen > this.getMaxMessageSize()) {
+                    this.close(1009, "Message too big");
+                    return 0;
+                }
+
+                this.fragmentBuffer.append(data, dataLen);
+
+                if (fin) {
+                    def isBinary : Bool = this.fragmentOpcode == 2;
+                    this.onUserData(this.fragmentBuffer.string, isBinary);
+                    this.fragmentBuffer.clear();
+                } else {
+                    this.isFragmenting = 1;
+                }
+            }
+
+            if opcode == 0 {
+                if (!this.isFragmenting) {
+                    // Protocol violation: CONTINUATION with no preceding TEXT/BINARY
+                    this.close(1002, "unexpected continuation frame");
+                    return 0;
+                }
+
+                if (this.fragmentBuffer.getLength() + dataLen > this.getMaxMessageSize()) {
+                    this.close(1009, "Message too big");
+                    return 0;
+                }
+
+                this.fragmentBuffer.append(data, dataLen);
+
+                if (fin) {
+                    def isBinary : Bool = this.fragmentOpcode == 2;
+                    this.onUserData(this.fragmentBuffer.string, isBinary);
+                    this.fragmentBuffer.clear();
+                    this.isFragmenting = 0;
+                }
+            }
+
+            if opcode == 8 {
+                // reply with a close frame before tearing down — completes the handshake properly
+                if dataLen~cast[Int] >= 2 {
+                    this.replyToClose(data, dataLen); // echo back client's code+reason
+                } else {
+                    this.close(1000, ""); // client sent no code, reply with normal closure
+                }
+                return 0;
+            }
+
+            if (opcode != 0 and opcode != 1 and opcode != 2 and opcode != 8) {
+                this.close(1002, "unsupported opcode");
+                return 0;
+            }
+
+            return 1;
+        }
+
+        handler this.onUserData(data: ref[String], isBinary: Bool) as_ptr {
+        }
+
+        handler this.onClose() as_ptr {
+        }
+    }
+}