cheykrym/socket.io-client-swift
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

merge development

Browse Source
This commit is contained in:
Erik 2016-08-11 22:08:48 -04:00
commit ddd7003d89
No known key found for this signature in database
GPG Key ID: 4930B7C5FBC1A69D
6 changed files with 279 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/SSLSecurity.swift
View File

@ -88,10 +88,10 @@ public class SSLSecurity : NSObject {
- returns: a representation security object to be used with - returns: a representation security object to be used with
*/ */
public init(certs: [SSLCert], usePublicKeys: Bool) { public init(certs: [SSLCert], usePublicKeys: Bool) {
super.init()
self.usePublicKeys = usePublicKeys self.usePublicKeys = usePublicKeys
super.init()
if self.usePublicKeys { if self.usePublicKeys {
DispatchQueue.global(qos: .default).async { DispatchQueue.global(qos: .default).async {
let pubKeys = certs.reduce([SecKey]()) { (pubKeys: [SecKey], cert: SSLCert) -> [SecKey] in let pubKeys = certs.reduce([SecKey]()) { (pubKeys: [SecKey], cert: SSLCert) -> [SecKey] in

23
Source/SocketEngine.swift
View File

@ -153,17 +153,12 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
} }
} }
private func checkIfMessageIsBase64Binary(_ message: String) -> Bool { private func handleBase64(message: String) {
if message.hasPrefix("b4") {
// binary in base64 string // binary in base64 string
let noPrefix = message[message.characters.index(message.startIndex, offsetBy: 2)..<message.endIndex] let noPrefix = message[message.index(message.startIndex, offsetBy: 2)..<message.endIndex]
if let data = Data(base64Encoded: noPrefix, options: Data.Base64DecodingOptions(rawValue: 0)) {
client?.parseEngineBinaryData(data)
}
return true if let data = NSData(base64Encoded: noPrefix, options: .ignoreUnknownCharacters) {
} else { client?.parseEngineBinaryData(data as Data)
return false
} }
} }
@ -264,7 +259,7 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
} }
} }
ws?.queue = handleQueue ws?.callbackQueue = handleQueue
ws?.voipEnabled = voipEnabled ws?.voipEnabled = voipEnabled
ws?.delegate = self ws?.delegate = self
ws?.selfSignedSSL = selfSigned ws?.selfSignedSSL = selfSigned
@ -420,11 +415,13 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
let reader = SocketStringReader(message: message) let reader = SocketStringReader(message: message)
let fixedString: String let fixedString: String
guard let type = SocketEnginePacketType(rawValue: Int(reader.currentCharacter) ?? -1) else { if message.hasPrefix("b4") {
if !checkIfMessageIsBase64Binary(message) { return handleBase64(message: message)
checkAndHandleEngineError(message)
} }
guard let type = SocketEnginePacketType(rawValue: Int(reader.currentCharacter) ?? -1) else {
checkAndHandleEngineError(message)
return return
} }

69
Source/SocketExtensions.swift
View File

@ -41,6 +41,75 @@ extension CharacterSet {
} }
} }
extension NSDictionary {
private static func keyValueToSocketIOClientOption(key: String, value: AnyObject) -> SocketIOClientOption? {
switch (key, value) {
case let ("connectParams", params as [String: AnyObject]):
return .connectParams(params)
case let ("cookies", cookies as [HTTPCookie]):
return .cookies(cookies)
case let ("doubleEncodeUTF8", encode as Bool):
return .doubleEncodeUTF8(encode)
case let ("extraHeaders", headers as [String: String]):
return .extraHeaders(headers)
case let ("forceNew", force as Bool):
return .forceNew(force)
case let ("forcePolling", force as Bool):
return .forcePolling(force)
case let ("forceWebsockets", force as Bool):
return .forceWebsockets(force)
case let ("handleQueue", queue as DispatchQueue):
return .handleQueue(queue)
case let ("log", log as Bool):
return .log(log)
case let ("logger", logger as SocketLogger):
return .logger(logger)
case let ("nsp", nsp as String):
return .nsp(nsp)
case let ("path", path as String):
return .path(path)
case let ("reconnects", reconnects as Bool):
return .reconnects(reconnects)
case let ("reconnectAttempts", attempts as Int):
return .reconnectAttempts(attempts)
case let ("reconnectWait", wait as Int):
return .reconnectWait(wait)
case let ("secure", secure as Bool):
return .secure(secure)
case let ("security", security as SSLSecurity):
return .security(security)
case let ("selfSigned", selfSigned as Bool):
return .selfSigned(selfSigned)
case let ("sessionDelegate", delegate as URLSessionDelegate):
return .sessionDelegate(delegate)
case let ("voipEnabled", enable as Bool):
return .voipEnabled(enable)
default:
return nil
}
}
func toSocketOptionsSet() -> Set<SocketIOClientOption> {
var options = Set<SocketIOClientOption>()
for (rawKey, value) in self {
if let key = rawKey as? String, let opt = NSDictionary.keyValueToSocketIOClientOption(key: key, value: value) {
options.insertIgnore(opt)
}
}
return options
}
}
extension Set where Element : ClientOption {
mutating func insertIgnore(_ element: Element) {
if !contains(element) {
insert(element)
}
}
}
extension String { extension String {
func toArray() throws -> [AnyObject] { func toArray() throws -> [AnyObject] {
guard let stringData = data(using: .utf8, allowLossyConversion: false) else { return [] } guard let stringData = data(using: .utf8, allowLossyConversion: false) else { return [] }

22
Source/SocketIOClient.swift
View File

@ -279,7 +279,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
didDisconnect(reason: reason) didDisconnect(reason: reason)
} else if !reconnecting { } else if !reconnecting {
reconnecting = true reconnecting = true
tryReconnect(reason) tryReconnect(reason: reason)
} }
} }
@ -416,19 +416,17 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
return data.flatMap({$0 as? AnyObject}) return data.flatMap({$0 as? AnyObject})
} }
private func tryReconnect(_ reason: String) { private func tryReconnect(reason: String) {
if reconnecting { guard reconnecting else { return }
DefaultSocketLogger.Logger.log("Starting reconnect", type: logType) DefaultSocketLogger.Logger.log("Starting reconnect", type: logType)
handleEvent("reconnect", data: [reason as AnyObject], isInternalMessage: true) handleEvent("reconnect", data: [reason], isInternalMessage: true)
_tryReconnect() _tryReconnect()
} }
}
private func _tryReconnect() { private func _tryReconnect() {
if !reconnecting { guard reconnecting else { return }
return
}
if reconnectAttempts != -1 && currentReconnectAttempt + 1 > reconnectAttempts || !reconnects { if reconnectAttempts != -1 && currentReconnectAttempt + 1 > reconnectAttempts || !reconnects {
return didDisconnect(reason: "Reconnect Failed") return didDisconnect(reason: "Reconnect Failed")
@ -441,9 +439,9 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
currentReconnectAttempt += 1 currentReconnectAttempt += 1
connect() connect()
let dispatchAfter = DispatchTime.now() + Double(Int64(UInt64(reconnectWait) * NSEC_PER_SEC)) / Double(NSEC_PER_SEC) let deadline = DispatchTime.now() + Double(Int64(UInt64(reconnectWait) * NSEC_PER_SEC)) / Double(NSEC_PER_SEC)
DispatchQueue.main.asyncAfter(deadline: dispatchAfter, execute: _tryReconnect) DispatchQueue.main.asyncAfter(deadline: deadline, execute: _tryReconnect)
} }
} }
@ -461,7 +459,7 @@ extension SocketIOClient {
self.engine = engine self.engine = engine
} }
func emitTest(_ event: String, _ data: AnyObject...) { func emitTest(event: String, _ data: AnyObject...) {
self._emit([event as AnyObject] + data) _emit([event] + data)
} }
} }

69
Source/SocketIOClientOption.swift
View File

@ -156,72 +156,3 @@ public enum SocketIOClientOption : ClientOption {
public func ==(lhs: SocketIOClientOption, rhs: SocketIOClientOption) -> Bool { public func ==(lhs: SocketIOClientOption, rhs: SocketIOClientOption) -> Bool {
return lhs.description == rhs.description return lhs.description == rhs.description
} }
extension Set where Element : ClientOption {
mutating func insertIgnore(_ element: Element) {
if !contains(element) {
insert(element)
}
}
}
extension NSDictionary {
private static func keyValueToSocketIOClientOption(_ key: String, value: AnyObject) -> SocketIOClientOption? {
switch (key, value) {
case let ("connectParams", params as [String: AnyObject]):
return .connectParams(params)
case let ("cookies", cookies as [HTTPCookie]):
return .cookies(cookies)
case let ("doubleEncodeUTF8", encode as Bool):
return .doubleEncodeUTF8(encode)
case let ("extraHeaders", headers as [String: String]):
return .extraHeaders(headers)
case let ("forceNew", force as Bool):
return .forceNew(force)
case let ("forcePolling", force as Bool):
return .forcePolling(force)
case let ("forceWebsockets", force as Bool):
return .forceWebsockets(force)
case let ("handleQueue", queue as DispatchQueue):
return .handleQueue(queue)
case let ("log", log as Bool):
return .log(log)
case let ("logger", logger as SocketLogger):
return .logger(logger)
case let ("nsp", nsp as String):
return .nsp(nsp)
case let ("path", path as String):
return .path(path)
case let ("reconnects", reconnects as Bool):
return .reconnects(reconnects)
case let ("reconnectAttempts", attempts as Int):
return .reconnectAttempts(attempts)
case let ("reconnectWait", wait as Int):
return .reconnectWait(wait)
case let ("secure", secure as Bool):
return .secure(secure)
case let ("security", security as SSLSecurity):
return .security(security)
case let ("selfSigned", selfSigned as Bool):
return .selfSigned(selfSigned)
case let ("sessionDelegate", delegate as URLSessionDelegate):
return .sessionDelegate(delegate)
case let ("voipEnabled", enable as Bool):
return .voipEnabled(enable)
default:
return nil
}
}
func toSocketOptionsSet() -> Set<SocketIOClientOption> {
var options = Set<SocketIOClientOption>()
for (rawKey, value) in self {
if let key = rawKey as? String, let opt = NSDictionary.keyValueToSocketIOClientOption(key, value: value) {
options.insertIgnore(opt)
}
}
return options
}
}

303
Source/WebSocket.swift
View File

@ -64,21 +64,20 @@ public class WebSocket : NSObject, StreamDelegate {
case messageTooBig = 1009 case messageTooBig = 1009
} }
#if swift(>=3)
#else
public static let ErrorDomain = "WebSocket" public static let ErrorDomain = "WebSocket"
#endif
enum InternalErrorCode: UInt16 { enum InternalErrorCode: UInt16 {
// 0-999 WebSocket status codes not used // 0-999 WebSocket status codes not used
case outputStreamWriteError = 1 case outputStreamWriteError = 1
} }
//Where the callback is executed. It defaults to the main UI thread queue. /// Where the callback is executed. It defaults to the main UI thread queue.
public var queue = DispatchQueue.main public var callbackQueue = DispatchQueue.main
var optionalProtocols : [String]? var optionalProtocols : [String]?
//Constant Values.
// MARK: - Constants
let headerWSUpgradeName = "Upgrade" let headerWSUpgradeName = "Upgrade"
let headerWSUpgradeValue = "websocket" let headerWSUpgradeValue = "websocket"
let headerWSHostName = "Host" let headerWSHostName = "Host"
@ -97,6 +96,8 @@ public class WebSocket : NSObject, StreamDelegate {
let MaskMask: UInt8 = 0x80 let MaskMask: UInt8 = 0x80
let PayloadLenMask: UInt8 = 0x7F let PayloadLenMask: UInt8 = 0x7F
let MaxFrameSize: Int = 32 let MaxFrameSize: Int = 32
let httpSwitchProtocolCode = 101
let supportedSSLSchemes = ["wss", "https"]
class WSResponse { class WSResponse {
var isFin = false var isFin = false
@ -106,13 +107,24 @@ public class WebSocket : NSObject, StreamDelegate {
var buffer: NSMutableData? var buffer: NSMutableData?
} }
// MARK: - Delegates
/// Responds to callback about new messages coming in over the WebSocket
/// and also connection/disconnect messages.
public weak var delegate: WebSocketDelegate? public weak var delegate: WebSocketDelegate?
/// Recives a callback for each pong message recived.
public weak var pongDelegate: WebSocketPongDelegate? public weak var pongDelegate: WebSocketPongDelegate?
// MARK: - Block based API.
public var onConnect: ((Void) -> Void)? public var onConnect: ((Void) -> Void)?
public var onDisconnect: ((NSError?) -> Void)? public var onDisconnect: ((NSError?) -> Void)?
public var onText: ((String) -> Void)? public var onText: ((String) -> Void)?
public var onData: ((Data) -> Void)? public var onData: ((Data) -> Void)?
public var onPong: ((Void) -> Void)? public var onPong: ((Void) -> Void)?
public var headers = [String: String]() public var headers = [String: String]()
public var voipEnabled = false public var voipEnabled = false
public var selfSignedSSL = false public var selfSignedSSL = false
@ -123,12 +135,16 @@ public class WebSocket : NSObject, StreamDelegate {
public var isConnected :Bool { public var isConnected :Bool {
return connected return connected
} }
public var currentURL: URL {return url}
private var url: URL public var currentURL: NSURL { return url }
// MARK: - Private
private var url: NSURL
private var inputStream: InputStream? private var inputStream: InputStream?
private var outputStream: NSOutputStream? private var outputStream: NSOutputStream?
private var connected = false private var connected = false
private var isCreated = false private var isConnecting = false
private var writeQueue = OperationQueue() private var writeQueue = OperationQueue()
private var readStack = [WSResponse]() private var readStack = [WSResponse]()
private var inputQueue = [Data]() private var inputQueue = [Data]()
@ -144,24 +160,25 @@ public class WebSocket : NSObject, StreamDelegate {
mutex.unlock() mutex.unlock()
return canWork return canWork
} }
//the shared processing queue used for all websocket
private static let sharedWorkQueue = DispatchQueue(label: "com.vluxe.starscream.websocket", attributes: [])
//used for setting protocols. /// The shared processing queue used for all WebSocket.
public init(url: URL, protocols: [String]? = nil) { private static let sharedWorkQueue = DispatchQueue(label: "com.vluxe.starscream.websocket")
/// Used for setting protocols.
public init(url: NSURL, protocols: [String]? = nil) {
self.url = url self.url = url
self.origin = url.absoluteString self.origin = url.absoluteString
writeQueue.maxConcurrentOperationCount = 1 writeQueue.maxConcurrentOperationCount = 1
optionalProtocols = protocols optionalProtocols = protocols
} }
///Connect to the websocket server on a background thread /// Connect to the WebSocket server on a background thread.
public func connect() { public func connect() {
guard !isCreated else { return } guard !isConnecting else { return }
didDisconnect = false didDisconnect = false
isCreated = true isConnecting = true
createHTTPRequest() createHTTPRequest()
isCreated = false isConnecting = false
} }
/** /**
@ -176,15 +193,15 @@ public class WebSocket : NSObject, StreamDelegate {
public func disconnect(_ forceTimeout: TimeInterval? = nil) { public func disconnect(_ forceTimeout: TimeInterval? = nil) {
switch forceTimeout { switch forceTimeout {
case .some(let seconds) where seconds > 0: case .some(let seconds) where seconds > 0:
queue.asyncAfter(deadline: DispatchTime.now() + Double(Int64(seconds * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)) { [weak self] in callbackQueue.asyncAfter(deadline: DispatchTime.now() + Double(Int64(seconds * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)) { [weak self] in
self?.disconnectStream(nil) self?.disconnectStream(error: nil)
} }
fallthrough fallthrough
case .none: case .none:
writeError(CloseCode.normal.rawValue) writeError(code: CloseCode.normal.rawValue)
default: default:
self.disconnectStream(nil) disconnectStream(error: nil)
break break
} }
} }
@ -199,7 +216,7 @@ public class WebSocket : NSObject, StreamDelegate {
*/ */
public func writeString(_ str: String, completion: (() -> ())? = nil) { public func writeString(_ str: String, completion: (() -> ())? = nil) {
guard isConnected else { return } guard isConnected else { return }
dequeueWrite(str.data(using: String.Encoding.utf8)!, code: .textFrame, writeCompletion: completion) dequeueWrite(data: str.data(using: String.Encoding.utf8)!, code: .textFrame, writeCompletion: completion)
} }
/** /**
@ -212,17 +229,17 @@ public class WebSocket : NSObject, StreamDelegate {
*/ */
public func writeData(_ data: Data, completion: (() -> ())? = nil) { public func writeData(_ data: Data, completion: (() -> ())? = nil) {
guard isConnected else { return } guard isConnected else { return }
dequeueWrite(data, code: .binaryFrame, writeCompletion: completion) dequeueWrite(data: data, code: .binaryFrame, writeCompletion: completion)
} }
//write a ping to the websocket. This sends it as a control frame. // Write a ping to the websocket. This sends it as a control frame.
//yodel a sound to the planet. This sends it as an astroid. http://youtu.be/Eu5ZJELRiJ8?t=42s // Yodel a sound to the planet. This sends it as an astroid. http://youtu.be/Eu5ZJELRiJ8?t=42s
public func writePing(_ data: Data, completion: (() -> ())? = nil) { public func writePing(data: NSData, completion: (() -> ())? = nil) {
guard isConnected else { return } guard isConnected else { return }
dequeueWrite(data, code: .ping, writeCompletion: completion) dequeueWrite(data: data, code: .ping, writeCompletion: completion)
} }
//private method that starts the connection /// Private method that starts the connection.
private func createHTTPRequest() { private func createHTTPRequest() {
let urlRequest = CFHTTPMessageCreateRequest(kCFAllocatorDefault, "GET", let urlRequest = CFHTTPMessageCreateRequest(kCFAllocatorDefault, "GET",
@ -230,38 +247,38 @@ public class WebSocket : NSObject, StreamDelegate {
var port = url.port var port = url.port
if port == nil { if port == nil {
if ["wss", "https"].contains(url.scheme!) { if supportedSSLSchemes.contains(url.scheme!) {
port = 443 port = 443
} else { } else {
port = 80 port = 80
} }
} }
addHeader(urlRequest, key: headerWSUpgradeName as NSString, val: headerWSUpgradeValue as NSString) addHeader(urlRequest: urlRequest, key: headerWSUpgradeName as NSString, val: headerWSUpgradeValue as NSString)
addHeader(urlRequest, key: headerWSConnectionName as NSString, val: headerWSConnectionValue as NSString) addHeader(urlRequest: urlRequest, key: headerWSConnectionName as NSString, val: headerWSConnectionValue as NSString)
if let protocols = optionalProtocols { if let protocols = optionalProtocols {
addHeader(urlRequest, key: headerWSProtocolName as NSString, val: protocols.joined(separator: ",") as NSString) addHeader(urlRequest: urlRequest, key: headerWSProtocolName as NSString, val: protocols.joined(separator: ",") as NSString)
} }
addHeader(urlRequest, key: headerWSVersionName as NSString, val: headerWSVersionValue as NSString) addHeader(urlRequest: urlRequest, key: headerWSVersionName as NSString, val: headerWSVersionValue as NSString)
addHeader(urlRequest, key: headerWSKeyName as NSString, val: generateWebSocketKey() as NSString) addHeader(urlRequest: urlRequest, key: headerWSKeyName as NSString, val: generateWebSocketKey() as NSString)
if let origin = origin { if let origin = origin {
addHeader(urlRequest, key: headerOriginName as NSString, val: origin as NSString) addHeader(urlRequest: urlRequest, key: headerOriginName as NSString, val: origin as NSString)
} }
addHeader(urlRequest, key: headerWSHostName as NSString, val: "\(url.host!):\(port!)" as NSString) addHeader(urlRequest: urlRequest, key: headerWSHostName as NSString, val: "\(url.host!):\(port!)" as NSString)
for (key,value) in headers { for (key,value) in headers {
addHeader(urlRequest, key: key as NSString, val: value as NSString) addHeader(urlRequest: urlRequest, key: key as NSString, val: value as NSString)
} }
if let cfHTTPMessage = CFHTTPMessageCopySerializedMessage(urlRequest) { if let cfHTTPMessage = CFHTTPMessageCopySerializedMessage(urlRequest) {
let serializedRequest = cfHTTPMessage.takeRetainedValue() let serializedRequest = cfHTTPMessage.takeRetainedValue()
initStreamsWithData(serializedRequest as Data, Int(port!)) initStreamsWithData(data: serializedRequest as Data, Int(port!))
} }
} }
//Add a header to the CFHTTPMessage by using the NSString bridges to CFString /// Add a header to the CFHTTPMessage by using the NSString bridges to CFString.
private func addHeader(_ urlRequest: CFHTTPMessage, key: NSString, val: NSString) { private func addHeader(urlRequest: CFHTTPMessage, key: NSString, val: NSString) {
CFHTTPMessageSetHeaderFieldValue(urlRequest, key, val) CFHTTPMessageSetHeaderFieldValue(urlRequest, key, val)
} }
//generate a websocket key as needed in rfc /// Generate a WebSocket key as needed in RFC.
private func generateWebSocketKey() -> String { private func generateWebSocketKey() -> String {
var key = "" var key = ""
let seed = 16 let seed = 16
@ -274,8 +291,8 @@ public class WebSocket : NSObject, StreamDelegate {
return baseKey! return baseKey!
} }
//Start the stream connection and write the data to the output stream /// Start the stream connection and write the data to the output stream.
private func initStreamsWithData(_ data: Data, _ port: Int) { private func initStreamsWithData(data: NSData, _ port: Int) {
//higher level API we will cut over to at some point //higher level API we will cut over to at some point
//NSStream.getStreamsToHostWithName(url.host, port: url.port.integerValue, inputStream: &inputStream, outputStream: &outputStream) //NSStream.getStreamsToHostWithName(url.host, port: url.port.integerValue, inputStream: &inputStream, outputStream: &outputStream)
@ -288,9 +305,9 @@ public class WebSocket : NSObject, StreamDelegate {
guard let inStream = inputStream, let outStream = outputStream else { return } guard let inStream = inputStream, let outStream = outputStream else { return }
inStream.delegate = self inStream.delegate = self
outStream.delegate = self outStream.delegate = self
if ["wss", "https"].contains(url.scheme!) { if supportedSSLSchemes.contains(url.scheme!) {
inStream.setProperty(StreamSocketSecurityLevel.negotiatedSSL as NSString, forKey: Stream.PropertyKey(rawValue: Stream.PropertyKey.socketSecurityLevelKey.rawValue)) inStream.setProperty(StreamSocketSecurityLevel.negotiatedSSL, forKey: Stream.PropertyKey.socketSecurityLevelKey)
outStream.setProperty(StreamSocketSecurityLevel.negotiatedSSL as NSString, forKey: Stream.PropertyKey(rawValue: Stream.PropertyKey.socketSecurityLevelKey.rawValue)) outStream.setProperty(StreamSocketSecurityLevel.negotiatedSSL, forKey: Stream.PropertyKey.socketSecurityLevelKey)
} else { } else {
certValidated = true //not a https session, so no need to check SSL pinning certValidated = true //not a https session, so no need to check SSL pinning
} }
@ -300,8 +317,8 @@ public class WebSocket : NSObject, StreamDelegate {
} }
if selfSignedSSL { if selfSignedSSL {
let settings: [NSObject: NSObject] = [kCFStreamSSLValidatesCertificateChain: NSNumber(value: false), kCFStreamSSLPeerName: kCFNull] let settings: [NSObject: NSObject] = [kCFStreamSSLValidatesCertificateChain: NSNumber(value: false), kCFStreamSSLPeerName: kCFNull]
inStream.setProperty(settings as AnyObject?, forKey: kCFStreamPropertySSLSettings as Stream.PropertyKey) inStream.setProperty(settings, forKey: kCFStreamPropertySSLSettings as Stream.PropertyKey)
outStream.setProperty(settings as AnyObject?, forKey: kCFStreamPropertySSLSettings as Stream.PropertyKey) outStream.setProperty(settings, forKey: kCFStreamPropertySSLSettings as Stream.PropertyKey)
} }
if let cipherSuites = self.enabledSSLCipherSuites { if let cipherSuites = self.enabledSSLCipherSuites {
if let sslContextIn = CFReadStreamCopyProperty(inputStream, CFStreamPropertyKey(rawValue: kCFStreamPropertySSLContext)) as! SSLContext?, if let sslContextIn = CFReadStreamCopyProperty(inputStream, CFStreamPropertyKey(rawValue: kCFStreamPropertySSLContext)) as! SSLContext?,
@ -309,13 +326,13 @@ public class WebSocket : NSObject, StreamDelegate {
let resIn = SSLSetEnabledCiphers(sslContextIn, cipherSuites, cipherSuites.count) let resIn = SSLSetEnabledCiphers(sslContextIn, cipherSuites, cipherSuites.count)
let resOut = SSLSetEnabledCiphers(sslContextOut, cipherSuites, cipherSuites.count) let resOut = SSLSetEnabledCiphers(sslContextOut, cipherSuites, cipherSuites.count)
if resIn != errSecSuccess { if resIn != errSecSuccess {
let error = self.errorWithDetail("Error setting ingoing cypher suites", code: UInt16(resIn)) let error = self.errorWithDetail(detail: "Error setting ingoing cypher suites", code: UInt16(resIn))
disconnectStream(error) disconnectStream(error: error)
return return
} }
if resOut != errSecSuccess { if resOut != errSecSuccess {
let error = self.errorWithDetail("Error setting outgoing cypher suites", code: UInt16(resOut)) let error = self.errorWithDetail(detail: "Error setting outgoing cypher suites", code: UInt16(resOut))
disconnectStream(error) disconnectStream(error: error)
return return
} }
} }
@ -329,7 +346,7 @@ public class WebSocket : NSObject, StreamDelegate {
self.readyToWrite = true self.readyToWrite = true
self.mutex.unlock() self.mutex.unlock()
let bytes = UnsafePointer<UInt8>((data as NSData).bytes) let bytes = UnsafePointer<UInt8>(data.bytes)
var out = timeout * 1000000 // wait 5 seconds before giving up var out = timeout * 1000000 // wait 5 seconds before giving up
writeQueue.addOperation { [weak self] in writeQueue.addOperation { [weak self] in
while !outStream.hasSpaceAvailable { while !outStream.hasSpaceAvailable {
@ -337,18 +354,19 @@ public class WebSocket : NSObject, StreamDelegate {
out -= 100 out -= 100
if out < 0 { if out < 0 {
self?.cleanupStream() self?.cleanupStream()
self?.doDisconnect(self?.errorWithDetail("write wait timed out", code: 2)) self?.doDisconnect(error: self?.errorWithDetail(detail: "write wait timed out", code: 2))
return return
} else if outStream.streamError != nil { } else if outStream.streamError != nil {
return // disconnectStream will be called. return // disconnectStream will be called.
} }
} }
outStream.write(bytes, maxLength: data.count) outStream.write(bytes, maxLength: data.length)
} }
} }
//delegate for the stream methods. Processes incoming bytes // Delegate for the stream methods. Processes incoming bytes.
public func stream(_ aStream: Stream, handle eventCode: Stream.Event) { public func stream(aStream: Stream, handleEvent eventCode: Stream.Event) {
if let sec = security , !certValidated && [.hasBytesAvailable, .hasSpaceAvailable].contains(eventCode) { if let sec = security , !certValidated && [.hasBytesAvailable, .hasSpaceAvailable].contains(eventCode) {
let possibleTrust: AnyObject? = aStream.property(forKey: kCFStreamPropertySSLPeerTrust as Stream.PropertyKey) let possibleTrust: AnyObject? = aStream.property(forKey: kCFStreamPropertySSLPeerTrust as Stream.PropertyKey)
if let trust: AnyObject = possibleTrust { if let trust: AnyObject = possibleTrust {
@ -356,8 +374,8 @@ public class WebSocket : NSObject, StreamDelegate {
if sec.isValid(trust as! SecTrust, domain: domain as! String?) { if sec.isValid(trust as! SecTrust, domain: domain as! String?) {
certValidated = true certValidated = true
} else { } else {
let error = errorWithDetail("Invalid SSL certificate", code: 1) let error = errorWithDetail(detail: "Invalid SSL certificate", code: 1)
disconnectStream(error) disconnectStream(error: error)
return return
} }
} }
@ -367,20 +385,21 @@ public class WebSocket : NSObject, StreamDelegate {
processInputStream() processInputStream()
} }
} else if eventCode == .errorOccurred { } else if eventCode == .errorOccurred {
disconnectStream(aStream.streamError) disconnectStream(error: aStream.streamError)
} else if eventCode == .endEncountered { } else if eventCode == .endEncountered {
disconnectStream(nil) disconnectStream(error: nil)
} }
} }
//disconnect the stream object
private func disconnectStream(_ error: NSError?) { /// Disconnect the stream object and notifies the delegate.
private func disconnectStream(error: NSError?) {
if error == nil { if error == nil {
writeQueue.waitUntilAllOperationsAreFinished() writeQueue.waitUntilAllOperationsAreFinished()
} else { } else {
writeQueue.cancelAllOperations() writeQueue.cancelAllOperations()
} }
cleanupStream() cleanupStream()
doDisconnect(error) doDisconnect(error: error)
} }
private func cleanupStream() { private func cleanupStream() {
@ -398,7 +417,7 @@ public class WebSocket : NSObject, StreamDelegate {
inputStream = nil inputStream = nil
} }
///handles the incoming bytes and sending them to the proper processing method /// Handles the incoming bytes and sending them to the proper processing method.
private func processInputStream() { private func processInputStream() {
let buf = NSMutableData(capacity: BUFFER_MAX) let buf = NSMutableData(capacity: BUFFER_MAX)
let buffer = UnsafeMutablePointer<UInt8>(buf!.bytes) let buffer = UnsafeMutablePointer<UInt8>(buf!.bytes)
@ -414,7 +433,8 @@ public class WebSocket : NSObject, StreamDelegate {
dequeueInput() dequeueInput()
} }
} }
///dequeue the incoming input so it is processed in order
/// Dequeue the incoming input so it is processed in order.
private func dequeueInput() { private func dequeueInput() {
while !inputQueue.isEmpty { while !inputQueue.isEmpty {
let data = inputQueue[0] let data = inputQueue[0]
@ -428,7 +448,7 @@ public class WebSocket : NSObject, StreamDelegate {
let buffer = UnsafePointer<UInt8>((work as NSData).bytes) let buffer = UnsafePointer<UInt8>((work as NSData).bytes)
let length = work.count let length = work.count
if !connected { if !connected {
processTCPHandshake(buffer, bufferLen: length) processTCPHandshake(buffer: buffer, bufferLen: length)
} else { } else {
processRawMessagesInBuffer(buffer, bufferLen: length) processRawMessagesInBuffer(buffer, bufferLen: length)
} }
@ -436,28 +456,29 @@ public class WebSocket : NSObject, StreamDelegate {
} }
} }
//handle checking the inital connection status // Handle checking the initial connection status.
private func processTCPHandshake(_ buffer: UnsafePointer<UInt8>, bufferLen: Int) { private func processTCPHandshake(buffer: UnsafePointer<UInt8>, bufferLen: Int) {
let code = processHTTP(buffer, bufferLen: bufferLen) let code = processHTTP(buffer: buffer, bufferLen: bufferLen)
switch code { switch code {
case 0: case 0:
connected = true connected = true
guard canDispatch else {return} guard canDispatch else {return}
queue.async { [weak self] in callbackQueue.async { [weak self] in
guard let s = self else { return } guard let s = self else { return }
s.onConnect?() s.onConnect?()
s.delegate?.websocketDidConnect(s) s.delegate?.websocketDidConnect(s)
s.notificationCenter.post(name: NSNotification.Name(WebsocketDidConnectNotification), object: self) s.notificationCenter.post(name: NSNotification.Name(WebsocketDidConnectNotification), object: self)
} }
case -1: case -1:
fragBuffer = Data(bytes: UnsafePointer<UInt8>(buffer), count: bufferLen) fragBuffer = NSData(bytes: buffer, length: bufferLen) as Data
break // do nothing, we are going to collect more data break // do nothing, we are going to collect more data
default: default:
doDisconnect(errorWithDetail("Invalid HTTP upgrade", code: UInt16(code))) doDisconnect(error: errorWithDetail(detail: "Invalid HTTP upgrade", code: UInt16(code)))
} }
} }
/// Finds the HTTP Packet in the TCP stream, by looking for the CRLF. /// Finds the HTTP Packet in the TCP stream, by looking for the CRLF.
private func processHTTP(_ buffer: UnsafePointer<UInt8>, bufferLen: Int) -> Int { private func processHTTP(buffer: UnsafePointer<UInt8>, bufferLen: Int) -> Int {
let CRLFBytes = [UInt8(ascii: "\r"), UInt8(ascii: "\n"), UInt8(ascii: "\r"), UInt8(ascii: "\n")] let CRLFBytes = [UInt8(ascii: "\r"), UInt8(ascii: "\n"), UInt8(ascii: "\r"), UInt8(ascii: "\n")]
var k = 0 var k = 0
var totalSize = 0 var totalSize = 0
@ -473,7 +494,7 @@ public class WebSocket : NSObject, StreamDelegate {
} }
} }
if totalSize > 0 { if totalSize > 0 {
let code = validateResponse(buffer, bufferLen: totalSize) let code = validateResponse(buffer: buffer, bufferLen: totalSize)
if code != 0 { if code != 0 {
return code return code
} }
@ -484,15 +505,15 @@ public class WebSocket : NSObject, StreamDelegate {
} }
return 0 //success return 0 //success
} }
return -1 //was unable to find the full TCP header return -1 // Was unable to find the full TCP header.
} }
///validates the HTTP is a 101 as per the RFC spec /// Validates the HTTP is a 101 as per the RFC spec.
private func validateResponse(_ buffer: UnsafePointer<UInt8>, bufferLen: Int) -> Int { private func validateResponse(buffer: UnsafePointer<UInt8>, bufferLen: Int) -> Int {
let response = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, false).takeRetainedValue() let response = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, false).takeRetainedValue()
CFHTTPMessageAppendBytes(response, buffer, bufferLen) CFHTTPMessageAppendBytes(response, buffer, bufferLen)
let code = CFHTTPMessageGetResponseStatusCode(response) let code = CFHTTPMessageGetResponseStatusCode(response)
if code != 101 { if code != httpSwitchProtocolCode {
return code return code
} }
if let cfHeaders = CFHTTPMessageCopyAllHeaderFields(response) { if let cfHeaders = CFHTTPMessageCopyAllHeaderFields(response) {
@ -506,13 +527,13 @@ public class WebSocket : NSObject, StreamDelegate {
return -1 return -1
} }
///read a 16 bit big endian value from a buffer ///read a 16-bit big endian value from a buffer
private static func readUint16(_ buffer: UnsafePointer<UInt8>, offset: Int) -> UInt16 { private static func readUint16(buffer: UnsafePointer<UInt8>, offset: Int) -> UInt16 {
return (UInt16(buffer[offset + 0]) << 8) | UInt16(buffer[offset + 1]) return (UInt16(buffer[offset + 0]) << 8) | UInt16(buffer[offset + 1])
} }
///read a 64 bit big endian value from a buffer ///read a 64-bit big endian value from a buffer
private static func readUint64(_ buffer: UnsafePointer<UInt8>, offset: Int) -> UInt64 { private static func readUint64(buffer: UnsafePointer<UInt8>, offset: Int) -> UInt64 {
var value = UInt64(0) var value = UInt64(0)
for i in 0...7 { for i in 0...7 {
value = (value << 8) | UInt64(buffer[offset + i]) value = (value << 8) | UInt64(buffer[offset + i])
@ -520,14 +541,14 @@ public class WebSocket : NSObject, StreamDelegate {
return value return value
} }
///write a 16 bit big endian value to a buffer /// Write a 16-bit big endian value to a buffer.
private static func writeUint16(_ buffer: UnsafeMutablePointer<UInt8>, offset: Int, value: UInt16) { private static func writeUint16(buffer: UnsafeMutablePointer<UInt8>, offset: Int, value: UInt16) {
buffer[offset + 0] = UInt8(value >> 8) buffer[offset + 0] = UInt8(value >> 8)
buffer[offset + 1] = UInt8(value & 0xff) buffer[offset + 1] = UInt8(value & 0xff)
} }
///write a 64 bit big endian value to a buffer /// Write a 64-bit big endian value to a buffer.
private static func writeUint64(_ buffer: UnsafeMutablePointer<UInt8>, offset: Int, value: UInt64) { private static func writeUint64(buffer: UnsafeMutablePointer<UInt8>, offset: Int, value: UInt64) {
for i in 0...7 { for i in 0...7 {
buffer[offset + i] = UInt8((value >> (8*UInt64(7 - i))) & 0xff) buffer[offset + i] = UInt8((value >> (8*UInt64(7 - i))) & 0xff)
} }
@ -552,7 +573,7 @@ public class WebSocket : NSObject, StreamDelegate {
} }
response.bytesLeft -= len response.bytesLeft -= len
response.buffer?.append(Data(bytes: baseAddress, count: len)) response.buffer?.append(Data(bytes: baseAddress, count: len))
processResponse(response) processResponse(response: response)
return buffer.fromOffset(bufferLen - extra) return buffer.fromOffset(bufferLen - extra)
} else { } else {
let isFin = (FinMask & baseAddress[0]) let isFin = (FinMask & baseAddress[0])
@ -562,22 +583,22 @@ public class WebSocket : NSObject, StreamDelegate {
var offset = 2 var offset = 2
if (isMasked > 0 || (RSVMask & baseAddress[0]) > 0) && receivedOpcode != .pong { if (isMasked > 0 || (RSVMask & baseAddress[0]) > 0) && receivedOpcode != .pong {
let errCode = CloseCode.protocolError.rawValue let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("masked and rsv data is not currently supported", code: errCode)) doDisconnect(error: errorWithDetail(detail: "masked and rsv data is not currently supported", code: errCode))
writeError(errCode) writeError(code: errCode)
return emptyBuffer return emptyBuffer
} }
let isControlFrame = (receivedOpcode == .connectionClose || receivedOpcode == .ping) let isControlFrame = (receivedOpcode == .connectionClose || receivedOpcode == .ping)
if !isControlFrame && (receivedOpcode != .binaryFrame && receivedOpcode != .continueFrame && if !isControlFrame && (receivedOpcode != .binaryFrame && receivedOpcode != .continueFrame &&
receivedOpcode != .textFrame && receivedOpcode != .pong) { receivedOpcode != .textFrame && receivedOpcode != .pong) {
let errCode = CloseCode.protocolError.rawValue let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("unknown opcode: \(receivedOpcode)", code: errCode)) doDisconnect(error: errorWithDetail(detail: "unknown opcode: \(receivedOpcode)", code: errCode))
writeError(errCode) writeError(code: errCode)
return emptyBuffer return emptyBuffer
} }
if isControlFrame && isFin == 0 { if isControlFrame && isFin == 0 {
let errCode = CloseCode.protocolError.rawValue let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("control frames can't be fragmented", code: errCode)) doDisconnect(error: errorWithDetail(detail: "control frames can't be fragmented", code: errCode))
writeError(errCode) writeError(code: errCode)
return emptyBuffer return emptyBuffer
} }
if receivedOpcode == .connectionClose { if receivedOpcode == .connectionClose {
@ -585,36 +606,38 @@ public class WebSocket : NSObject, StreamDelegate {
if payloadLen == 1 { if payloadLen == 1 {
code = CloseCode.protocolError.rawValue code = CloseCode.protocolError.rawValue
} else if payloadLen > 1 { } else if payloadLen > 1 {
code = WebSocket.readUint16(baseAddress, offset: offset) code = WebSocket.readUint16(buffer: baseAddress, offset: offset)
if code < 1000 || (code > 1003 && code < 1007) || (code > 1011 && code < 3000) { if code < 1000 || (code > 1003 && code < 1007) || (code > 1011 && code < 3000) {
code = CloseCode.protocolError.rawValue code = CloseCode.protocolError.rawValue
} }
offset += 2 offset += 2
} }
var closeReason = "connection closed by server"
if payloadLen > 2 { if payloadLen > 2 {
let len = Int(payloadLen - 2) let len = Int(payloadLen - 2)
if len > 0 { if len > 0 {
let bytes = baseAddress + offset let bytes = baseAddress + offset
let str: NSString? = NSString(data: Data(bytes: bytes, count: len), encoding: String.Encoding.utf8.rawValue) if let customCloseReason = String(data: NSData(bytes: bytes, length: len) as Data, encoding: String.Encoding.utf8) {
if str == nil { closeReason = customCloseReason
} else {
code = CloseCode.protocolError.rawValue code = CloseCode.protocolError.rawValue
} }
} }
} }
doDisconnect(errorWithDetail("connection closed by server", code: code)) doDisconnect(error: errorWithDetail(detail: closeReason, code: code))
writeError(code) writeError(code: code)
return emptyBuffer return emptyBuffer
} }
if isControlFrame && payloadLen > 125 { if isControlFrame && payloadLen > 125 {
writeError(CloseCode.protocolError.rawValue) writeError(code: CloseCode.protocolError.rawValue)
return emptyBuffer return emptyBuffer
} }
var dataLength = UInt64(payloadLen) var dataLength = UInt64(payloadLen)
if dataLength == 127 { if dataLength == 127 {
dataLength = WebSocket.readUint64(baseAddress, offset: offset) dataLength = WebSocket.readUint64(buffer: baseAddress, offset: offset)
offset += sizeof(UInt64.self) offset += sizeof(UInt64.self)
} else if dataLength == 126 { } else if dataLength == 126 {
dataLength = UInt64(WebSocket.readUint16(baseAddress, offset: offset)) dataLength = UInt64(WebSocket.readUint16(buffer: baseAddress, offset: offset))
offset += sizeof(UInt16.self) offset += sizeof(UInt16.self)
} }
if bufferLen < offset || UInt64(bufferLen - offset) < dataLength { if bufferLen < offset || UInt64(bufferLen - offset) < dataLength {
@ -634,7 +657,7 @@ public class WebSocket : NSObject, StreamDelegate {
} }
if receivedOpcode == .pong { if receivedOpcode == .pong {
if canDispatch { if canDispatch {
queue.async { [weak self] in callbackQueue.async { [weak self] in
guard let s = self else { return } guard let s = self else { return }
s.onPong?() s.onPong?()
s.pongDelegate?.websocketDidReceivePong(s) s.pongDelegate?.websocketDidReceivePong(s)
@ -644,21 +667,21 @@ public class WebSocket : NSObject, StreamDelegate {
} }
var response = readStack.last var response = readStack.last
if isControlFrame { if isControlFrame {
response = nil //don't append pings response = nil // Don't append pings.
} }
if isFin == 0 && receivedOpcode == .continueFrame && response == nil { if isFin == 0 && receivedOpcode == .continueFrame && response == nil {
let errCode = CloseCode.protocolError.rawValue let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("continue frame before a binary or text frame", code: errCode)) doDisconnect(error: errorWithDetail(detail: "continue frame before a binary or text frame", code: errCode))
writeError(errCode) writeError(code: errCode)
return emptyBuffer return emptyBuffer
} }
var isNew = false var isNew = false
if response == nil { if response == nil {
if receivedOpcode == .continueFrame { if receivedOpcode == .continueFrame {
let errCode = CloseCode.protocolError.rawValue let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("first frame can't be a continue frame", doDisconnect(error: errorWithDetail(detail: "first frame can't be a continue frame",
code: errCode)) code: errCode))
writeError(errCode) writeError(code: errCode)
return emptyBuffer return emptyBuffer
} }
isNew = true isNew = true
@ -671,9 +694,9 @@ public class WebSocket : NSObject, StreamDelegate {
response!.bytesLeft = Int(dataLength) response!.bytesLeft = Int(dataLength)
} else { } else {
let errCode = CloseCode.protocolError.rawValue let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("second and beyond of fragment message must be a continue frame", doDisconnect(error: errorWithDetail(detail: "second and beyond of fragment message must be a continue frame",
code: errCode)) code: errCode))
writeError(errCode) writeError(code: errCode)
return emptyBuffer return emptyBuffer
} }
response!.buffer!.append(data) response!.buffer!.append(data)
@ -685,7 +708,7 @@ public class WebSocket : NSObject, StreamDelegate {
if isNew { if isNew {
readStack.append(response) readStack.append(response)
} }
processResponse(response) processResponse(response: response)
} }
let step = Int(offset + numericCast(len)) let step = Int(offset + numericCast(len))
@ -704,21 +727,20 @@ public class WebSocket : NSObject, StreamDelegate {
} }
} }
///process the finished response of a buffer /// Process the finished response of a buffer.
@discardableResult private func processResponse(response: WSResponse) -> Bool {
private func processResponse(_ response: WSResponse) -> Bool {
if response.isFin && response.bytesLeft <= 0 { if response.isFin && response.bytesLeft <= 0 {
if response.code == .ping { if response.code == .ping {
let data = response.buffer! //local copy so it is perverse for writing let data = response.buffer! // local copy so it's not perverse for writing
dequeueWrite(data as Data, code: .pong) dequeueWrite(data: data, code: OpCode.pong)
} else if response.code == .textFrame { } else if response.code == .textFrame {
let str: NSString? = NSString(data: response.buffer! as Data, encoding: String.Encoding.utf8.rawValue) let str: NSString? = NSString(data: response.buffer! as Data, encoding: String.Encoding.utf8.rawValue)
if str == nil { if str == nil {
writeError(CloseCode.encoding.rawValue) writeError(code: CloseCode.encoding.rawValue)
return false return false
} }
if canDispatch { if canDispatch {
queue.async { [weak self] in callbackQueue.async { [weak self] in
guard let s = self else { return } guard let s = self else { return }
s.onText?(str! as String) s.onText?(str! as String)
s.delegate?.websocketDidReceiveMessage(s, text: str! as String) s.delegate?.websocketDidReceiveMessage(s, text: str! as String)
@ -726,8 +748,8 @@ public class WebSocket : NSObject, StreamDelegate {
} }
} else if response.code == .binaryFrame { } else if response.code == .binaryFrame {
if canDispatch { if canDispatch {
let data = response.buffer! //local copy so it is perverse for writing let data = response.buffer! //local copy so it's not perverse for writing
queue.async { [weak self] in callbackQueue.async { [weak self] in
guard let s = self else { return } guard let s = self else { return }
s.onData?(data as Data) s.onData?(data as Data)
s.delegate?.websocketDidReceiveData(s, data: data as Data) s.delegate?.websocketDidReceiveData(s, data: data as Data)
@ -740,8 +762,8 @@ public class WebSocket : NSObject, StreamDelegate {
return false return false
} }
///Create an error /// Create an error.
private func errorWithDetail(_ detail: String, code: UInt16) -> NSError { private func errorWithDetail(detail: String, code: UInt16) -> NSError {
var details = [String: String]() var details = [String: String]()
details[NSLocalizedDescriptionKey] = detail details[NSLocalizedDescriptionKey] = detail
@ -752,21 +774,22 @@ public class WebSocket : NSObject, StreamDelegate {
#endif #endif
} }
///write a an error to the socket /// Write a an error to the socket.
private func writeError(_ code: UInt16) { private func writeError(code: UInt16) {
let buf = NSMutableData(capacity: sizeof(UInt16.self)) let buf = NSMutableData(capacity: sizeof(UInt16.self))
let buffer = UnsafeMutablePointer<UInt8>(buf!.bytes) let buffer = UnsafeMutablePointer<UInt8>(buf!.bytes)
WebSocket.writeUint16(buffer, offset: 0, value: code) WebSocket.writeUint16(buffer: buffer, offset: 0, value: code)
dequeueWrite(Data(bytes: buffer, count: sizeof(UInt16.self)), code: .connectionClose) dequeueWrite(data: Data(bytes: buffer, count: sizeof(UInt16.self)), code: .connectionClose)
} }
///used to write things to the stream
private func dequeueWrite(_ data: Data, code: OpCode, writeCompletion: (() -> ())? = nil) { /// Used to write things to the stream.
private func dequeueWrite(data: NSData, code: OpCode, writeCompletion: (() -> ())? = nil) {
writeQueue.addOperation { [weak self] in writeQueue.addOperation { [weak self] in
//stream isn't ready, let's wait //stream isn't ready, let's wait
guard let s = self else { return } guard let s = self else { return }
var offset = 2 var offset = 2
let bytes = UnsafeMutablePointer<UInt8>((data as NSData).bytes) let bytes = UnsafeMutablePointer<UInt8>((data as NSData).bytes)
let dataLength = data.count let dataLength = data.length
let frame = NSMutableData(capacity: dataLength + s.MaxFrameSize) let frame = NSMutableData(capacity: dataLength + s.MaxFrameSize)
let buffer = UnsafeMutablePointer<UInt8>(frame!.mutableBytes) let buffer = UnsafeMutablePointer<UInt8>(frame!.mutableBytes)
buffer[0] = s.FinMask | code.rawValue buffer[0] = s.FinMask | code.rawValue
@ -774,11 +797,11 @@ public class WebSocket : NSObject, StreamDelegate {
buffer[1] = CUnsignedChar(dataLength) buffer[1] = CUnsignedChar(dataLength)
} else if dataLength <= Int(UInt16.max) { } else if dataLength <= Int(UInt16.max) {
buffer[1] = 126 buffer[1] = 126
WebSocket.writeUint16(buffer, offset: offset, value: UInt16(dataLength)) WebSocket.writeUint16(buffer: buffer, offset: offset, value: UInt16(dataLength))
offset += sizeof(UInt16.self) offset += sizeof(UInt16.self)
} else { } else {
buffer[1] = 127 buffer[1] = 127
WebSocket.writeUint64(buffer, offset: offset, value: UInt64(dataLength)) WebSocket.writeUint64(buffer: buffer, offset: offset, value: UInt64(dataLength))
offset += sizeof(UInt64.self) offset += sizeof(UInt64.self)
} }
buffer[1] |= s.MaskMask buffer[1] |= s.MaskMask
@ -801,16 +824,16 @@ public class WebSocket : NSObject, StreamDelegate {
error = streamError as NSError error = streamError as NSError
} else { } else {
let errCode = InternalErrorCode.outputStreamWriteError.rawValue let errCode = InternalErrorCode.outputStreamWriteError.rawValue
error = s.errorWithDetail("output stream error during write", code: errCode) error = s.errorWithDetail(detail: "output stream error during write", code: errCode)
} }
s.doDisconnect(error) s.doDisconnect(error: error)
break break
} else { } else {
total += len total += len
} }
if total >= offset { if total >= offset {
if let queue = self?.queue, let callback = writeCompletion { if let callbackQueue = self?.callbackQueue, let callback = writeCompletion {
queue.async { callbackQueue.async {
callback() callback()
} }
} }
@ -822,21 +845,23 @@ public class WebSocket : NSObject, StreamDelegate {
} }
} }
///used to preform the disconnect delegate /// Used to preform the disconnect delegate.
private func doDisconnect(_ error: NSError?) { private func doDisconnect(error: NSError?) {
guard !didDisconnect else { return } guard !didDisconnect else { return }
didDisconnect = true didDisconnect = true
connected = false connected = false
guard canDispatch else {return} guard canDispatch else {return}
queue.async { [weak self] in callbackQueue.async { [weak self] in
guard let s = self else { return } guard let s = self else { return }
s.onDisconnect?(error) s.onDisconnect?(error)
s.delegate?.websocketDidDisconnect(s, error: error) s.delegate?.websocketDidDisconnect(s, error: error)
let userInfo = error.map({ [WebsocketDisconnectionErrorKeyName: $0] }) let userInfo = error.map{ [WebsocketDisconnectionErrorKeyName: $0] }
s.notificationCenter.post(name: NSNotification.Name(rawValue: WebsocketDidDisconnectNotification), object: self, userInfo: userInfo) s.notificationCenter.post(name: NSNotification.Name(rawValue: WebsocketDidDisconnectNotification), object: self, userInfo: userInfo)
} }
} }
// MARK: - Deinit
deinit { deinit {
mutex.lock() mutex.lock()
readyToWrite = false readyToWrite = false