WSCloseCode

Author: swhitty

FlyingFox/Sources/WebSocket/WSCloseCode.swift

@@ -0,0 +1,65 @@
+//
+//  WSCloseCode.swift
+//  FlyingFox
+//
+//  Created by Simon Whitty on 04/03/2025.
+//  Copyright © 2025 Simon Whitty. All rights reserved.
+//
+//  Distributed under the permissive MIT license
+//  Get the latest version from here:
+//
+//  https://github.com/swhitty/FlyingFox
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+public struct WSCloseCode: RawRepresentable, Sendable, Hashable {
+    public var rawValue: UInt16
+
+    public init(rawValue: UInt16) {
+        self.rawValue = rawValue
+    }
+
+    public init(_ code: UInt16) {
+        self.rawValue = code
+    }
+}
+
+public extension WSCloseCode {
+    // The following codes are based on:
+    // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+
+    static let normalClosure = WSCloseCode(1000)
+    static let goingAway = WSCloseCode(1001)
+    static let protocolError = WSCloseCode(1002)
+    static let unsupportedData = WSCloseCode(1003)
+    static let noStatusReceived = WSCloseCode(1005)
+    static let abnormalClosure = WSCloseCode(1006)
+    static let invalidFramePayloadData = WSCloseCode(1007)
+    static let policyViolation = WSCloseCode(1008)
+    static let messageTooBig = WSCloseCode(1009)
+    static let mandatoryExtensionMissing = WSCloseCode(1010)
+    static let internalServerError = WSCloseCode(1011)
+    static let serviceRestart = WSCloseCode(1012)
+    static let tryAgainLater = WSCloseCode(1013)
+    static let badGateway = WSCloseCode(1014)
+    static let tlsHandshakeFailure = WSCloseCode(1015)
+}

FlyingFox/Sources/WebSocket/WSFrame.swift

@@ -93,14 +93,14 @@ public struct WSFrame: Sendable, Hashable {
 public extension WSFrame {
     static func close(message: String = "", mask: Mask? = nil) -> Self {
         close(
-            code: message.isEmpty ? 1000 : 1002,
+            code: message.isEmpty ? .normalClosure : .protocolError,
             message: message,
             mask: mask
         )
     }
 
-    static func close(code: UInt16, message: String, mask: Mask? = nil) -> Self {
-        var payload = Data([UInt8(code >> 8), UInt8(code & 0xFF)])
+    static func close(code: WSCloseCode, message: String, mask: Mask? = nil) -> Self {
+        var payload = Data([UInt8(code.rawValue >> 8), UInt8(code.rawValue & 0xFF)])
         if let data = message.data(using: .utf8) {
             payload.append(contentsOf: data)
         }

FlyingFox/Sources/WebSocket/WSHandler.swift

@@ -147,16 +147,16 @@ public struct MessageFrameWSHandler: WSHandler {
         }
     }
 
-    func makeCloseCode(from payload: Data) throws -> (UInt16, String) {
+    func makeCloseCode(from payload: Data) throws -> (WSCloseCode, String) {
         guard payload.count >= 2 else {
-            return (1005, "")
+            return (.noStatusReceived, "")
         }
 
-        let code = payload.withUnsafeBytes { $0.load(as: UInt16.self).bigEndian }
+        let statusCode = payload.withUnsafeBytes { $0.load(as: UInt16.self).bigEndian }
         guard let reason = String(data: payload.dropFirst(2), encoding: .utf8) else {
             throw FrameError.invalid("Invalid UTF8 Sequence")
         }
-        return (code, reason)
+        return (WSCloseCode(statusCode), reason)
     }
 
     func makeResponseFrames(for frame: WSFrame) throws -> WSFrame? {

FlyingFox/Sources/WebSocket/WSMessage.swift

@@ -34,7 +34,7 @@ import Foundation
 public enum WSMessage: @unchecked Sendable, Hashable {
     case text(String)
     case data(Data)
-    case close(code: UInt16 = 1000, reason: String = "")
+    case close(code: WSCloseCode = .normalClosure, reason: String = "")
 }
 
 public protocol WSMessageHandler: Sendable {

FlyingFox/Tests/WebSocket/WSFrameTests.swift

@@ -70,15 +70,15 @@ struct WSFrameTests {
             )
         )
         #expect(
-            WSFrame.close(code: 4999, message: "Err") == .make(
+            WSFrame.close(code: WSCloseCode(4999), message: "Err") == .make(
                 fin: true,
                 opcode: .close,
                 mask: nil,
                 payload: Data([0x13, 0x87, .ascii("E"), .ascii("r"), .ascii("r")])
             )
         )
         #expect(
-            WSFrame.close(code: 4999, message: "Err", mask: .mock) == .make(
+            WSFrame.close(code: WSCloseCode(4999), message: "Err", mask: .mock) == .make(
                 fin: true,
                 opcode: .close,
                 mask: .mock,

FlyingFox/Tests/WebSocket/WSHandlerTests.swift

@@ -63,11 +63,11 @@ struct WSHandlerTests {
 
         #expect(
             try handler.makeMessage(for: .make(fin: true, opcode: .close, payload: payload)) ==
-                .close(code: 4999, reason: "fish")
+                .close(code: WSCloseCode(4999), reason: "fish")
         )
         #expect(
             try handler.makeMessage(for: .make(fin: true, opcode: .close)) ==
-                .close(code: 1005, reason: "")
+                .close(code: .noStatusReceived, reason: "")
         )
     }
 

FlyingFox/XCTests/WebSocket/WSFrameTests.swift

@@ -65,7 +65,7 @@ final class WSFrameTests: XCTestCase {
                   payload: Data([0x03, 0xEA, .ascii("E"), .ascii("r"), .ascii("r")]))
         )
         XCTAssertEqual(
-            WSFrame.close(code: 4999, message: "Err"),
+            WSFrame.close(code: WSCloseCode(4999), message: "Err"),
             .make(
                 fin: true,
                 opcode: .close,
@@ -74,7 +74,7 @@ final class WSFrameTests: XCTestCase {
             )
         )
         XCTAssertEqual(
-            WSFrame.close(code: 4999, message: "Err", mask: .mock),
+            WSFrame.close(code: WSCloseCode(4999), message: "Err", mask: .mock),
             .make(
                 fin: true,
                 opcode: .close,

FlyingFox/XCTests/WebSocket/WSHandlerTests.swift

@@ -65,11 +65,11 @@ final class WSHandlerTests: XCTestCase {
 
         XCTAssertEqual(
             try handler.makeMessage(for: .make(fin: true, opcode: .close, payload: payload)),
-            .close(code: 4999, reason: "fish")
+            .close(code: WSCloseCode(4999), reason: "fish")
         )
         XCTAssertEqual(
             try handler.makeMessage(for: .make(fin: true, opcode: .close)),
-            .close(code: 1005, reason: "")
+            .close(code: .noStatusReceived, reason: "")
         )
     }