You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
181 lines
6.8 KiB
181 lines
6.8 KiB
//
|
|
// SocketParsable.swift
|
|
// Socket.IO-Client-Swift
|
|
//
|
|
// 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
|
|
|
|
/// Defines that a type will be able to parse socket.io-protocol messages.
|
|
public protocol SocketParsable : AnyObject {
|
|
// MARK: Methods
|
|
|
|
/// Called when the engine has received some binary data that should be attached to a packet.
|
|
///
|
|
/// Packets binary data should be sent directly after the packet that expects it, so there's confusion over
|
|
/// where the data should go. Data should be received in the order it is sent, so that the correct data is put
|
|
/// into the correct placeholder.
|
|
///
|
|
/// - parameter data: The data that should be attached to a packet.
|
|
func parseBinaryData(_ data: Data) -> SocketPacket?
|
|
|
|
/// Called when the engine has received a string that should be parsed into a socket.io packet.
|
|
///
|
|
/// - parameter message: The string that needs parsing.
|
|
/// - returns: A completed socket packet if there is no more data left to collect.
|
|
func parseSocketMessage(_ message: String) -> SocketPacket?
|
|
}
|
|
|
|
/// Errors that can be thrown during parsing.
|
|
public enum SocketParsableError : Error {
|
|
// MARK: Cases
|
|
|
|
/// Thrown when a packet received has an invalid data array, or is missing the data array.
|
|
case invalidDataArray
|
|
|
|
/// Thrown when an malformed packet is received.
|
|
case invalidPacket
|
|
|
|
/// Thrown when the parser receives an unknown packet type.
|
|
case invalidPacketType
|
|
}
|
|
|
|
/// Says that a type will be able to buffer binary data before all data for an event has come in.
|
|
public protocol SocketDataBufferable : AnyObject {
|
|
// MARK: Properties
|
|
|
|
/// A list of packets that are waiting for binary data.
|
|
///
|
|
/// The way that socket.io works all data should be sent directly after each packet.
|
|
/// So this should ideally be an array of one packet waiting for data.
|
|
///
|
|
/// **This should not be modified directly.**
|
|
var waitingPackets: [SocketPacket] { get set }
|
|
}
|
|
|
|
public extension SocketParsable where Self: SocketManagerSpec & SocketDataBufferable {
|
|
/// Parses a message from the engine, returning a complete SocketPacket or throwing.
|
|
///
|
|
/// - parameter message: The message to parse.
|
|
/// - returns: A completed packet, or throwing.
|
|
internal func parseString(_ message: String) throws -> SocketPacket {
|
|
var reader = SocketStringReader(message: message)
|
|
|
|
guard let type = Int(reader.read(count: 1)).flatMap({ SocketPacket.PacketType(rawValue: $0) }) else {
|
|
throw SocketParsableError.invalidPacketType
|
|
}
|
|
|
|
if !reader.hasNext {
|
|
return SocketPacket(type: type, nsp: "/")
|
|
}
|
|
|
|
var namespace = "/"
|
|
var placeholders = -1
|
|
|
|
if type.isBinary {
|
|
if let holders = Int(reader.readUntilOccurence(of: "-")) {
|
|
placeholders = holders
|
|
} else {
|
|
throw SocketParsableError.invalidPacket
|
|
}
|
|
}
|
|
|
|
if reader.currentCharacter == "/" {
|
|
namespace = reader.readUntilOccurence(of: ",")
|
|
}
|
|
|
|
if !reader.hasNext {
|
|
return SocketPacket(type: type, nsp: namespace, placeholders: placeholders)
|
|
}
|
|
|
|
var idString = ""
|
|
|
|
if type == .error {
|
|
reader.advance(by: -1)
|
|
} else {
|
|
while let int = Int(reader.read(count: 1)) {
|
|
idString += String(int)
|
|
}
|
|
|
|
reader.advance(by: -2)
|
|
}
|
|
|
|
var dataArray = String(message.utf16[message.utf16.index(reader.currentIndex, offsetBy: 1)...])!
|
|
|
|
if type == .error && !dataArray.hasPrefix("[") && !dataArray.hasSuffix("]") {
|
|
dataArray = "[" + dataArray + "]"
|
|
}
|
|
|
|
let data = try parseData(dataArray)
|
|
|
|
return SocketPacket(type: type, data: data, id: Int(idString) ?? -1, nsp: namespace, placeholders: placeholders)
|
|
}
|
|
|
|
// Parses data for events
|
|
private func parseData(_ data: String) throws -> [Any] {
|
|
do {
|
|
return try data.toArray()
|
|
} catch {
|
|
throw SocketParsableError.invalidDataArray
|
|
}
|
|
}
|
|
|
|
/// Called when the engine has received a string that should be parsed into a socket.io packet.
|
|
///
|
|
/// - parameter message: The string that needs parsing.
|
|
/// - returns: A completed socket packet or nil if the packet is invalid.
|
|
func parseSocketMessage(_ message: String) -> SocketPacket? {
|
|
guard !message.isEmpty else { return nil }
|
|
|
|
DefaultSocketLogger.Logger.log("Parsing \(message)", type: "SocketParser")
|
|
|
|
do {
|
|
let packet = try parseString(message)
|
|
|
|
DefaultSocketLogger.Logger.log("Decoded packet as: \(packet.description)", type: "SocketParser")
|
|
|
|
return packet
|
|
} catch {
|
|
DefaultSocketLogger.Logger.error("\(error): \(message)", type: "SocketParser")
|
|
|
|
return nil
|
|
}
|
|
}
|
|
|
|
/// Called when the engine has received some binary data that should be attached to a packet.
|
|
///
|
|
/// Packets binary data should be sent directly after the packet that expects it, so there's confusion over
|
|
/// where the data should go. Data should be received in the order it is sent, so that the correct data is put
|
|
/// into the correct placeholder.
|
|
///
|
|
/// - parameter data: The data that should be attached to a packet.
|
|
/// - returns: A completed socket packet if there is no more data left to collect.
|
|
func parseBinaryData(_ data: Data) -> SocketPacket? {
|
|
guard !waitingPackets.isEmpty else {
|
|
DefaultSocketLogger.Logger.error("Got data when not remaking packet", type: "SocketParser")
|
|
|
|
return nil
|
|
}
|
|
|
|
// Should execute event?
|
|
guard waitingPackets[waitingPackets.count - 1].addData(data) else { return nil }
|
|
|
|
return waitingPackets.removeLast()
|
|
}
|
|
}
|