Extract shared code

Sesame/API/DeviceResponse.swift

@@ -1,29 +1,37 @@
 import Foundation
 import NIOCore
 
-
+/**
+ Encapsulates a response from a device.
+ */
 struct DeviceResponse {
 
+    /// Shorthand property for a timeout event.
     static var deviceTimedOut: DeviceResponse {
         .init(event: .deviceTimedOut)
     }
 
+    /// Shorthand property for a disconnected event.
     static var deviceNotConnected: DeviceResponse {
         .init(event: .deviceNotConnected)
     }
 
+    /// Shorthand property for an unexpected socket event.
     static var unexpectedSocketEvent: DeviceResponse {
         .init(event: .unexpectedSocketEvent)
     }
 
+    /// Shorthand property for an invalid message.
     static var invalidMessageData: DeviceResponse {
         .init(event: .invalidMessageData)
     }
 
+    /// Shorthand property for missing body data.
     static var noBodyData: DeviceResponse {
         .init(event: .noBodyData)
     }
 
+    /// Shorthand property for a busy connection
     static var operationInProgress: DeviceResponse {
         .init(event: .operationInProgress)
     }
@@ -34,6 +42,13 @@ struct DeviceResponse {
     /// The index of the next key to use
     let response: Message?
 
+    /**
+     Decode a message from a buffer.
+
+     The buffer must contain `Message.length+1` bytes. The first byte denotes the event type,
+     the remaining bytes contain the message.
+     - Parameter buffer: The buffer where the message bytes are stored
+     */
     init?(_ buffer: ByteBuffer) {
         guard let byte = buffer.getBytes(at: 0, length: 1) else {
             print("No bytes received from device")
@@ -51,11 +66,16 @@ struct DeviceResponse {
         self.response = Message(decodeFrom: data)
     }
 
+    /**
+     Create a response from an event without a message from the device.
+     - Parameter event: The response from the device.
+     */
     init(event: MessageResult) {
         self.event = event
         self.response = nil
     }
 
+    /// Get the reponse encoded in bytes.
     var encoded: Data {
         guard let message = response else {
             return Data([event.rawValue])

Sesame/API/Message+Extensions.swift

@@ -1,21 +1,19 @@
-//
-//  Message+Extensions.swift
-//  Sesame
-//
-//  Created by CH on 08.04.22.
-//
-
 import Foundation
+
+#if canImport(CryptoKit)
 import CryptoKit
+#else
+import Crypto
+#endif
 
 extension Message {
 
     static var length: Int {
-        SHA256Digest.byteCount + Content.length
+        SHA256.byteCount + Content.length
     }
 
     init<T: Sequence>(decodeFrom data: T) where T.Element == UInt8 {
-        let count = SHA256Digest.byteCount
+        let count = SHA256.byteCount
         self.mac = Data(data.prefix(count))
         self.content = .init(decodeFrom: Array(data.dropFirst(count)))
     }

Sesame/API/Message.swift

@@ -0,0 +1,122 @@
+import Foundation
+import NIOCore
+
+/**
+ An authenticated message to or from the device.
+ */
+struct Message: Equatable, Hashable {
+
+    /**
+     The message content without authentication.
+     */
+    struct Content: Equatable, Hashable {
+
+        /// The time of message creation, in UNIX time (seconds since 1970)
+        let time: UInt32
+
+        /// The counter of the message (for freshness)
+        let id: UInt32
+
+        /**
+         Create new message content.
+         - Parameter time: The time of message creation,
+         - Parameter id: The counter of the message
+         */
+        init(time: UInt32, id: UInt32) {
+            self.time = time
+            self.id = id
+        }
+
+        /**
+         Decode message content from data.
+
+         The data consists of two `UInt32` encoded in big endian format (MSB at index 0)
+         - Warning: The sequence must contain at least 8 bytes, or the function will crash.
+         - Parameter data: The sequence containing the bytes.
+         */
+        init<T: Sequence>(decodeFrom data: T) where T.Element == UInt8 {
+            self.time = UInt32(data: data.prefix(MemoryLayout<UInt32>.size))
+            self.id = UInt32(data: data.dropFirst(MemoryLayout<UInt32>.size))
+        }
+
+        /// The byte length of an encoded message content
+        static var length: Int {
+            MemoryLayout<UInt32>.size * 2
+        }
+
+        /// The message content encoded to data
+        var encoded: Data {
+            time.encoded + id.encoded
+        }
+
+        /// The message content encoded to bytes
+        var bytes: [UInt8] {
+            time.bytes + id.bytes
+        }
+    }
+
+    /// The message authentication code for the message (32 bytes)
+    let mac: Data
+
+    /// The message content
+    let content: Content
+
+    /**
+     Create an authenticated message
+     - Parameter mac: The message authentication code
+     - Parameter content: The message content
+     */
+    init(mac: Data, content: Content) {
+        self.mac = mac
+        self.content = content
+    }
+
+    /**
+     Decode a message from a byte buffer.
+     The buffer must contain at least `Message.length` bytes, or it will return `nil`.
+     - Parameter buffer: The buffer containing the bytes.
+     */
+    init?(decodeFrom buffer: ByteBuffer) {
+        guard let data = buffer.getBytes(at: 0, length: Message.length) else {
+            return nil
+        }
+        self.init(decodeFrom: data)
+    }
+
+    /// The message encoded to data
+    var encoded: Data {
+        mac + content.encoded
+    }
+
+    /// The message encoded to bytes
+    var bytes: [UInt8] {
+        Array(mac) + content.bytes
+    }
+}
+
+ extension UInt32 {
+
+     /**
+      Create a value from a big-endian data representation (MSB first)
+      - Note: The data must contain exactly four bytes.
+      */
+     init<T: Sequence>(data: T) where T.Element == UInt8 {
+        self = data
+            .reversed()
+            .enumerated()
+            .map { UInt32($0.element) << ($0.offset * 8) }
+            .reduce(0, +)
+     }
+
+     /// The value encoded to a big-endian representation
+     var encoded: Data {
+         .init(bytes)
+     }
+
+     /// The value encoded to a big-endian byte array
+     var bytes: [UInt8] {
+         (0..<4).reversed().map {
+             UInt8((self >> ($0*8)) & 0xFF)
+         }
+     }
+}

Sesame/API/RouteAPI.swift

@@ -0,0 +1,16 @@
+import Foundation
+
+/**
+ The active urls on the server, for the device and the remote to connect
+ */
+enum RouteAPI: String {
+
+    /// Check the device status
+    case getDeviceStatus = "status"
+
+    /// Send a message to the server, to relay to the device
+    case postMessage = "message"
+
+    /// Open a socket between the device and the server
+    case socket = "listen"
+}

Sesame/Client.swift

@@ -19,7 +19,7 @@ struct Client {
     }
 
     func deviceStatus() async -> ClientState {
-        let url = server.appendingPathComponent("status")
+        let url = server.appendingPathComponent(RouteAPI.getDeviceStatus.rawValue)
         let request = URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData)
         let response = await integerReponse(to: request)
         switch response {
@@ -42,7 +42,7 @@ struct Client {
     }
     
     func send(_ message: Message) async throws -> (state: ClientState, response: Message?) {
-        let url = server.appendingPathComponent("message")
+        let url = server.appendingPathComponent(RouteAPI.postMessage.rawValue)
         var request = URLRequest(url: url)
         request.httpBody = message.encoded
         request.httpMethod = "POST"

Sesame/Message.swift

@@ -1,78 +0,0 @@
-import Foundation
-import NIOCore
-
-struct Message: Equatable, Hashable {
-
-    struct Content: Equatable, Hashable {
-
-        let time: UInt32
-
-        let id: UInt32
-
-        init(time: UInt32, id: UInt32) {
-            self.time = time
-            self.id = id
-        }
-
-        init<T: Sequence>(decodeFrom data: T) where T.Element == UInt8 {
-            self.time = UInt32(data: data.prefix(4))
-            self.id = UInt32(data: data.dropFirst(4))
-        }
-
-        static var length: Int {
-            MemoryLayout<UInt32>.size * 2
-        }
-
-        var encoded: Data {
-            time.encoded + id.encoded
-        }
-
-        var bytes: [UInt8] {
-            time.bytes + id.bytes
-        }
-    }
-
-    let mac: Data
-
-    let content: Content
-
-    init(mac: Data, content: Content) {
-        self.mac = mac
-        self.content = content
-    }
-
-    init?(decodeFrom buffer: ByteBuffer) {
-        guard let data = buffer.getBytes(at: 0, length: Message.length) else {
-            return nil
-        }
-        self.init(decodeFrom: data)
-    }
-
-    var encoded: Data {
-        mac + content.encoded
-    }
-
-    var bytes: [UInt8] {
-        Array(mac) + content.bytes
-    }
-}
-
- extension UInt32 {
-
-     init<T: Sequence>(data: T) where T.Element == UInt8 {
-        self = data
-            .enumerated()
-            .map { UInt32($0.element) << ($0.offset * 8) }
-            .reduce(0, +)
-    }
-
-    var encoded: Data {
-        .init(bytes)
-    }
-
-    var bytes: [UInt8] {
-        (0..<4).map {
-            UInt8((self >> ($0*8)) & 0xFF)
-        }
-    }
-}