Merge pull request #255 from pvzig/swift-23

Update OS X deployment target
2016-09-25 22:08:58 -05:00 · 2016-09-25 15:03:02 -04:00 · 2016-09-25 14:59:37 -04:00
32 changed files with 2013 additions and 2193 deletions
@@ -1 +0,0 @@
-4.0
@@ -2,90 +2,6 @@
 All notable changes to this project will be documented in this file.
 `Starscream` adheres to [Semantic Versioning](http://semver.org/).

-#### [3.0.0](https://github.com/daltoniam/Starscream/tree/3.0.0)
-
-Major refactor and Swift 4 support. Additions include:
-
- Watchos support.
- Linux support.
- New Stream class to allow custom socket implementations if desired.
- Protocol add for mocking (dependency injection)
- Single framework (no more platform suffixes! e.g. StarscreamOSX, StarscreamTVOS, etc) 
-
-[#384](https://github.com/daltoniam/Starscream/issues/384)
-[#377](https://github.com/daltoniam/Starscream/pull/377)
-[#374](https://github.com/daltoniam/Starscream/issues/374)
-[#346](https://github.com/daltoniam/Starscream/issues/346)
-[#335](https://github.com/daltoniam/Starscream/issues/335)
-[#311](https://github.com/daltoniam/Starscream/pull/311)
-[#269](https://github.com/daltoniam/Starscream/issues/269)
-
-#### [2.1.1](https://github.com/daltoniam/Starscream/tree/2.1.1)
-
-Fixes race condition. Updated to avoid SPM dependencies.
-
-[#370](https://github.com/daltoniam/Starscream/issues/370)
-[#367](https://github.com/daltoniam/Starscream/issues/367)
-[#364](https://github.com/daltoniam/Starscream/pull/364)
-[#357](https://github.com/daltoniam/Starscream/pull/357)
-[#355](https://github.com/daltoniam/Starscream/pull/355)
-
-#### [2.1.0](https://github.com/daltoniam/Starscream/tree/2.1.0)
-
-Adds WebSocket compression. Also adds advance WebSocket delegate for extra control. Bug Fixes.
-
-[#349](https://github.com/daltoniam/Starscream/pull/349)
-[#344](https://github.com/daltoniam/Starscream/pull/344)
-[#339](https://github.com/daltoniam/Starscream/pull/339)
-[#337](https://github.com/daltoniam/Starscream/pull/337)
-[#334](https://github.com/daltoniam/Starscream/issues/334)
-[#333](https://github.com/daltoniam/Starscream/pull/333)
-[#319](https://github.com/daltoniam/Starscream/issues/319)
-[#309](https://github.com/daltoniam/Starscream/issues/309)
-[#329](https://github.com/daltoniam/Starscream/issues/329)
-
-#### [2.0.4](https://github.com/daltoniam/Starscream/tree/2.0.4)
-
-SSL Pinning fix by Giuliano Galea as reported by Lukas Futera of [Centralway](https://www.centralway.com/de/).
-Warning fixes for Swift 3.1
-
-#### [2.0.3](https://github.com/daltoniam/Starscream/tree/2.0.3)
-
-[#302](https://github.com/daltoniam/Starscream/issues/302)
-[#301](https://github.com/daltoniam/Starscream/issues/301)
-[#300](https://github.com/daltoniam/Starscream/issues/300)
-[#296](https://github.com/daltoniam/Starscream/issues/296)
-[#294](https://github.com/daltoniam/Starscream/issues/294)
-[#292](https://github.com/daltoniam/Starscream/issues/292)
-[#289](https://github.com/daltoniam/Starscream/issues/289)
-[#288](https://github.com/daltoniam/Starscream/issues/288)
-
-#### [2.0.2](https://github.com/daltoniam/Starscream/tree/2.0.2)
-
-Fix for the Swift Package Manager.
-
-Fixed: 
-[#277](https://github.com/daltoniam/Starscream/issues/277)
-
-#### [2.0.1](https://github.com/daltoniam/Starscream/tree/2.0.1)
-
-Bug fixes.
-
-Fixed: 
-[#261](https://github.com/daltoniam/Starscream/issues/261)
-[#276](https://github.com/daltoniam/Starscream/issues/276)
-[#267](https://github.com/daltoniam/Starscream/issues/267)
-[#266](https://github.com/daltoniam/Starscream/issues/266)
-[#259](https://github.com/daltoniam/Starscream/issues/259)
-
-#### [2.0.0](https://github.com/daltoniam/Starscream/tree/2.0.0)
-
-Added Swift 3 support.
-
-Fixed: 
-[#229](https://github.com/daltoniam/Starscream/issues/229)
-[#232](https://github.com/daltoniam/Starscream/issues/232)
-
 #### [1.1.4](https://github.com/daltoniam/Starscream/tree/1.1.4)

 Swift 2.3 support.
@@ -135,4 +51,4 @@ Fixes for #121, #123

 #### [1.0.0](https://github.com/daltoniam/Starscream/tree/1.0.0)

-first release of Swift 2 support.
+first release of Swift 2 support.
@@ -2,7 +2,7 @@
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

-   Copyright (c) 2014-2016 Dalton Cherry.
+   Copyright (c) 2014-2015 Dalton Cherry.

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

@@ -3,7 +3,7 @@
 //  Starscream
 //
 //  Created by Dalton Cherry on 5/16/15.
-//  Copyright (c) 2014-2016 Dalton Cherry.
+//  Copyright (c) 2014-2015 Dalton Cherry.
 //
 //  Licensed under the Apache License, Version 2.0 (the "License");
 //  you may not use this file except in compliance with the License.
@@ -21,12 +21,5 @@
 import PackageDescription

 let package = Package(
-    name: "Starscream",
-    dependencies: [
-        .Package(url: "https://github.com/daltoniam/zlib-spm.git",
-    majorVersion: 1, minor: 1),
-        .Package(url: "https://github.com/daltoniam/common-crypto-spm",
-                 majorVersion: 1, minor: 1),
-        ],
-    exclude: ["Tests", "examples"]
-)
+    name: "Starscream"
+)
@@ -1,15 +1,17 @@
 ![starscream](https://raw.githubusercontent.com/daltoniam/starscream/assets/starscream.jpg)

-Starscream is a conforming WebSocket ([RFC 6455](http://tools.ietf.org/html/rfc6455)) client library in Swift.
+Starscream is a conforming WebSocket ([RFC 6455](http://tools.ietf.org/html/rfc6455)) client library in Swift for iOS and OSX.

-Its Objective-C counterpart can be found here: [Jetfire](https://github.com/acmacalister/jetfire)
+It's Objective-C counter part can be found here: [Jetfire](https://github.com/acmacalister/jetfire)
+
+###Swift 3/Xcode 8
+If you are looking for Swift 3 support, see [swift 3 here](https://github.com/daltoniam/Starscream/tree/swift3)

 ## Features

 - Conforms to all of the base [Autobahn test suite](http://autobahn.ws/testsuite/).
 - Nonblocking. Everything happens in the background, thanks to GCD.
 - TLS/WSS support.
- Compression Extensions support ([RFC 7692](https://tools.ietf.org/html/rfc7692))
 - Simple concise codebase at just a few hundred LOC.

 ## Example
@@ -23,7 +25,7 @@ import Starscream
 Once imported, you can open a connection to your WebSocket server. Note that `socket` is probably best as a property, so it doesn't get deallocated right after being setup.

 ```swift
-socket = WebSocket(url: URL(string: "ws://localhost:8080/")!)
+socket = WebSocket(url: NSURL(string: "ws://localhost:8080/")!)
 socket.delegate = self
 socket.connect()
 ```
@@ -35,7 +37,7 @@ After you are connected, there are some delegate methods that we need to impleme
 websocketDidConnect is called as soon as the client connects to the server.

 ```swift
-func websocketDidConnect(socket: WebSocketClient) {
+func websocketDidConnect(socket: WebSocket) {
    print("websocket is connected")
 }
 ```
@@ -45,7 +47,7 @@ func websocketDidConnect(socket: WebSocketClient) {
 websocketDidDisconnect is called as soon as the client is disconnected from the server.

 ```swift
-func websocketDidDisconnect(socket: WebSocketClient, error: Error?) {
+func websocketDidDisconnect(socket: WebSocket, error: NSError?) {
 	print("websocket is disconnected: \(error?.localizedDescription)")
 }
 ```
@@ -55,7 +57,7 @@ func websocketDidDisconnect(socket: WebSocketClient, error: Error?) {
 websocketDidReceiveMessage is called when the client gets a text frame from the connection.

 ```swift
-func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
+func websocketDidReceiveMessage(socket: WebSocket, text: String) {
 	print("got some text: \(text)")
 }
 ```
@@ -65,8 +67,8 @@ func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
 websocketDidReceiveData is called when the client gets a binary frame from the connection.

 ```swift
-func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
-	print("got some data: \(data.count)")
+func websocketDidReceiveData(socket: WebSocket, data: NSData) {
+	print("got some data: \(data.length)")
 }
 ```

@@ -75,21 +77,21 @@ func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
 websocketDidReceivePong is called when the client gets a pong response from the connection. You need to implement the WebSocketPongDelegate protocol and set an additional delegate, eg: ` socket.pongDelegate = self`

 ```swift
-func websocketDidReceivePong(socket: WebSocketClient, data: Data?) {
-	print("Got pong! Maybe some data: \(data?.count)")
+func websocketDidReceivePong(socket: WebSocket) {
+	print("Got pong!")
 }
 ```

 Or you can use closures.

 ```swift
-socket = WebSocket(url: URL(string: "ws://localhost:8080/")!)
+socket = WebSocket(url: NSURL(string: "ws://localhost:8080/")!)
 //websocketDidConnect
 socket.onConnect = {
    print("websocket is connected")
 }
 //websocketDidDisconnect
-socket.onDisconnect = { (error: Error?) in
+socket.onDisconnect = { (error: NSError?) in
    print("websocket is disconnected: \(error?.localizedDescription)")
 }
 //websocketDidReceiveMessage
@@ -97,40 +99,40 @@ socket.onText = { (text: String) in
    print("got some text: \(text)")
 }
 //websocketDidReceiveData
-socket.onData = { (data: Data) in
-    print("got some data: \(data.count)")
+socket.onData = { (data: NSData) in
+    print("got some data: \(data.length)")
 }
 //you could do onPong as well.
 socket.connect()
 ```

-One more: you can listen to socket connection and disconnection via notifications. Starscream posts `WebsocketDidConnectNotification` and `WebsocketDidDisconnectNotification`. You can find an `Error` that caused the disconection by accessing `WebsocketDisconnectionErrorKeyName` on notification `userInfo`.
+One more: you can listen to socket connection and disconnection via notifications. Starscream posts `WebsocketDidConnectNotification` and `WebsocketDidDisconnectNotification`. You can find an `NSError` that caused the disconection by accessing `WebsocketDisconnectionErrorKeyName` on notification `userInfo`.


 ## The delegate methods give you a simple way to handle data from the server, but how do you send data?

-### write a binary frame
+### writeData

-The writeData method gives you a simple way to send `Data` (binary) data to the server.
+The writeData method gives you a simple way to send `NSData` (binary) data to the server.

 ```swift
-socket.write(data: data) //write some Data over the socket!
+socket.writeData(data) //write some NSData over the socket!
 ```

-### write a string frame
+### writeString

 The writeString method is the same as writeData, but sends text/string.

 ```swift
-socket.write(string: "Hi Server!") //example on how to write text over the socket!
+socket.writeString("Hi Server!") //example on how to write text over the socket!
 ```

-### write a ping frame
+### writePing

-The writePing method is the same as write, but sends a ping control frame.
+The writePing method is the same as writeData, but sends a ping control frame.

 ```swift
-socket.write(ping: Data()) //example on how to write a ping control frame over the socket!
+socket.writePing(NSData()) //example on how to write a ping control frame over the socket!
 ```

 ### disconnect
@@ -156,23 +158,9 @@ if socket.isConnected {
 You can also override the default websocket headers with your own custom ones like so:

 ```swift
-var request = URLRequest(url: URL(string: "ws://localhost:8080/")!)
-request.timeoutInterval = 5
-request.setValue("someother protocols", forHTTPHeaderField: "Sec-WebSocket-Protocol")
-request.setValue("14", forHTTPHeaderField: "Sec-WebSocket-Version")
-request.setValue("Everything is Awesome!", forHTTPHeaderField: "My-Awesome-Header")
-let socket = WebSocket(request: request)
-```
-
-### Custom HTTP Method
-
-Your server may use a different HTTP method when connecting to the websocket:
-
-```swift
-var request = URLRequest(url: URL(string: "ws://localhost:8080/")!)
-request.httpMethod = "POST"
-request.timeoutInterval = 5
-let socket = WebSocket(request: request)
+socket.headers["Sec-WebSocket-Protocol"] = "someother protocols"
+socket.headers["Sec-WebSocket-Version"] = "14"
+socket.headers["My-Awesome-Header"] = "Everything is Awesome!"
 ```

 ### Protocols
@@ -181,64 +169,45 @@ If you need to specify a protocol, simple add it to the init:

 ```swift
 //chat and superchat are the example protocols here
-socket = WebSocket(url: URL(string: "ws://localhost:8080/")!, protocols: ["chat","superchat"])
+socket = WebSocket(url: NSURL(string: "ws://localhost:8080/")!, protocols: ["chat","superchat"])
 socket.delegate = self
 socket.connect()
 ```

-### Self Signed SSL
+### Self Signed SSL and VOIP
+
+There are a couple of other properties that modify the stream:

 ```swift
-socket = WebSocket(url: URL(string: "ws://localhost:8080/")!, protocols: ["chat","superchat"])
+socket = WebSocket(url: NSURL(string: "ws://localhost:8080/")!, protocols: ["chat","superchat"])

-//set this if you want to ignore SSL cert validation, so a self signed SSL certificate can be used.
-socket.disableSSLCertValidation = true
+//set this if you are planning on using the socket in a VOIP background setting (using the background VOIP service).
+socket.voipEnabled = true
+
+//set this you want to ignore SSL cert validation, so a self signed SSL certificate can be used.
+socket.selfSignedSSL = true
 ```

 ### SSL Pinning

-SSL Pinning is also supported in Starscream.
+SSL Pinning is also supported in Starscream. 

 ```swift
-socket = WebSocket(url: URL(string: "ws://localhost:8080/")!, protocols: ["chat","superchat"])
+socket = WebSocket(url: NSURL(string: "ws://localhost:8080/")!, protocols: ["chat","superchat"])
 let data = ... //load your certificate from disk
 socket.security = SSLSecurity(certs: [SSLCert(data: data)], usePublicKeys: true)
 //socket.security = SSLSecurity() //uses the .cer files in your app's bundle
 ```
-You load either a `Data` blob of your certificate or you can use a `SecKeyRef` if you have a public key you want to use. The `usePublicKeys` bool is whether to use the certificates for validation or the public keys. The public keys will be extracted from the certificates automatically if `usePublicKeys` is choosen.
-
-### SSL Cipher Suites
-
-To use an SSL encrypted connection, you need to tell Starscream about the cipher suites your server supports. 
-
-```swift
-socket = WebSocket(url: URL(string: "wss://localhost:8080/")!, protocols: ["chat","superchat"])
-
-// Set enabled cipher suites to AES 256 and AES 128
-socket.enabledSSLCipherSuites = [TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256] 
-```
-
-If you don't know which cipher suites are supported by your server, you can try pointing [SSL Labs](https://www.ssllabs.com/ssltest/) at it and checking the results.
-
-### Compression Extensions
-
-Compression Extensions ([RFC 7692](https://tools.ietf.org/html/rfc7692)) is supported in Starscream.  Compression is enabled by default, however compression will only be used if it is supported by the server as well.  You may enable or disable compression via the `.enableCompression` property:
-
-```swift
-socket = WebSocket(url: URL(string: "ws://localhost:8080/")!)
-socket.enableCompression = false
-```
-
-Compression should be disabled if your application is transmitting already-compressed, random, or other uncompressable data.
+You load either a `NSData` blob of your certificate or you can use a `SecKeyRef` if you have a public key you want to use. The `usePublicKeys` bool is whether to use the certificates for validation or the public keys. The public keys will be extracted from the certificates automatically if `usePublicKeys` is choosen.

 ### Custom Queue

-A custom queue can be specified when delegate methods are called. By default `DispatchQueue.main` is used, thus making all delegate methods calls run on the main thread. It is important to note that all WebSocket processing is done on a background thread, only the delegate method calls are changed when modifying the queue. The actual processing is always on a background thread and will not pause your app.
+A custom queue can be specified when delegate methods are called. By default `dispatch_get_main_queue` is used, thus making all delegate methods calls run on the main thread. It is important to note that all WebSocket processing is done on a background thread, only the delegate method calls are changed when modifying the queue. The actual processing is always on a background thread and will not pause your app.

 ```swift
-socket = WebSocket(url: URL(string: "ws://localhost:8080/")!, protocols: ["chat","superchat"])
+socket = WebSocket(url: NSURL(string: "ws://localhost:8080/")!, protocols: ["chat","superchat"])
 //create a custom queue
-socket.callbackQueue = DispatchQueue(label: "com.vluxe.starscream.myapp")
+socket.queue = dispatch_queue_create("com.vluxe.starscream.myapp", nil)
 ```

 ## Example Project
@@ -261,7 +230,7 @@ To use Starscream in your project add the following 'Podfile' to your project
 	platform :ios, '9.0'
 	use_frameworks!

-	pod 'Starscream', '~> 3.0.0'
+	pod 'Starscream', '~> 1.1.3'

 Then run:

@@ -283,7 +252,7 @@ $ brew install carthage
 To integrate Starscream into your Xcode project using Carthage, specify it in your `Cartfile`:

 ```
-github "daltoniam/Starscream" >= 3.0.0
+github "daltoniam/Starscream" >= 1.1.3
 ```

 ### Rogue
@@ -293,23 +262,11 @@ First see the [installation docs](https://github.com/acmacalister/Rogue) for how
 To install Starscream run the command below in the directory you created the rogue file.

 ```
-rogue add https://github.com/daltoniam/Starscream
+rogue add https://github.com/daltoniam/starscream
 ```

 Next open the `libs` folder and add the `Starscream.xcodeproj` to your Xcode project. Once that is complete, in your "Build Phases" add the `Starscream.framework` to your "Link Binary with Libraries" phase. Make sure to add the `libs` folder to your `.gitignore` file.

-### Swift Package Manager
-
-The [Swift Package Manager](https://swift.org/package-manager/) is a tool for automating the distribution of Swift code and is integrated into the `swift` compiler.
-
-Once you have your Swift package set up, adding Starscream as a dependency is as easy as adding it to the `dependencies` value of your `Package.swift`.
-
-```swift
-dependencies: [
-    .Package(url: "https://github.com/daltoniam/Starscream.git", majorVersion: 3)
-]
-```
-
 ### Other

 Simply grab the framework (either via git submodule or another package manager).
@@ -320,49 +277,11 @@ Add the `Starscream.xcodeproj` to your Xcode project. Once that is complete, in

 If you are running this in an OSX app or on a physical iOS device you will need to make sure you add the `Starscream.framework` to be included in your app bundle. To do this, in Xcode, navigate to the target configuration window by clicking on the blue project icon, and selecting the application target under the "Targets" heading in the sidebar. In the tab bar at the top of that window, open the "Build Phases" panel. Expand the "Link Binary with Libraries" group, and add `Starscream.framework`. Click on the + button at the top left of the panel and select "New Copy Files Phase". Rename this new phase to "Copy Frameworks", set the "Destination" to "Frameworks", and add `Starscream.framework` respectively.

-
-## WebSocketAdvancedDelegate
-The advanced delegate acts just like the simpler delegate but provides some additional information on the connection and incoming frames.
-
-```swift
-socket.advancedDelegate = self
-```
-
-In most cases you do not need the extra info and should use the normal delegate.
-
-#### websocketDidReceiveMessage
-```swift
-func websocketDidReceiveMessage(socket: WebSocketClient, text: String, response: WebSocket.WSResponse {
-	print("got some text: \(text)")
-	print("First frame for this message arrived on \(response.firstFrame)")
-}
-```
-
-#### websocketDidReceiveData
-```swift
-func websocketDidReceiveData(socket: WebSocketClient, data: Date, response: WebSocket.WSResponse) {
-	print("got some data it long: \(data.count)")
-	print("A total of \(response.frameCount) frames were used to send this data")
-}
-```
-
-#### websocketHttpUpgrade
-These methods are called when the HTTP upgrade request is sent and when the response returns.
-```swift
-func  websocketHttpUpgrade(socket: WebSocketClient, request: CFHTTPMessage) {
-	print("the http request was sent we can check the raw http if we need to")
-}
-```
-
-```swift
-func  websocketHttpUpgrade(socket: WebSocketClient, response: CFHTTPMessage) {
-	print("the http response has returned.")
-}
-```
-
 ## TODOs

- [ ] Add Unit Tests - Local WebSocket server that runs against Autobahn
+- [ ] WatchOS?
+- [ ] Linux Support?
+- [ ] Add Unit Tests - Local Swift websocket server

 ## License

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.1.4</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>arm64</string>
+	</array>
+</dict>
+</plist>
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>3.0.0</string>
+	<string>1.1.4</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
@@ -4,7 +4,7 @@
 //  Starscream
 //
 //  Created by Dalton Cherry on 5/16/15.
-//  Copyright (c) 2014-2016 Dalton Cherry.
+//  Copyright (c) 2014-2015 Dalton Cherry.
 //
 //  Licensed under the Apache License, Version 2.0 (the "License");
 //  you may not use this file except in compliance with the License.
@@ -19,18 +19,13 @@
 //  limitations under the License.
 //
 //////////////////////////////////////////////////////////////////////////////////////////////////
-#if os(Linux)
-#else
+
 import Foundation
 import Security

-public protocol SSLTrustValidator {
-    func isValid(_ trust: SecTrust, domain: String?) -> Bool
-}
-
-open class SSLCert {
-    var certData: Data?
-    var key: SecKey?
+public class SSLCert {
+    var certData: NSData?
+    var key: SecKeyRef?
    
    /**
    Designated init for certificates
@@ -39,7 +34,7 @@ open class SSLCert {
    
    - returns: a representation security object to be used with
    */
-    public init(data: Data) {
+    public init(data: NSData) {
        self.certData = data
    }
    
@@ -50,17 +45,17 @@ open class SSLCert {
    
    - returns: a representation security object to be used with
    */
-    public init(key: SecKey) {
+    public init(key: SecKeyRef) {
        self.key = key
    }
 }

-open class SSLSecurity : SSLTrustValidator {
+public class SSLSecurity {
    public var validatedDN = true //should the domain name be validated?
    
    var isReady = false //is the key processing done?
-    var certificates: [Data]? //the certificates
-    var pubKeys: [SecKey]? //the public keys
+    var certificates: [NSData]? //the certificates
+    var pubKeys: [SecKeyRef]? //the public keys
    var usePublicKeys = false //use public keys or certificate validation?
    
    /**
@@ -71,12 +66,12 @@ open class SSLSecurity : SSLTrustValidator {
    - returns: a representation security object to be used with
    */
    public convenience init(usePublicKeys: Bool = false) {
-        let paths = Bundle.main.paths(forResourcesOfType: "cer", inDirectory: ".")
+        let paths = NSBundle.mainBundle().pathsForResourcesOfType("cer", inDirectory: ".")
        
        let certs = paths.reduce([SSLCert]()) { (certs: [SSLCert], path: String) -> [SSLCert] in
            var certs = certs
            if let data = NSData(contentsOfFile: path) {
-                certs.append(SSLCert(data: data as Data))
+                certs.append(SSLCert(data: data))
            }
            return certs
        }
@@ -87,7 +82,7 @@ open class SSLSecurity : SSLTrustValidator {
    /**
    Designated init
    
-    - parameter certs: is the certificates or public keys to use
+    - parameter keys: is the certificates or public keys to use
    - parameter usePublicKeys: is to specific if the publicKeys or certificates should be used for SSL pinning validation
    
    - returns: a representation security object to be used with
@@ -96,10 +91,10 @@ open class SSLSecurity : SSLTrustValidator {
        self.usePublicKeys = usePublicKeys
        
        if self.usePublicKeys {
-            DispatchQueue.global(qos: .default).async {
-                let pubKeys = certs.reduce([SecKey]()) { (pubKeys: [SecKey], cert: SSLCert) -> [SecKey] in
+            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)) {
+                let pubKeys = certs.reduce([SecKeyRef]()) { (pubKeys: [SecKeyRef], cert: SSLCert) -> [SecKeyRef] in
                    var pubKeys = pubKeys
-                    if let data = cert.certData, cert.key == nil {
+                    if let data = cert.certData where cert.key == nil {
                        cert.key = self.extractPublicKey(data)
                    }
                    if let key = cert.key {
@@ -112,7 +107,7 @@ open class SSLSecurity : SSLTrustValidator {
                self.isReady = true
            }
        } else {
-            let certificates = certs.reduce([Data]()) { (certificates: [Data], cert: SSLCert) -> [Data] in
+            let certificates = certs.reduce([NSData]()) { (certificates: [NSData], cert: SSLCert) -> [NSData] in
                var certificates = certificates
                if let data = cert.certData {
                    certificates.append(data)
@@ -132,26 +127,26 @@ open class SSLSecurity : SSLTrustValidator {
    
    - returns: if the key was successfully validated
    */
-    public func isValid(_ trust: SecTrust, domain: String?) -> Bool {
+    public func isValid(trust: SecTrustRef, domain: String?) -> Bool {
        
        var tries = 0
-        while !self.isReady {
+        while(!self.isReady) {
            usleep(1000)
            tries += 1
            if tries > 5 {
                return false //doesn't appear it is going to ever be ready...
            }
        }
-        var policy: SecPolicy
+        var policy: SecPolicyRef
        if self.validatedDN {
-            policy = SecPolicyCreateSSL(true, domain as NSString?)
+            policy = SecPolicyCreateSSL(true, domain)
        } else {
            policy = SecPolicyCreateBasicX509()
        }
        SecTrustSetPolicies(trust,policy)
        if self.usePublicKeys {
            if let keys = self.pubKeys {
-                let serverPubKeys = publicKeyChain(trust)
+                let serverPubKeys = publicKeyChainForTrust(trust)
                for serverKey in serverPubKeys as [AnyObject] {
                    for key in keys as [AnyObject] {
                        if serverKey.isEqual(key) {
@@ -161,15 +156,15 @@ open class SSLSecurity : SSLTrustValidator {
                }
            }
        } else if let certs = self.certificates {
-            let serverCerts = certificateChain(trust)
+            let serverCerts = certificateChainForTrust(trust)
            var collect = [SecCertificate]()
            for cert in certs {
-                collect.append(SecCertificateCreateWithData(nil,cert as CFData)!)
+                collect.append(SecCertificateCreateWithData(nil,cert)!)
            }
-            SecTrustSetAnchorCertificates(trust,collect as NSArray)
-            var result: SecTrustResultType = .unspecified
+            SecTrustSetAnchorCertificates(trust,collect)
+            var result: SecTrustResultType = .Unspecified
            SecTrustEvaluate(trust,&result)
-            if result == .unspecified || result == .proceed {
+            if result == .Unspecified || result == .Proceed {
                var trustedCount = 0
                for serverCert in serverCerts {
                    for cert in certs {
@@ -194,10 +189,10 @@ open class SSLSecurity : SSLTrustValidator {
    
    - returns: a public key
    */
-    func extractPublicKey(_ data: Data) -> SecKey? {
-        guard let cert = SecCertificateCreateWithData(nil, data as CFData) else { return nil }
+    func extractPublicKey(data: NSData) -> SecKeyRef? {
+        guard let cert = SecCertificateCreateWithData(nil, data) else { return nil }
        
-        return extractPublicKey(cert, policy: SecPolicyCreateBasicX509())
+        return extractPublicKeyFromCert(cert, policy: SecPolicyCreateBasicX509())
    }
    
    /**
@@ -207,12 +202,12 @@ open class SSLSecurity : SSLTrustValidator {
    
    - returns: a public key
    */
-    func extractPublicKey(_ cert: SecCertificate, policy: SecPolicy) -> SecKey? {
+    func extractPublicKeyFromCert(cert: SecCertificate, policy: SecPolicy) -> SecKeyRef? {
        var possibleTrust: SecTrust?
        SecTrustCreateWithCertificates(cert, policy, &possibleTrust)
        
        guard let trust = possibleTrust else { return nil }
-        var result: SecTrustResultType = .unspecified
+        var result: SecTrustResultType = .Unspecified
        SecTrustEvaluate(trust, &result)
        return SecTrustCopyPublicKey(trust)
    }
@@ -224,11 +219,11 @@ open class SSLSecurity : SSLTrustValidator {
    
    - returns: the certificate chain for the trust
    */
-    func certificateChain(_ trust: SecTrust) -> [Data] {
-        let certificates = (0..<SecTrustGetCertificateCount(trust)).reduce([Data]()) { (certificates: [Data], index: Int) -> [Data] in
+    func certificateChainForTrust(trust: SecTrustRef) -> [NSData] {
+        let certificates = (0..<SecTrustGetCertificateCount(trust)).reduce([NSData]()) { (certificates: [NSData], index: Int) -> [NSData] in
            var certificates = certificates
            let cert = SecTrustGetCertificateAtIndex(trust, index)
-            certificates.append(SecCertificateCopyData(cert!) as Data)
+            certificates.append(SecCertificateCopyData(cert!))
            return certificates
        }
        
@@ -242,12 +237,12 @@ open class SSLSecurity : SSLTrustValidator {
    
    - returns: the public keys from the certifcate chain for the trust
    */
-    func publicKeyChain(_ trust: SecTrust) -> [SecKey] {
+    func publicKeyChainForTrust(trust: SecTrustRef) -> [SecKeyRef] {
        let policy = SecPolicyCreateBasicX509()
-        let keys = (0..<SecTrustGetCertificateCount(trust)).reduce([SecKey]()) { (keys: [SecKey], index: Int) -> [SecKey] in
+        let keys = (0..<SecTrustGetCertificateCount(trust)).reduce([SecKeyRef]()) { (keys: [SecKeyRef], index: Int) -> [SecKeyRef] in
            var keys = keys
            let cert = SecTrustGetCertificateAtIndex(trust, index)
-            if let key = extractPublicKey(cert!, policy: policy) {
+            if let key = extractPublicKeyFromCert(cert!, policy: policy) {
                keys.append(key)
            }
            
@@ -259,4 +254,3 @@ open class SSLSecurity : SSLTrustValidator {
    
    
 }
-#endif
@@ -0,0 +1,891 @@
+//////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Websocket.swift
+//
+//  Created by Dalton Cherry on 7/16/14.
+//  Copyright (c) 2014-2015 Dalton Cherry.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+import Foundation
+import CoreFoundation
+import Security
+
+public let WebsocketDidConnectNotification = "WebsocketDidConnectNotification"
+public let WebsocketDidDisconnectNotification = "WebsocketDidDisconnectNotification"
+public let WebsocketDisconnectionErrorKeyName = "WebsocketDisconnectionErrorKeyName"
+
+public protocol WebSocketDelegate: class {
+    func websocketDidConnect(socket: WebSocket)
+    func websocketDidDisconnect(socket: WebSocket, error: NSError?)
+    func websocketDidReceiveMessage(socket: WebSocket, text: String)
+    func websocketDidReceiveData(socket: WebSocket, data: NSData)
+}
+
+public protocol WebSocketPongDelegate: class {
+    func websocketDidReceivePong(socket: WebSocket)
+}
+
+public class WebSocket: NSObject, NSStreamDelegate {
+
+    enum OpCode: UInt8 {
+        case ContinueFrame = 0x0
+        case TextFrame = 0x1
+        case BinaryFrame = 0x2
+        // 3-7 are reserved.
+        case ConnectionClose = 0x8
+        case Ping = 0x9
+        case Pong = 0xA
+        // B-F reserved.
+    }
+
+    public enum CloseCode: UInt16 {
+        case Normal                 = 1000
+        case GoingAway              = 1001
+        case ProtocolError          = 1002
+        case ProtocolUnhandledType  = 1003
+        // 1004 reserved.
+        case NoStatusReceived       = 1005
+        // 1006 reserved.
+        case Encoding               = 1007
+        case PolicyViolated         = 1008
+        case MessageTooBig          = 1009
+    }
+
+    public static let ErrorDomain   = "WebSocket"
+
+    enum InternalErrorCode: UInt16 {
+        // 0-999 WebSocket status codes not used
+        case OutputStreamWriteError  = 1
+    }
+
+    /// Where the callback is executed. It defaults to the main UI thread queue.
+    public var callbackQueue            = dispatch_get_main_queue()
+
+    var optionalProtocols       : [String]?
+
+    // MARK: - Constants
+
+    let headerWSUpgradeName     = "Upgrade"
+    let headerWSUpgradeValue    = "websocket"
+    let headerWSHostName        = "Host"
+    let headerWSConnectionName  = "Connection"
+    let headerWSConnectionValue = "Upgrade"
+    let headerWSProtocolName    = "Sec-WebSocket-Protocol"
+    let headerWSVersionName     = "Sec-WebSocket-Version"
+    let headerWSVersionValue    = "13"
+    let headerWSKeyName         = "Sec-WebSocket-Key"
+    let headerOriginName        = "Origin"
+    let headerWSAcceptName      = "Sec-WebSocket-Accept"
+    let BUFFER_MAX              = 4096
+    let FinMask: UInt8          = 0x80
+    let OpCodeMask: UInt8       = 0x0F
+    let RSVMask: UInt8          = 0x70
+    let MaskMask: UInt8         = 0x80
+    let PayloadLenMask: UInt8   = 0x7F
+    let MaxFrameSize: Int       = 32
+    let httpSwitchProtocolCode  = 101
+    let supportedSSLSchemes     = ["wss", "https"]
+
+    class WSResponse {
+        var isFin = false
+        var code: OpCode = .ContinueFrame
+        var bytesLeft = 0
+        var frameCount = 0
+        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?
+
+    /// Recives a callback for each pong message recived.
+    public weak var pongDelegate: WebSocketPongDelegate?
+
+
+    // MARK: - Block based API.
+
+    public var onConnect: ((Void) -> Void)?
+    public var onDisconnect: ((NSError?) -> Void)?
+    public var onText: ((String) -> Void)?
+    public var onData: ((NSData) -> Void)?
+    public var onPong: ((Void) -> Void)?
+
+    public var headers = [String: String]()
+    public var voipEnabled = false
+    public var selfSignedSSL = false
+    public var security: SSLSecurity?
+    public var enabledSSLCipherSuites: [SSLCipherSuite]?
+    public var origin: String?
+    public var timeout = 5
+    public var isConnected :Bool {
+        return connected
+    }
+    public var currentURL: NSURL { return url }
+
+    // MARK: - Private
+
+    private var url: NSURL
+    private var inputStream: NSInputStream?
+    private var outputStream: NSOutputStream?
+    private var connected = false
+    private var isConnecting = false
+    private var writeQueue = NSOperationQueue()
+    private var readStack = [WSResponse]()
+    private var inputQueue = [NSData]()
+    private var fragBuffer: NSData?
+    private var certValidated = false
+    private var didDisconnect = false
+    private var readyToWrite = false
+    private let mutex = NSLock()
+    private let notificationCenter = NSNotificationCenter.defaultCenter()
+    private var canDispatch: Bool {
+        mutex.lock()
+        let canWork = readyToWrite
+        mutex.unlock()
+        return canWork
+    }
+
+    /// The shared processing queue used for all WebSocket.
+    private static let sharedWorkQueue = dispatch_queue_create("com.vluxe.starscream.websocket", DISPATCH_QUEUE_SERIAL)
+
+    /// Used for setting protocols.
+    public init(url: NSURL, protocols: [String]? = nil) {
+        self.url = url
+        self.origin = url.absoluteString
+        writeQueue.maxConcurrentOperationCount = 1
+        optionalProtocols = protocols
+    }
+    
+    // Used for specifically setting the QOS for the write queue.
+    public convenience init(url: NSURL, writeQueueQOS: NSQualityOfService, protocols: [String]? = nil) {
+        self.init(url: url, protocols: protocols)
+        writeQueue.qualityOfService = writeQueueQOS
+    }
+
+    /// Connect to the WebSocket server on a background thread.
+    public func connect() {
+        guard !isConnecting else { return }
+        didDisconnect = false
+        isConnecting = true
+        createHTTPRequest()
+        isConnecting = false
+    }
+
+    /**
+     Disconnect from the server. I send a Close control frame to the server, then expect the server to respond with a Close control frame and close the socket from its end. I notify my delegate once the socket has been closed.
+
+     If you supply a non-nil `forceTimeout`, I wait at most that long (in seconds) for the server to close the socket. After the timeout expires, I close the socket and notify my delegate.
+
+     If you supply a zero (or negative) `forceTimeout`, I immediately close the socket (without sending a Close control frame) and notify my delegate.
+
+     - Parameter forceTimeout: Maximum time to wait for the server to close the socket.
+     */
+    public func disconnect(forceTimeout forceTimeout: NSTimeInterval? = nil) {
+        switch forceTimeout {
+        case .Some(let seconds) where seconds > 0:
+            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(seconds * Double(NSEC_PER_SEC))), callbackQueue) { [weak self] in
+                self?.disconnectStream(nil)
+            }
+            fallthrough
+        case .None:
+            writeError(CloseCode.Normal.rawValue)
+
+        default:
+            disconnectStream(nil)
+            break
+        }
+    }
+
+    /**
+     Write a string to the websocket. This sends it as a text frame.
+
+     If you supply a non-nil completion block, I will perform it when the write completes.
+
+     - parameter str:        The string to write.
+     - parameter completion: The (optional) completion handler.
+     */
+    public func writeString(str: String, completion: (() -> ())? = nil) {
+        guard isConnected else { return }
+        dequeueWrite(str.dataUsingEncoding(NSUTF8StringEncoding)!, code: .TextFrame, writeCompletion: completion)
+    }
+
+    /**
+     Write binary data to the websocket. This sends it as a binary frame.
+
+     If you supply a non-nil completion block, I will perform it when the write completes.
+
+     - parameter data:       The data to write.
+     - parameter completion: The (optional) completion handler.
+     */
+    public func writeData(data: NSData, completion: (() -> ())? = nil) {
+        guard isConnected else { return }
+        dequeueWrite(data, code: .BinaryFrame, writeCompletion: completion)
+    }
+
+    // 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
+    public func writePing(data: NSData, completion: (() -> ())? = nil) {
+        guard isConnected else { return }
+        dequeueWrite(data, code: .Ping, writeCompletion: completion)
+    }
+
+    /// Private method that starts the connection.
+    private func createHTTPRequest() {
+
+        let urlRequest = CFHTTPMessageCreateRequest(kCFAllocatorDefault, "GET",
+                                                    url, kCFHTTPVersion1_1).takeRetainedValue()
+
+        var port = url.port
+        if port == nil {
+            if supportedSSLSchemes.contains(url.scheme!) {
+                port = 443
+            } else {
+                port = 80
+            }
+        }
+        addHeader(urlRequest, key: headerWSUpgradeName, val: headerWSUpgradeValue)
+        addHeader(urlRequest, key: headerWSConnectionName, val: headerWSConnectionValue)
+        if let protocols = optionalProtocols {
+            addHeader(urlRequest, key: headerWSProtocolName, val: protocols.joinWithSeparator(","))
+        }
+        addHeader(urlRequest, key: headerWSVersionName, val: headerWSVersionValue)
+        addHeader(urlRequest, key: headerWSKeyName, val: generateWebSocketKey())
+        if let origin = origin {
+            addHeader(urlRequest, key: headerOriginName, val: origin)
+        }
+        addHeader(urlRequest, key: headerWSHostName, val: "\(url.host!):\(port!)")
+        for (key,value) in headers {
+            addHeader(urlRequest, key: key, val: value)
+        }
+        if let cfHTTPMessage = CFHTTPMessageCopySerializedMessage(urlRequest) {
+            let serializedRequest = cfHTTPMessage.takeRetainedValue()
+            initStreamsWithData(serializedRequest, Int(port!))
+        }
+    }
+
+    /// Add a header to the CFHTTPMessage by using the NSString bridges to CFString.
+    private func addHeader(urlRequest: CFHTTPMessage, key: NSString, val: NSString) {
+        CFHTTPMessageSetHeaderFieldValue(urlRequest, key, val)
+    }
+
+    /// Generate a WebSocket key as needed in RFC.
+    private func generateWebSocketKey() -> String {
+        var key = ""
+        let seed = 16
+        for _ in 0..<seed {
+            let uni = UnicodeScalar(UInt32(97 + arc4random_uniform(25)))
+            key += "\(Character(uni))"
+        }
+        let data = key.dataUsingEncoding(NSUTF8StringEncoding)
+        let baseKey = data?.base64EncodedStringWithOptions(NSDataBase64EncodingOptions(rawValue: 0))
+        return baseKey!
+    }
+
+    /// Start the stream connection and write the data to the output stream.
+    private func initStreamsWithData(data: NSData, _ port: Int) {
+        //higher level API we will cut over to at some point
+        //NSStream.getStreamsToHostWithName(url.host, port: url.port.integerValue, inputStream: &inputStream, outputStream: &outputStream)
+
+        var readStream: Unmanaged<CFReadStream>?
+        var writeStream: Unmanaged<CFWriteStream>?
+        let h: NSString = url.host!
+        CFStreamCreatePairWithSocketToHost(nil, h, UInt32(port), &readStream, &writeStream)
+        inputStream = readStream!.takeRetainedValue()
+        outputStream = writeStream!.takeRetainedValue()
+        guard let inStream = inputStream, let outStream = outputStream else { return }
+        inStream.delegate = self
+        outStream.delegate = self
+        if supportedSSLSchemes.contains(url.scheme!) {
+            inStream.setProperty(NSStreamSocketSecurityLevelNegotiatedSSL, forKey: NSStreamSocketSecurityLevelKey)
+            outStream.setProperty(NSStreamSocketSecurityLevelNegotiatedSSL, forKey: NSStreamSocketSecurityLevelKey)
+        } else {
+            certValidated = true //not a https session, so no need to check SSL pinning
+        }
+        if voipEnabled {
+            inStream.setProperty(NSStreamNetworkServiceTypeVoIP, forKey: NSStreamNetworkServiceType)
+            outStream.setProperty(NSStreamNetworkServiceTypeVoIP, forKey: NSStreamNetworkServiceType)
+        }
+        if selfSignedSSL {
+            let settings: [NSObject: NSObject] = [kCFStreamSSLValidatesCertificateChain: NSNumber(bool: false), kCFStreamSSLPeerName: kCFNull]
+            inStream.setProperty(settings, forKey: kCFStreamPropertySSLSettings as String)
+            outStream.setProperty(settings, forKey: kCFStreamPropertySSLSettings as String)
+        }
+        if let cipherSuites = self.enabledSSLCipherSuites {
+            if let sslContextIn = CFReadStreamCopyProperty(inputStream, kCFStreamPropertySSLContext) as! SSLContextRef?,
+                sslContextOut = CFWriteStreamCopyProperty(outputStream, kCFStreamPropertySSLContext) as! SSLContextRef? {
+                let resIn = SSLSetEnabledCiphers(sslContextIn, cipherSuites, cipherSuites.count)
+                let resOut = SSLSetEnabledCiphers(sslContextOut, cipherSuites, cipherSuites.count)
+                if resIn != errSecSuccess {
+                    let error = self.errorWithDetail("Error setting ingoing cypher suites", code: UInt16(resIn))
+                    disconnectStream(error)
+                    return
+                }
+                if resOut != errSecSuccess {
+                    let error = self.errorWithDetail("Error setting outgoing cypher suites", code: UInt16(resOut))
+                    disconnectStream(error)
+                    return
+                }
+            }
+        }
+        CFReadStreamSetDispatchQueue(inStream, WebSocket.sharedWorkQueue)
+        CFWriteStreamSetDispatchQueue(outStream, WebSocket.sharedWorkQueue)
+        inStream.open()
+        outStream.open()
+
+        self.mutex.lock()
+        self.readyToWrite = true
+        self.mutex.unlock()
+
+        let bytes = UnsafePointer<UInt8>(data.bytes)
+        var out = timeout * 1000000 // wait 5 seconds before giving up
+        writeQueue.addOperationWithBlock { [weak self] in
+            while !outStream.hasSpaceAvailable {
+                usleep(100) // wait until the socket is ready
+                out -= 100
+                if out < 0 {
+                    self?.cleanupStream()
+                    self?.doDisconnect(self?.errorWithDetail("write wait timed out", code: 2))
+                    return
+                } else if outStream.streamError != nil {
+                    return // disconnectStream will be called.
+                }
+            }
+            outStream.write(bytes, maxLength: data.length)
+        }
+    }
+
+    // Delegate for the stream methods. Processes incoming bytes.
+    public func stream(aStream: NSStream, handleEvent eventCode: NSStreamEvent) {
+
+        if let sec = security where !certValidated && [.HasBytesAvailable, .HasSpaceAvailable].contains(eventCode) {
+            let possibleTrust: AnyObject? = aStream.propertyForKey(kCFStreamPropertySSLPeerTrust as String)
+            if let trust: AnyObject = possibleTrust {
+                let domain: AnyObject? = aStream.propertyForKey(kCFStreamSSLPeerName as String)
+                if sec.isValid(trust as! SecTrustRef, domain: domain as! String?) {
+                    certValidated = true
+                } else {
+                    let error = errorWithDetail("Invalid SSL certificate", code: 1)
+                    disconnectStream(error)
+                    return
+                }
+            }
+        }
+        if eventCode == .HasBytesAvailable {
+            if aStream == inputStream {
+                processInputStream()
+            }
+        } else if eventCode == .ErrorOccurred {
+            disconnectStream(aStream.streamError)
+        } else if eventCode == .EndEncountered {
+            disconnectStream(nil)
+        }
+    }
+
+    /// Disconnect the stream object and notifies the delegate.
+    private func disconnectStream(error: NSError?) {
+        if error == nil {
+            writeQueue.waitUntilAllOperationsAreFinished()
+        } else {
+            writeQueue.cancelAllOperations()
+        }
+        cleanupStream()
+        doDisconnect(error)
+    }
+
+    private func cleanupStream() {
+        outputStream?.delegate = nil
+        inputStream?.delegate = nil
+        if let stream = inputStream {
+            CFReadStreamSetDispatchQueue(stream, nil)
+            stream.close()
+        }
+        if let stream = outputStream {
+            CFWriteStreamSetDispatchQueue(stream, nil)
+            stream.close()
+        }
+        outputStream = nil
+        inputStream = nil
+    }
+
+    /// Handles the incoming bytes and sending them to the proper processing method.
+    private func processInputStream() {
+        let buf = NSMutableData(capacity: BUFFER_MAX)
+        let buffer = UnsafeMutablePointer<UInt8>(buf!.bytes)
+        let length = inputStream!.read(buffer, maxLength: BUFFER_MAX)
+
+        guard length > 0 else { return }
+        var process = false
+        if inputQueue.count == 0 {
+            process = true
+        }
+        inputQueue.append(NSData(bytes: buffer, length: length))
+        if process {
+            dequeueInput()
+        }
+    }
+
+    /// Dequeue the incoming input so it is processed in order.
+    private func dequeueInput() {
+        while !inputQueue.isEmpty {
+            let data = inputQueue[0]
+            var work = data
+            if let fragBuffer = fragBuffer {
+                let combine = NSMutableData(data: fragBuffer)
+                combine.appendData(data)
+                work = combine
+                self.fragBuffer = nil
+            }
+            let buffer = UnsafePointer<UInt8>(work.bytes)
+            let length = work.length
+            if !connected {
+                processTCPHandshake(buffer, bufferLen: length)
+            } else {
+                processRawMessagesInBuffer(buffer, bufferLen: length)
+            }
+            inputQueue = inputQueue.filter{ $0 != data }
+        }
+    }
+
+    // Handle checking the initial connection status.
+    private func processTCPHandshake(buffer: UnsafePointer<UInt8>, bufferLen: Int) {
+        let code = processHTTP(buffer, bufferLen: bufferLen)
+        switch code {
+        case 0:
+            connected = true
+            guard canDispatch else {return}
+            dispatch_async(callbackQueue) { [weak self] in
+                guard let s = self else { return }
+                s.onConnect?()
+                s.delegate?.websocketDidConnect(s)
+                s.notificationCenter.postNotificationName(WebsocketDidConnectNotification, object: self)
+            }
+        case -1:
+            fragBuffer = NSData(bytes: buffer, length: bufferLen)
+        break // do nothing, we are going to collect more data
+        default:
+            doDisconnect(errorWithDetail("Invalid HTTP upgrade", code: UInt16(code)))
+        }
+    }
+
+    /// Finds the HTTP Packet in the TCP stream, by looking for the CRLF.
+    private func processHTTP(buffer: UnsafePointer<UInt8>, bufferLen: Int) -> Int {
+        let CRLFBytes = [UInt8(ascii: "\r"), UInt8(ascii: "\n"), UInt8(ascii: "\r"), UInt8(ascii: "\n")]
+        var k = 0
+        var totalSize = 0
+        for i in 0..<bufferLen {
+            if buffer[i] == CRLFBytes[k] {
+                k += 1
+                if k == 3 {
+                    totalSize = i + 1
+                    break
+                }
+            } else {
+                k = 0
+            }
+        }
+        if totalSize > 0 {
+            let code = validateResponse(buffer, bufferLen: totalSize)
+            if code != 0 {
+                return code
+            }
+            totalSize += 1 //skip the last \n
+            let restSize = bufferLen - totalSize
+            if restSize > 0 {
+                processRawMessagesInBuffer(buffer + totalSize, bufferLen: restSize)
+            }
+            return 0 //success
+        }
+        return -1 // Was unable to find the full TCP header.
+    }
+
+    /// Validates the HTTP is a 101 as per the RFC spec.
+    private func validateResponse(buffer: UnsafePointer<UInt8>, bufferLen: Int) -> Int {
+        let response = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, false).takeRetainedValue()
+        CFHTTPMessageAppendBytes(response, buffer, bufferLen)
+        let code = CFHTTPMessageGetResponseStatusCode(response)
+        if code != httpSwitchProtocolCode {
+            return code
+        }
+        if let cfHeaders = CFHTTPMessageCopyAllHeaderFields(response) {
+            let headers = cfHeaders.takeRetainedValue() as NSDictionary
+            if let acceptKey = headers[headerWSAcceptName] as? NSString {
+                if acceptKey.length > 0 {
+                    return 0
+                }
+            }
+        }
+        return -1
+    }
+
+    ///read a 16-bit big endian value from a buffer
+    private static func readUint16(buffer: UnsafePointer<UInt8>, offset: Int) -> UInt16 {
+        return (UInt16(buffer[offset + 0]) << 8) | UInt16(buffer[offset + 1])
+    }
+
+    ///read a 64-bit big endian value from a buffer
+    private static func readUint64(buffer: UnsafePointer<UInt8>, offset: Int) -> UInt64 {
+        var value = UInt64(0)
+        for i in 0...7 {
+            value = (value << 8) | UInt64(buffer[offset + i])
+        }
+        return value
+    }
+
+    /// Write a 16-bit big endian value to a buffer.
+    private static func writeUint16(buffer: UnsafeMutablePointer<UInt8>, offset: Int, value: UInt16) {
+        buffer[offset + 0] = UInt8(value >> 8)
+        buffer[offset + 1] = UInt8(value & 0xff)
+    }
+
+    /// Write a 64-bit big endian value to a buffer.
+    private static func writeUint64(buffer: UnsafeMutablePointer<UInt8>, offset: Int, value: UInt64) {
+        for i in 0...7 {
+            buffer[offset + i] = UInt8((value >> (8*UInt64(7 - i))) & 0xff)
+        }
+    }
+
+    /// Process one message at the start of `buffer`. Return another buffer (sharing storage) that contains the leftover contents of `buffer` that I didn't process.
+    @warn_unused_result
+    private func processOneRawMessage(inBuffer buffer: UnsafeBufferPointer<UInt8>) -> UnsafeBufferPointer<UInt8> {
+        let response = readStack.last
+        let baseAddress = buffer.baseAddress
+        let bufferLen = buffer.count
+        if response != nil && bufferLen < 2  {
+            fragBuffer = NSData(buffer: buffer)
+            return emptyBuffer
+        }
+        if let response = response where response.bytesLeft > 0 {
+            var len = response.bytesLeft
+            var extra = bufferLen - response.bytesLeft
+            if response.bytesLeft > bufferLen {
+                len = bufferLen
+                extra = 0
+            }
+            response.bytesLeft -= len
+            response.buffer?.appendData(NSData(bytes: baseAddress, length: len))
+            processResponse(response)
+            return buffer.fromOffset(bufferLen - extra)
+        } else {
+            let isFin = (FinMask & baseAddress[0])
+            let receivedOpcode = OpCode(rawValue: (OpCodeMask & baseAddress[0]))
+            let isMasked = (MaskMask & baseAddress[1])
+            let payloadLen = (PayloadLenMask & baseAddress[1])
+            var offset = 2
+            if (isMasked > 0 || (RSVMask & baseAddress[0]) > 0) && receivedOpcode != .Pong {
+                let errCode = CloseCode.ProtocolError.rawValue
+                doDisconnect(errorWithDetail("masked and rsv data is not currently supported", code: errCode))
+                writeError(errCode)
+                return emptyBuffer
+            }
+            let isControlFrame = (receivedOpcode == .ConnectionClose || receivedOpcode == .Ping)
+            if !isControlFrame && (receivedOpcode != .BinaryFrame && receivedOpcode != .ContinueFrame &&
+                receivedOpcode != .TextFrame && receivedOpcode != .Pong) {
+                let errCode = CloseCode.ProtocolError.rawValue
+                doDisconnect(errorWithDetail("unknown opcode: \(receivedOpcode)", code: errCode))
+                writeError(errCode)
+                return emptyBuffer
+            }
+            if isControlFrame && isFin == 0 {
+                let errCode = CloseCode.ProtocolError.rawValue
+                doDisconnect(errorWithDetail("control frames can't be fragmented", code: errCode))
+                writeError(errCode)
+                return emptyBuffer
+            }
+            if receivedOpcode == .ConnectionClose {
+                var code = CloseCode.Normal.rawValue
+                if payloadLen == 1 {
+                    code = CloseCode.ProtocolError.rawValue
+                } else if payloadLen > 1 {
+                    code = WebSocket.readUint16(baseAddress, offset: offset)
+                    if code < 1000 || (code > 1003 && code < 1007) || (code > 1011 && code < 3000) {
+                        code = CloseCode.ProtocolError.rawValue
+                    }
+                    offset += 2
+                }
+                var closeReason = "connection closed by server"
+                if payloadLen > 2 {
+                    let len = Int(payloadLen - 2)
+                    if len > 0 {
+                        let bytes = baseAddress + offset
+                        if let customCloseReason = String(data: NSData(bytes: bytes, length: len), encoding: NSUTF8StringEncoding) {
+                            closeReason = customCloseReason
+                        } else {
+                            code = CloseCode.ProtocolError.rawValue
+                        }
+                    }
+                }
+                doDisconnect(errorWithDetail(closeReason, code: code))
+                writeError(code)
+                return emptyBuffer
+            }
+            if isControlFrame && payloadLen > 125 {
+                writeError(CloseCode.ProtocolError.rawValue)
+                return emptyBuffer
+            }
+            var dataLength = UInt64(payloadLen)
+            if dataLength == 127 {
+                dataLength = WebSocket.readUint64(baseAddress, offset: offset)
+                offset += sizeof(UInt64)
+            } else if dataLength == 126 {
+                dataLength = UInt64(WebSocket.readUint16(baseAddress, offset: offset))
+                offset += sizeof(UInt16)
+            }
+            if bufferLen < offset || UInt64(bufferLen - offset) < dataLength {
+                fragBuffer = NSData(bytes: baseAddress, length: bufferLen)
+                return emptyBuffer
+            }
+            var len = dataLength
+            if dataLength > UInt64(bufferLen) {
+                len = UInt64(bufferLen-offset)
+            }
+            let data: NSData
+            if len < 0 {
+                len = 0
+                data = NSData()
+            } else {
+                data = NSData(bytes: baseAddress+offset, length: Int(len))
+            }
+            if receivedOpcode == .Pong {
+                if canDispatch {
+                    dispatch_async(callbackQueue) { [weak self] in
+                        guard let s = self else { return }
+                        s.onPong?()
+                        s.pongDelegate?.websocketDidReceivePong(s)
+                    }
+                }
+                return buffer.fromOffset(offset + Int(len))
+            }
+            var response = readStack.last
+            if isControlFrame {
+                response = nil // Don't append pings.
+            }
+            if isFin == 0 && receivedOpcode == .ContinueFrame && response == nil {
+                let errCode = CloseCode.ProtocolError.rawValue
+                doDisconnect(errorWithDetail("continue frame before a binary or text frame", code: errCode))
+                writeError(errCode)
+                return emptyBuffer
+            }
+            var isNew = false
+            if response == nil {
+                if receivedOpcode == .ContinueFrame  {
+                    let errCode = CloseCode.ProtocolError.rawValue
+                    doDisconnect(errorWithDetail("first frame can't be a continue frame",
+                        code: errCode))
+                    writeError(errCode)
+                    return emptyBuffer
+                }
+                isNew = true
+                response = WSResponse()
+                response!.code = receivedOpcode!
+                response!.bytesLeft = Int(dataLength)
+                response!.buffer = NSMutableData(data: data)
+            } else {
+                if receivedOpcode == .ContinueFrame  {
+                    response!.bytesLeft = Int(dataLength)
+                } else {
+                    let errCode = CloseCode.ProtocolError.rawValue
+                    doDisconnect(errorWithDetail("second and beyond of fragment message must be a continue frame",
+                        code: errCode))
+                    writeError(errCode)
+                    return emptyBuffer
+                }
+                response!.buffer!.appendData(data)
+            }
+            if let response = response {
+                response.bytesLeft -= Int(len)
+                response.frameCount += 1
+                response.isFin = isFin > 0 ? true : false
+                if isNew {
+                    readStack.append(response)
+                }
+                processResponse(response)
+            }
+
+            let step = Int(offset + numericCast(len))
+            return buffer.fromOffset(step)
+        }
+    }
+
+    /// Process all messages in the buffer if possible.
+    private func processRawMessagesInBuffer(pointer: UnsafePointer<UInt8>, bufferLen: Int) {
+        var buffer = UnsafeBufferPointer(start: pointer, count: bufferLen)
+        repeat {
+            buffer = processOneRawMessage(inBuffer: buffer)
+        } while buffer.count >= 2
+        if buffer.count > 0 {
+            fragBuffer = NSData(buffer: buffer)
+        }
+    }
+
+    /// Process the finished response of a buffer.
+    private func processResponse(response: WSResponse) -> Bool {
+        if response.isFin && response.bytesLeft <= 0 {
+            if response.code == .Ping {
+                let data = response.buffer! // local copy so it's not perverse for writing
+                dequeueWrite(data, code: OpCode.Pong)
+            } else if response.code == .TextFrame {
+                let str: NSString? = NSString(data: response.buffer!, encoding: NSUTF8StringEncoding)
+                if str == nil {
+                    writeError(CloseCode.Encoding.rawValue)
+                    return false
+                }
+                if canDispatch {
+                    dispatch_async(callbackQueue) { [weak self] in
+                        guard let s = self else { return }
+                        s.onText?(str! as String)
+                        s.delegate?.websocketDidReceiveMessage(s, text: str! as String)
+                    }
+                }
+            } else if response.code == .BinaryFrame {
+                if canDispatch {
+                    let data = response.buffer! //local copy so it's not perverse for writing
+                    dispatch_async(callbackQueue) { [weak self] in
+                        guard let s = self else { return }
+                        s.onData?(data)
+                        s.delegate?.websocketDidReceiveData(s, data: data)
+                    }
+                }
+            }
+            readStack.removeLast()
+            return true
+        }
+        return false
+    }
+
+    /// Create an error.
+    private func errorWithDetail(detail: String, code: UInt16) -> NSError {
+        var details = [String: String]()
+        details[NSLocalizedDescriptionKey] =  detail
+        return NSError(domain: WebSocket.ErrorDomain, code: Int(code), userInfo: details)
+    }
+
+    /// Write a an error to the socket.
+    private func writeError(code: UInt16) {
+        let buf = NSMutableData(capacity: sizeof(UInt16))
+        let buffer = UnsafeMutablePointer<UInt8>(buf!.bytes)
+        WebSocket.writeUint16(buffer, offset: 0, value: code)
+        dequeueWrite(NSData(bytes: buffer, length: sizeof(UInt16)), code: .ConnectionClose)
+    }
+
+    /// Used to write things to the stream.
+    private func dequeueWrite(data: NSData, code: OpCode, writeCompletion: (() -> ())? = nil) {
+        writeQueue.addOperationWithBlock { [weak self] in
+            //stream isn't ready, let's wait
+            guard let s = self else { return }
+            var offset = 2
+            let bytes = UnsafeMutablePointer<UInt8>(data.bytes)
+            let dataLength = data.length
+            let frame = NSMutableData(capacity: dataLength + s.MaxFrameSize)
+            let buffer = UnsafeMutablePointer<UInt8>(frame!.mutableBytes)
+            buffer[0] = s.FinMask | code.rawValue
+            if dataLength < 126 {
+                buffer[1] = CUnsignedChar(dataLength)
+            } else if dataLength <= Int(UInt16.max) {
+                buffer[1] = 126
+                WebSocket.writeUint16(buffer, offset: offset, value: UInt16(dataLength))
+                offset += sizeof(UInt16)
+            } else {
+                buffer[1] = 127
+                WebSocket.writeUint64(buffer, offset: offset, value: UInt64(dataLength))
+                offset += sizeof(UInt64)
+            }
+            buffer[1] |= s.MaskMask
+            let maskKey = UnsafeMutablePointer<UInt8>(buffer + offset)
+            _ = SecRandomCopyBytes(kSecRandomDefault, Int(sizeof(UInt32)), maskKey)
+            offset += sizeof(UInt32)
+
+            for i in 0..<dataLength {
+                buffer[offset] = bytes[i] ^ maskKey[i % sizeof(UInt32)]
+                offset += 1
+            }
+            var total = 0
+            while true {
+                guard let outStream = s.outputStream else { break }
+                let writeBuffer = UnsafePointer<UInt8>(frame!.bytes+total)
+                let len = outStream.write(writeBuffer, maxLength: offset-total)
+                if len < 0 {
+                    var error: NSError?
+                    if let streamError = outStream.streamError {
+                        error = streamError
+                    } else {
+                        let errCode = InternalErrorCode.OutputStreamWriteError.rawValue
+                        error = s.errorWithDetail("output stream error during write", code: errCode)
+                    }
+                    s.doDisconnect(error)
+                    break
+                } else {
+                    total += len
+                }
+                if total >= offset {
+                    if let callbackQueue = self?.callbackQueue, callback = writeCompletion {
+                        dispatch_async(callbackQueue) {
+                            callback()
+                        }
+                    }
+
+                    break
+                }
+            }
+
+        }
+    }
+
+    /// Used to preform the disconnect delegate.
+    private func doDisconnect(error: NSError?) {
+        guard !didDisconnect else { return }
+        didDisconnect = true
+        connected = false
+        guard canDispatch else {return}
+        dispatch_async(callbackQueue) { [weak self] in
+            guard let s = self else { return }
+            s.onDisconnect?(error)
+            s.delegate?.websocketDidDisconnect(s, error: error)
+            let userInfo = error.map{ [WebsocketDisconnectionErrorKeyName: $0] }
+            s.notificationCenter.postNotificationName(WebsocketDidDisconnectNotification, object: self, userInfo: userInfo)
+        }
+    }
+
+    // MARK: - Deinit
+
+    deinit {
+        mutex.lock()
+        readyToWrite = false
+        mutex.unlock()
+        cleanupStream()
+    }
+
+}
+
+private extension NSData {
+
+    convenience init(buffer: UnsafeBufferPointer<UInt8>) {
+        self.init(bytes: buffer.baseAddress, length: buffer.count)
+    }
+
+}
+
+private extension UnsafeBufferPointer {
+
+    func fromOffset(offset: Int) -> UnsafeBufferPointer<Element> {
+        return UnsafeBufferPointer<Element>(start: baseAddress.advancedBy(offset), count: count - offset)
+    }
+    
+}
+
+private let emptyBuffer = UnsafeBufferPointer<UInt8>(start: nil, count: 0)
+
@@ -1,177 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  Compression.swift
-//
-//  Created by Joseph Ross on 7/16/14.
-//  Copyright © 2017 Joseph Ross.
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//  http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//  See the License for the specific language governing permissions and
-//  limitations under the License.
-//
-//////////////////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  Compression implementation is implemented in conformance with RFC 7692 Compression Extensions
-//  for WebSocket: https://tools.ietf.org/html/rfc7692
-//
-//////////////////////////////////////////////////////////////////////////////////////////////////
-
-import Foundation
-import SSCZLib
-
-class Decompressor {
-    private var strm = z_stream()
-    private var buffer = [UInt8](repeating: 0, count: 0x2000)
-    private var inflateInitialized = false
-    private let windowBits:Int
-
-    init?(windowBits:Int) {
-        self.windowBits = windowBits
-        guard initInflate() else { return nil }
-    }
-
-    private func initInflate() -> Bool {
-        if Z_OK == inflateInit2_(&strm, -CInt(windowBits),
-                                 ZLIB_VERSION, CInt(MemoryLayout<z_stream>.size))
-        {
-            inflateInitialized = true
-            return true
-        }
-        return false
-    }
-
-    func reset() throws {
-        teardownInflate()
-        guard initInflate() else { throw NSError() }
-    }
-
-    func decompress(_ data: Data, finish: Bool) throws -> Data {
-        return try data.withUnsafeBytes { (bytes:UnsafePointer<UInt8>) -> Data in
-            return try decompress(bytes: bytes, count: data.count, finish: finish)
-        }
-    }
-
-    func decompress(bytes: UnsafePointer<UInt8>, count: Int, finish: Bool) throws -> Data {
-        var decompressed = Data()
-        try decompress(bytes: bytes, count: count, out: &decompressed)
-
-        if finish {
-            let tail:[UInt8] = [0x00, 0x00, 0xFF, 0xFF]
-            try decompress(bytes: tail, count: tail.count, out: &decompressed)
-        }
-
-        return decompressed
-
-    }
-
-    private func decompress(bytes: UnsafePointer<UInt8>, count: Int, out:inout Data) throws {
-        var res:CInt = 0
-        strm.next_in = UnsafeMutablePointer<UInt8>(mutating: bytes)
-        strm.avail_in = CUnsignedInt(count)
-
-        repeat {
-            strm.next_out = UnsafeMutablePointer<UInt8>(&buffer)
-            strm.avail_out = CUnsignedInt(buffer.count)
-
-            res = inflate(&strm, 0)
-
-            let byteCount = buffer.count - Int(strm.avail_out)
-            out.append(buffer, count: byteCount)
-        } while res == Z_OK && strm.avail_out == 0
-
-        guard (res == Z_OK && strm.avail_out > 0)
-            || (res == Z_BUF_ERROR && Int(strm.avail_out) == buffer.count)
-            else {
-                throw NSError(domain: WebSocket.ErrorDomain, code: Int(InternalErrorCode.compressionError.rawValue), userInfo: nil)
-        }
-    }
-
-    private func teardownInflate() {
-        if inflateInitialized, Z_OK == inflateEnd(&strm) {
-            inflateInitialized = false
-        }
-    }
-
-    deinit {
-        teardownInflate()
-    }
-}
-
-class Compressor {
-    private var strm = z_stream()
-    private var buffer = [UInt8](repeating: 0, count: 0x2000)
-    private var deflateInitialized = false
-    private let windowBits:Int
-
-    init?(windowBits: Int) {
-        self.windowBits = windowBits
-        guard initDeflate() else { return nil }
-    }
-
-    private func initDeflate() -> Bool {
-        if Z_OK == deflateInit2_(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-                                 -CInt(windowBits), 8, Z_DEFAULT_STRATEGY,
-                                 ZLIB_VERSION, CInt(MemoryLayout<z_stream>.size))
-        {
-            deflateInitialized = true
-            return true
-        }
-        return false
-    }
-
-    func reset() throws {
-        teardownDeflate()
-        guard initDeflate() else { throw NSError() }
-    }
-
-    func compress(_ data: Data) throws -> Data {
-        var compressed = Data()
-        var res:CInt = 0
-        data.withUnsafeBytes { (ptr:UnsafePointer<UInt8>) -> Void in
-            strm.next_in = UnsafeMutablePointer<UInt8>(mutating: ptr)
-            strm.avail_in = CUnsignedInt(data.count)
-
-            repeat {
-                strm.next_out = UnsafeMutablePointer<UInt8>(&buffer)
-                strm.avail_out = CUnsignedInt(buffer.count)
-
-                res = deflate(&strm, Z_SYNC_FLUSH)
-
-                let byteCount = buffer.count - Int(strm.avail_out)
-                compressed.append(buffer, count: byteCount)
-            }
-            while res == Z_OK && strm.avail_out == 0
-
-        }
-
-        guard res == Z_OK && strm.avail_out > 0
-            || (res == Z_BUF_ERROR && Int(strm.avail_out) == buffer.count)
-        else {
-            throw NSError(domain: WebSocket.ErrorDomain, code: Int(InternalErrorCode.compressionError.rawValue), userInfo: nil)
-        }
-
-        compressed.removeLast(4)
-        return compressed
-    }
-
-    private func teardownDeflate() {
-        if deflateInitialized, Z_OK == deflateEnd(&strm) {
-            deflateInitialized = false
-        }
-    }
-
-    deinit {
-        teardownDeflate()
-    }
-}
-
@@ -1,7 +1,7 @@
 Pod::Spec.new do |s|
  s.name         = "Starscream"
-  s.version      = "3.0.0"
-  s.summary      = "A conforming WebSocket RFC 6455 client library in Swift."
+  s.version      = "1.1.4"
+  s.summary      = "A conforming WebSocket RFC 6455 client library in Swift for iOS and OSX."
  s.homepage     = "https://github.com/daltoniam/Starscream"
  s.license      = 'Apache License, Version 2.0'
  s.author       = {'Dalton Cherry' => 'http://daltoniam.com', 'Austin Cherry' => 'http://austincherry.me'}
@@ -10,11 +10,6 @@ Pod::Spec.new do |s|
  s.ios.deployment_target = '8.0'
  s.osx.deployment_target = '10.10'
  s.tvos.deployment_target = '9.0'
-  s.watchos.deployment_target = '2.0'
  s.source_files = 'Source/*.swift'
-  s.libraries    = 'z'
-  s.pod_target_xcconfig = {
-  'SWIFT_INCLUDE_PATHS' => '$(PODS_ROOT)/Starscream/zlib'
-  }
-  s.preserve_paths = 'zlib/*'
+  s.requires_arc = 'true'
 end
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0900"
-   version = "1.7">
+   LastUpgradeVersion = "0800"
+   version = "1.3">
   <BuildAction
      parallelizeBuildables = "YES"
      buildImplicitDependencies = "YES">
@@ -14,9 +14,9 @@
            buildForAnalyzing = "YES">
            <BuildableReference
               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "33CCF0841F5DDC030099B092"
+               BlueprintIdentifier = "6B3E79E519D48B7F006071F7"
               BuildableName = "Starscream.framework"
-               BlueprintName = "Starscream"
+               BlueprintName = "Starscream iOS"
               ReferencedContainer = "container:Starscream.xcodeproj">
            </BuildableReference>
         </BuildActionEntry>
@@ -26,34 +26,9 @@
      buildConfiguration = "Debug"
      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
-      shouldUseLaunchSchemeArgsEnv = "YES"
-      codeCoverageEnabled = "YES">
+      shouldUseLaunchSchemeArgsEnv = "YES">
      <Testables>
-         <TestableReference
-            skipped = "NO">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "335FA1F41F5DF71D00F6D2EC"
-               BuildableName = "Starscream Tests.xctest"
-               BlueprintName = "Starscream Tests"
-               ReferencedContainer = "container:Starscream.xcodeproj">
-            </BuildableReference>
-            <LocationScenarioReference
-               identifier = "com.apple.dt.IDEFoundation.CurrentLocationScenarioIdentifier"
-               referenceType = "1">
-            </LocationScenarioReference>
-         </TestableReference>
      </Testables>
-      <MacroExpansion>
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "33CCF0841F5DDC030099B092"
-            BuildableName = "Starscream.framework"
-            BlueprintName = "Starscream"
-            ReferencedContainer = "container:Starscream.xcodeproj">
-         </BuildableReference>
-      </MacroExpansion>
      <AdditionalOptions>
      </AdditionalOptions>
   </TestAction>
@@ -61,7 +36,6 @@
      buildConfiguration = "Debug"
      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
      launchStyle = "0"
      useCustomWorkingDirectory = "NO"
      ignoresPersistentStateOnLaunch = "NO"
@@ -71,9 +45,9 @@
      <MacroExpansion>
         <BuildableReference
            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "33CCF0841F5DDC030099B092"
+            BlueprintIdentifier = "6B3E79E519D48B7F006071F7"
            BuildableName = "Starscream.framework"
-            BlueprintName = "Starscream"
+            BlueprintName = "Starscream iOS"
            ReferencedContainer = "container:Starscream.xcodeproj">
         </BuildableReference>
      </MacroExpansion>
@@ -89,9 +63,9 @@
      <MacroExpansion>
         <BuildableReference
            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "33CCF0841F5DDC030099B092"
+            BlueprintIdentifier = "6B3E79E519D48B7F006071F7"
            BuildableName = "Starscream.framework"
-            BlueprintName = "Starscream"
+            BlueprintName = "Starscream iOS"
            ReferencedContainer = "container:Starscream.xcodeproj">
         </BuildableReference>
      </MacroExpansion>
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0800"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "D9C3E35E19E48FF1009FC285"
+               BuildableName = "Starscream.framework"
+               BlueprintName = "Starscream OSX"
+               ReferencedContainer = "container:Starscream.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "D9C3E36819E48FF1009FC285"
+               BuildableName = "Starscream OSXTests.xctest"
+               BlueprintName = "Starscream OSXTests"
+               ReferencedContainer = "container:Starscream.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "D9C3E36819E48FF1009FC285"
+               BuildableName = "Starscream OSXTests.xctest"
+               BlueprintName = "Starscream OSXTests"
+               ReferencedContainer = "container:Starscream.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "D9C3E35E19E48FF1009FC285"
+            BuildableName = "Starscream.framework"
+            BlueprintName = "Starscream OSX"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "D9C3E35E19E48FF1009FC285"
+            BuildableName = "Starscream.framework"
+            BlueprintName = "Starscream OSX"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "D9C3E35E19E48FF1009FC285"
+            BuildableName = "Starscream.framework"
+            BlueprintName = "Starscream OSX"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0800"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "6B3E79F019D48B7F006071F7"
+               BuildableName = "Starscream iOSTests.xctest"
+               BlueprintName = "Starscream iOSTests"
+               ReferencedContainer = "container:Starscream.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "6B3E79F019D48B7F006071F7"
+               BuildableName = "Starscream iOSTests.xctest"
+               BlueprintName = "Starscream iOSTests"
+               ReferencedContainer = "container:Starscream.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "6B3E79F019D48B7F006071F7"
+            BuildableName = "Starscream iOSTests.xctest"
+            BlueprintName = "Starscream iOSTests"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "6B3E79F019D48B7F006071F7"
+            BuildableName = "Starscream iOSTests.xctest"
+            BlueprintName = "Starscream iOSTests"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "6B3E79F019D48B7F006071F7"
+            BuildableName = "Starscream iOSTests.xctest"
+            BlueprintName = "Starscream iOSTests"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0800"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "091277961BD673A70003036D"
+               BuildableName = "Starscream.framework"
+               BlueprintName = "Starscream tvOS"
+               ReferencedContainer = "container:Starscream.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "0912779F1BD673A70003036D"
+               BuildableName = "Starscream tvOSTests.xctest"
+               BlueprintName = "Starscream tvOSTests"
+               ReferencedContainer = "container:Starscream.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "0912779F1BD673A70003036D"
+               BuildableName = "Starscream tvOSTests.xctest"
+               BlueprintName = "Starscream tvOSTests"
+               ReferencedContainer = "container:Starscream.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "091277961BD673A70003036D"
+            BuildableName = "Starscream.framework"
+            BlueprintName = "Starscream tvOS"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "091277961BD673A70003036D"
+            BuildableName = "Starscream.framework"
+            BlueprintName = "Starscream tvOS"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "091277961BD673A70003036D"
+            BuildableName = "Starscream.framework"
+            BlueprintName = "Starscream tvOS"
+            ReferencedContainer = "container:Starscream.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
@@ -1,65 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  CompressionTests.swift
-//
-//  Created by Joseph Ross on 7/16/14.
-//  Copyright © 2017 Joseph Ross.
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//  http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//  See the License for the specific language governing permissions and
-//  limitations under the License.
-//
-//////////////////////////////////////////////////////////////////////////////////////////////////
-
-import XCTest
-
-class CompressionTests: XCTestCase {
-    
-    override func setUp() {
-        super.setUp()
-        // Put setup code here. This method is called before the invocation of each test method in the class.
-    }
-    
-    override func tearDown() {
-        // Put teardown code here. This method is called after the invocation of each test method in the class.
-        super.tearDown()
-    }
-    
-    func testBasic() {
-        let compressor = Compressor(windowBits: 15)!
-        let decompressor = Decompressor(windowBits: 15)!
-        
-        let rawData = "Hello, World! Hello, World! Hello, World! Hello, World! Hello, World!".data(using: .utf8)!
-        
-        let compressed = try! compressor.compress(rawData)
-        let uncompressed = try! decompressor.decompress(compressed, finish: true)
-        
-        XCTAssert(rawData == uncompressed)
-    }
-    
-    func testHugeData() {
-        let compressor = Compressor(windowBits: 15)!
-        let decompressor = Decompressor(windowBits: 15)!
-        
-        // 2 Gigs!
-//        var rawData = Data(repeating: 0, count: 0x80000000)
-        var rawData = Data(repeating: 0, count: 0x80000)
-        rawData.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) -> Void in
-            arc4random_buf(ptr, rawData.count)
-        }
-        
-        let compressed = try! compressor.compress(rawData)
-        let uncompressed = try! decompressor.decompress(compressed, finish: true)
-        
-        XCTAssert(rawData == uncompressed)
-    }
-    
-}
@@ -27,7 +27,7 @@ class StarscreamTests: XCTestCase {
    
    func testPerformanceExample() {
        // This is an example of a performance test case.
-        self.measure() {
+        self.measureBlock() {
            // Put the code you want to measure the time of here.
        }
    }
@@ -59,20 +59,6 @@
 			remoteGlobalIDString = 6B3E79E519D48B7F006071F7;
 			remoteInfo = Starscream;
 		};
-		5C42C3D51D8DF51C00947AA2 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 5C178E411B62D0EF00A97204 /* Starscream.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 091277971BD673A70003036D;
-			remoteInfo = "Starscream tvOS";
-		};
-		5C42C3D71D8DF51C00947AA2 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 5C178E411B62D0EF00A97204 /* Starscream.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 091277A01BD673A70003036D;
-			remoteInfo = "Starscream tvOSTests";
-		};
 /* End PBXContainerItemProxy section */

 /* Begin PBXFileReference section */
@@ -172,8 +158,6 @@
 				5C178E4B1B62D0EF00A97204 /* StarscreamTests.xctest */,
 				5C178E4D1B62D0EF00A97204 /* Starscream.framework */,
 				5C178E4F1B62D0EF00A97204 /* StarscreamOSXTests.xctest */,
-				5C42C3D61D8DF51C00947AA2 /* Starscream.framework */,
-				5C42C3D81D8DF51C00947AA2 /* Starscream tvOSTests.xctest */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -230,11 +214,9 @@
 				TargetAttributes = {
 					5C178E1B1B62D0B900A97204 = {
 						CreatedOnToolsVersion = 6.4;
-						LastSwiftMigration = 0800;
 					};
 					5C178E301B62D0B900A97204 = {
 						CreatedOnToolsVersion = 6.4;
-						LastSwiftMigration = 0800;
 						TestTargetID = 5C178E1B1B62D0B900A97204;
 					};
 				};
@@ -275,7 +257,7 @@
 		5C178E4B1B62D0EF00A97204 /* StarscreamTests.xctest */ = {
 			isa = PBXReferenceProxy;
 			fileType = wrapper.cfbundle;
-			path = "Starscream iOSTests.xctest";
+			path = StarscreamTests.xctest;
 			remoteRef = 5C178E4A1B62D0EF00A97204 /* PBXContainerItemProxy */;
 			sourceTree = BUILT_PRODUCTS_DIR;
 		};
@@ -289,24 +271,10 @@
 		5C178E4F1B62D0EF00A97204 /* StarscreamOSXTests.xctest */ = {
 			isa = PBXReferenceProxy;
 			fileType = wrapper.cfbundle;
-			path = "Starscream OSXTests.xctest";
+			path = StarscreamOSXTests.xctest;
 			remoteRef = 5C178E4E1B62D0EF00A97204 /* PBXContainerItemProxy */;
 			sourceTree = BUILT_PRODUCTS_DIR;
 		};
-		5C42C3D61D8DF51C00947AA2 /* Starscream.framework */ = {
-			isa = PBXReferenceProxy;
-			fileType = wrapper.framework;
-			path = Starscream.framework;
-			remoteRef = 5C42C3D51D8DF51C00947AA2 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		5C42C3D81D8DF51C00947AA2 /* Starscream tvOSTests.xctest */ = {
-			isa = PBXReferenceProxy;
-			fileType = wrapper.cfbundle;
-			path = "Starscream tvOSTests.xctest";
-			remoteRef = 5C42C3D71D8DF51C00947AA2 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
 /* End PBXReferenceProxy section */

 /* Begin PBXResourcesBuildPhase section */
@@ -472,7 +440,6 @@
 				INFOPLIST_FILE = Autobahn/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 3.0;
 			};
 			name = Debug;
 		};
@@ -483,7 +450,6 @@
 				INFOPLIST_FILE = Autobahn/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 3.0;
 			};
 			name = Release;
 		};
@@ -502,7 +468,6 @@
 				INFOPLIST_FILE = AutobahnTests/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 3.0;
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Autobahn.app/Autobahn";
 			};
 			name = Debug;
@@ -518,7 +483,6 @@
 				INFOPLIST_FILE = AutobahnTests/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 3.0;
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Autobahn.app/Autobahn";
 			};
 			name = Release;
@@ -14,30 +14,30 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?


-    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
+    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
        // Override point for customization after application launch.
        return true
    }

-    func applicationWillResignActive(_ application: UIApplication) {
+    func applicationWillResignActive(application: UIApplication) {
        // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
        // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
    }

-    func applicationDidEnterBackground(_ application: UIApplication) {
+    func applicationDidEnterBackground(application: UIApplication) {
        // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
        // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
    }

-    func applicationWillEnterForeground(_ application: UIApplication) {
+    func applicationWillEnterForeground(application: UIApplication) {
        // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
    }

-    func applicationDidBecomeActive(_ application: UIApplication) {
+    func applicationDidBecomeActive(application: UIApplication) {
        // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
    }

-    func applicationWillTerminate(_ application: UIApplication) {
+    func applicationWillTerminate(application: UIApplication) {
        // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
    }

@@ -12,6 +12,7 @@ import Starscream
 class ViewController: UIViewController {
    
    let host = "localhost:9001"
+    let scheme = "ws"
    var socketArray = [WebSocket]()
    var caseCount = 300 //starting cases
    override func viewDidLoad() {
@@ -20,31 +21,30 @@ class ViewController: UIViewController {
        //getTestInfo(1)
    }
    
-    func removeSocket(_ s: WebSocket?) {
-        socketArray = socketArray.filter{$0 != s}
+    func removeSocket(s: WebSocket) {
+        self.socketArray = self.socketArray.filter{$0 != s}
    }
    
    func getCaseCount() {
-        
-        let s = WebSocket(url: URL(string: "ws://\(host)/getCaseCount")!, protocols: [])
+        let s = WebSocket(url: NSURL(scheme: scheme, host: host, path: "/getCaseCount")!, protocols: [])
        socketArray.append(s)
-        s.onText = { [weak self]  (text: String) in
+        s.onText = {[unowned self] (text: String) in
            if let c = Int(text) {
                print("number of cases is: \(c)")
-                self?.caseCount = c
+                self.caseCount = c
            }
        }
-        s.onDisconnect = { [weak self, weak s]  (error: Error?) in
-            self?.getTestInfo(1)
-            self?.removeSocket(s)
+        s.onDisconnect = {[unowned self] (error: NSError?) in
+            self.getTestInfo(1)
+            self.removeSocket(s)
        }
        s.connect()
    }
    
-    func getTestInfo(_ caseNum: Int) {
+    func getTestInfo(caseNum: Int) {
        let s = createSocket("getCaseInfo",caseNum)
        socketArray.append(s)
-        s.onText = { (text: String) in
+        s.onText = {(text: String) in
 //            let data = text.dataUsingEncoding(NSUTF8StringEncoding)
 //            do {
 //                let resp: AnyObject? = try NSJSONSerialization.JSONObjectWithData(data!,
@@ -62,51 +62,45 @@ class ViewController: UIViewController {

        }
        var once = false
-        s.onDisconnect = { [weak self, weak s]  (error: Error?) in
+        s.onDisconnect = {[unowned self] (error: NSError?) in
            if !once {
                once = true
-                self?.runTest(caseNum)
+                self.runTest(caseNum)
            }
-            self?.removeSocket(s)
+            self.removeSocket(s)
        }
        s.connect()
    }
    
-    func runTest(_ caseNum: Int) {
+    func runTest(caseNum: Int) {
        let s = createSocket("runCase",caseNum)
        self.socketArray.append(s)
-        s.onText = { [weak s]  (text: String) in
-            s?.write(string: text)
+        s.onText = {(text: String) in
+            s.writeString(text)
        }
-        s.onData = { [weak s]  (data: Data) in
-            s?.write(data: data)
+        s.onData = {(data: NSData) in
+            s.writeData(data)
        }
        var once = false
-        s.onDisconnect = {[weak self, weak s] (error: Error?) in
+        s.onDisconnect = {[unowned self] (error: NSError?) in
            if !once {
                once = true
                print("case:\(caseNum) finished")
-                //self?.verifyTest(caseNum) disabled since it slows down the tests
-                let nextCase = caseNum+1
-                if nextCase <= (self?.caseCount)! {
-                    self?.getTestInfo(nextCase)
-                } else {
-                    self?.finishReports()
-                }
-                self?.removeSocket(s)
+                self.verifyTest(caseNum)
+                self.removeSocket(s)
            }
        }
        s.connect()
    }
    
-    func verifyTest(_ caseNum: Int) {
+    func verifyTest(caseNum: Int) {
        let s = createSocket("getCaseStatus",caseNum)
        self.socketArray.append(s)
-        s.onText = { (text: String) in
-            let data = text.data(using: String.Encoding.utf8)
+        s.onText = {(text: String) in
+            let data = text.dataUsingEncoding(NSUTF8StringEncoding)
            do {
-                let resp: Any? = try JSONSerialization.jsonObject(with: data!,
-                    options: JSONSerialization.ReadingOptions())
+                let resp: AnyObject? = try NSJSONSerialization.JSONObjectWithData(data!,
+                    options: NSJSONReadingOptions())
                if let dict = resp as? Dictionary<String,String> {
                    if let status = dict["behavior"] {
                        if status == "OK" {
@@ -121,18 +115,17 @@ class ViewController: UIViewController {
            }
        }
        var once = false
-        s.onDisconnect = { [weak self, weak s]  (error: Error?) in
+        s.onDisconnect = {[unowned self] (error: NSError?) in
            if !once {
                once = true
                let nextCase = caseNum+1
-                print("next test is: \(nextCase)")
-                if nextCase <= (self?.caseCount)! {
-                    self?.getTestInfo(nextCase)
+                if nextCase <= self.caseCount {
+                    self.getTestInfo(nextCase)
                } else {
-                    self?.finishReports()
+                    self.finishReports()
                }
            }
-            self?.removeSocket(s)
+            self.removeSocket(s)
        }
        s.connect()
    }
@@ -140,18 +133,19 @@ class ViewController: UIViewController {
    func finishReports() {
        let s = createSocket("updateReports",0)
        self.socketArray.append(s)
-        s.onDisconnect = { [weak self, weak s]  (error: Error?) in
+        s.onDisconnect = {[unowned self] (error: NSError?) in
            print("finished all the tests!")
-            self?.removeSocket(s)
+            self.removeSocket(s)
        }
        s.connect()
    }
    
-    func createSocket(_ cmd: String, _ caseNum: Int) -> WebSocket {
-        return WebSocket(url: URL(string: "ws://\(host)\(buildPath(cmd,caseNum))")!, protocols: [])
+    func createSocket(cmd: String, _ caseNum: Int) -> WebSocket {
+        return WebSocket(url: NSURL(scheme: scheme,
+            host: host, path: buildPath(cmd,caseNum))!, protocols: [])
    }
    
-    func buildPath(_ cmd: String, _ caseNum: Int) -> String {
+    func buildPath(cmd: String, _ caseNum: Int) -> String {
        return "/\(cmd)?case=\(caseNum)&agent=Starscream"
    }

@@ -28,7 +28,7 @@ class AutobahnTests: XCTestCase {
    
    func testPerformanceExample() {
        // This is an example of a performance test case.
-        self.measure() {
+        self.measureBlock() {
            // Put the code you want to measure the time of here.
        }
    }
@@ -37,14 +37,14 @@
 			remoteGlobalIDString = D9C3E36919E48FF1009FC285;
 			remoteInfo = StarscreamOSXTests;
 		};
-		5C42C3E01D8F31DC00947AA2 /* PBXContainerItemProxy */ = {
+		5C42C3EB1D8F32EF00947AA2 /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 6B3E7A0819D48D00006071F7 /* Starscream.xcodeproj */;
 			proxyType = 2;
 			remoteGlobalIDString = 091277971BD673A70003036D;
 			remoteInfo = "Starscream tvOS";
 		};
-		5C42C3E21D8F31DC00947AA2 /* PBXContainerItemProxy */ = {
+		5C42C3ED1D8F32EF00947AA2 /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 6B3E7A0819D48D00006071F7 /* Starscream.xcodeproj */;
 			proxyType = 2;
@@ -146,8 +146,8 @@
 				6B3E7A1019D48D00006071F7 /* Starscream iOSTests.xctest */,
 				5C06AE8B1B08044600D41060 /* Starscream.framework */,
 				5C06AE8D1B08044600D41060 /* Starscream OSXTests.xctest */,
-				5C42C3E11D8F31DC00947AA2 /* Starscream.framework */,
-				5C42C3E31D8F31DC00947AA2 /* Starscream tvOSTests.xctest */,
+				5C42C3EC1D8F32EF00947AA2 /* Starscream.framework */,
+				5C42C3EE1D8F32EF00947AA2 /* Starscream tvOSTests.xctest */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -181,7 +181,7 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0700;
-				LastUpgradeCheck = 0900;
+				LastUpgradeCheck = 0800;
 				ORGANIZATIONNAME = vluxe;
 				TargetAttributes = {
 					5C765ADA199A6DAA003D9110 = {
@@ -229,18 +229,18 @@
 			remoteRef = 5C06AE8C1B08044600D41060 /* PBXContainerItemProxy */;
 			sourceTree = BUILT_PRODUCTS_DIR;
 		};
-		5C42C3E11D8F31DC00947AA2 /* Starscream.framework */ = {
+		5C42C3EC1D8F32EF00947AA2 /* Starscream.framework */ = {
 			isa = PBXReferenceProxy;
 			fileType = wrapper.framework;
 			path = Starscream.framework;
-			remoteRef = 5C42C3E01D8F31DC00947AA2 /* PBXContainerItemProxy */;
+			remoteRef = 5C42C3EB1D8F32EF00947AA2 /* PBXContainerItemProxy */;
 			sourceTree = BUILT_PRODUCTS_DIR;
 		};
-		5C42C3E31D8F31DC00947AA2 /* Starscream tvOSTests.xctest */ = {
+		5C42C3EE1D8F32EF00947AA2 /* Starscream tvOSTests.xctest */ = {
 			isa = PBXReferenceProxy;
 			fileType = wrapper.cfbundle;
 			path = "Starscream tvOSTests.xctest";
-			remoteRef = 5C42C3E21D8F31DC00947AA2 /* PBXContainerItemProxy */;
+			remoteRef = 5C42C3ED1D8F32EF00947AA2 /* PBXContainerItemProxy */;
 			sourceTree = BUILT_PRODUCTS_DIR;
 		};
 		6B3E7A0E19D48D00006071F7 /* Starscream.framework */ = {
@@ -311,20 +311,14 @@
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
@@ -364,20 +358,14 @@
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
@@ -411,7 +399,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = "com.vluxe.io.$(PRODUCT_NAME:rfc1034identifier)";
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 2.3;
 			};
 			name = Debug;
 		};
@@ -424,7 +412,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = "com.vluxe.io.$(PRODUCT_NAME:rfc1034identifier)";
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 2.3;
 			};
 			name = Release;
 		};
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0900"
+   LastUpgradeVersion = "0800"
   version = "1.3">
   <BuildAction
      parallelizeBuildables = "YES"
@@ -40,7 +40,6 @@
      buildConfiguration = "Debug"
      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
      shouldUseLaunchSchemeArgsEnv = "YES">
      <Testables>
         <TestableReference
@@ -70,7 +69,6 @@
      buildConfiguration = "Debug"
      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
      launchStyle = "0"
      useCustomWorkingDirectory = "NO"
      ignoresPersistentStateOnLaunch = "NO"
@@ -87,13 +85,6 @@
            ReferencedContainer = "container:SimpleTest.xcodeproj">
         </BuildableReference>
      </BuildableProductRunnable>
-      <EnvironmentVariables>
-         <EnvironmentVariable
-            key = "OS_ACTIVITY_MODE"
-            value = "disable"
-            isEnabled = "YES">
-         </EnvironmentVariable>
-      </EnvironmentVariables>
      <AdditionalOptions>
      </AdditionalOptions>
   </LaunchAction>
@@ -14,30 +14,30 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?


-    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
+    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject : AnyObject]?) -> Bool {
        // Override point for customization after application launch.
        return true
    }

-    func applicationWillResignActive(_ application: UIApplication) {
+    func applicationWillResignActive(application: UIApplication) {
        // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
        // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
    }

-    func applicationDidEnterBackground(_ application: UIApplication) {
+    func applicationDidEnterBackground(application: UIApplication) {
        // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
        // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
    }

-    func applicationWillEnterForeground(_ application: UIApplication) {
+    func applicationWillEnterForeground(application: UIApplication) {
        // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
    }

-    func applicationDidBecomeActive(_ application: UIApplication) {
+    func applicationDidBecomeActive(application: UIApplication) {
        // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
    }

-    func applicationWillTerminate(_ application: UIApplication) {
+    func applicationWillTerminate(application: UIApplication) {
        // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
    }

@@ -10,7 +10,7 @@ import UIKit
 import Starscream

 class ViewController: UIViewController, WebSocketDelegate {
-    var socket = WebSocket(url: URL(string: "ws://localhost:8080/")!, protocols: ["chat", "superchat"])
+    var socket = WebSocket(url: NSURL(string: "ws://localhost:8080/")!, protocols: ["chat", "superchat"])
    
    override func viewDidLoad() {
        super.viewDidLoad()
@@ -20,11 +20,11 @@ class ViewController: UIViewController, WebSocketDelegate {
    
    // MARK: Websocket Delegate Methods.
    
-    func websocketDidConnect(socket: WebSocketClient) {
+    func websocketDidConnect(ws: WebSocket) {
        print("websocket is connected")
    }
    
-    func websocketDidDisconnect(socket: WebSocketClient, error: Error?) {
+    func websocketDidDisconnect(ws: WebSocket, error: NSError?) {
        if let e = error {
            print("websocket is disconnected: \(e.localizedDescription)")
        } else {
@@ -32,23 +32,23 @@ class ViewController: UIViewController, WebSocketDelegate {
        }
    }
    
-    func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
+    func websocketDidReceiveMessage(ws: WebSocket, text: String) {
        print("Received text: \(text)")
    }
    
-    func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
-        print("Received data: \(data.count)")
+    func websocketDidReceiveData(ws: WebSocket, data: NSData) {
+        print("Received data: \(data.length)")
    }
    
    // MARK: Write Text Action
    
-    @IBAction func writeText(_ sender: UIBarButtonItem) {
-        socket.write(string: "hello there!")
+    @IBAction func writeText(sender: UIBarButtonItem) {
+        socket.writeString("hello there!")
    }
    
    // MARK: Disconnect Action
    
-    @IBAction func disconnect(_ sender: UIBarButtonItem) {
+    @IBAction func disconnect(sender: UIBarButtonItem) {
        if socket.isConnected {
            sender.title = "Connect"
            socket.disconnect()
@@ -22,4 +22,4 @@ EM.run {
      ws.send Faker::Hacker.say_something_smart
    }
  end
-}
+}
@@ -1,2 +0,0 @@
-#include <zlib.h>
-#include <CommonCrypto/CommonCrypto.h>
@@ -1,9 +0,0 @@
-module SSCZLib [system] {
-    header "include.h"
-    link "z"
-    export *
-}
-module SSCommonCrypto [system] {
-    header "include.h"
-    export *
-}
Author	SHA1	Message	Date
Dalton	a0ebc467b7	Merge pull request #255 from pvzig/swift-23 Update OS X deployment target	2016-09-25 22:08:58 -05:00
Peter Zignego	fc5529e18f	Update OS X deployment target `NSQualityOfService` requires 10.10 or later.	2016-09-25 15:03:02 -04:00
Peter Zignego	b0d7d4504b	Merge pull request #1 from daltoniam/swift-23 Swift 23	2016-09-25 14:59:37 -04:00