Added support for https, closes #2

Request.swift.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
     s.name             = 'Request.swift'
-    s.version          = '2.1.0'
+    s.version          = '2.2.0'
     s.summary          = 'A (sync/async) tiny http client written in swift.'
     s.homepage         = 'https://github.com/BiAtoms/Request.swift'
     s.license          = { :type => 'MIT', :file => 'LICENSE' }

Sources/Client.swift

@@ -24,35 +24,41 @@ open class Client {
 
     public init(baseUrl: String? = nil, usesSystemProxy: Bool = true) {
         self.baseUrl = baseUrl
+        self.usesSystemProxy = usesSystemProxy
+        #if os(Linux)
+            try! TLS.initialize()
+        #endif
     }
 
     //https://forums.developer.apple.com/thread/65416
     open static func getSystemProxy(for host: String) -> Proxy? {
         #if os(Linux) //CFNetworkCopySystemProxySettings hasn't been implemented. (see https://github.com/apple/swift-corelibs-foundation)
         #else
-        if let url = URL(string: host) {
-            if let proxySettingsUnmanaged = CFNetworkCopySystemProxySettings() {
-                let proxySettings = proxySettingsUnmanaged.takeRetainedValue()
-                let proxiesUnmanaged = CFNetworkCopyProxiesForURL(url as CFURL, proxySettings)
-                let proxies = proxiesUnmanaged.takeRetainedValue() as! [[String:AnyObject]]
-
-                for dict in proxies {
-                    if let type = dict[kCFProxyTypeKey as String] {
-                        if type as! CFString  == kCFProxyTypeHTTP { //only http for now
-                            let host = dict[kCFProxyHostNameKey as String] as! String
-                            let port = (dict[kCFProxyPortNumberKey as String] as! NSNumber).intValue
-                            return (host, Port(port))
-                        }
-                    }
+            guard let url = URL(string: host),
+                let proxySettingsUnmanaged = CFNetworkCopySystemProxySettings()
+                else { return nil }
+            let proxySettings = proxySettingsUnmanaged.takeRetainedValue()
+            let proxiesUnmanaged = CFNetworkCopyProxiesForURL(url as CFURL, proxySettings)
+            let proxies = proxiesUnmanaged.takeRetainedValue() as! [[String: AnyObject]]
+
+            func isValid(type: Any) -> Bool {
+                let t = type as! CFString
+                let isHttp = url.scheme == "http" && t == kCFProxyTypeHTTP
+                let isHttps = url.scheme == "https" && t == kCFProxyTypeHTTPS
+                return isHttp || isHttps
+            }
+            for dict in proxies {
+                guard let type = dict[kCFProxyTypeKey as String] else { continue }
+                if isValid(type: type) {
+                    let host = dict[kCFProxyHostNameKey as String] as! String
+                    let port = (dict[kCFProxyPortNumberKey as String] as! NSNumber).intValue
+                    return (host, Port(port))
                 }
-
-            }   
-        }
+            }
         #endif
         return nil
     }
 
-
     open func request(_ url: String, method: Request.Method = .get, parameters: Parameters? = nil, encoding: ParameterEncoding = URLEncoding.default, headers: Headers? = nil)
         -> Requester
     {

Sources/Request.swift

@@ -51,6 +51,14 @@ open class Request {
         return (hostname, port)
     }
 
+    open var defaultPort: Port {
+        return isSecure ? 443 : 80
+    }
+
+    open var isSecure: Bool {
+        return url.starts(with: "https")
+    }
+
     private static func firstMatch(pattern: String, in string: String) -> NSTextCheckingResult {
         let regex = try! NSRegularExpression(pattern: pattern, options: .caseInsensitive)
         return regex.firstMatch(in: string, options: [], range: NSRange(location: 0, length: string.characters.count))!

Sources/Requester.swift

@@ -80,20 +80,24 @@ open class Requester {
         let (hostname, portString) = request.hostnameAndPort
         if let proxy = self.proxy {
             try connect(socket, hostname: proxy.host, port: proxy.port)
-            let to = hostname + ":" + (portString ?? "80")
+            let to = hostname + ":" + (portString ?? "\(request.defaultPort)")
             try socket.write("CONNECT \(to) HTTP/1.0\r\n\r\n".bytes)
             try wait(socket)
             let response = try ResponseParser.parse(socket: socket)
             if response.statusCode != 200 {
                 throw Request.Error.proxyConnectionFailed
             }
         } else {
-            var port: SocketSwift.Port = 80
+            var port: SocketSwift.Port = request.defaultPort
             if let p = portString {
                 port = Port(p)!
             }
             try connect(socket, hostname: hostname, port: port)
         }
+
+        if request.isSecure {
+            try socket.startTls(.init(peer: hostname))
+        }
     }
 
     open func reset() {

Tests/RequestSwiftTests/RequestSwiftTests.swift

@@ -18,8 +18,8 @@ class RequestSwiftTests: XCTestCase {
         return a.client
     }
 
-    func testExample() {
-        let ex = expectation(description: "example")
+    func testHttp() {
+        let ex = expectation(description: "http")
         client.request("http://example.com/", headers: ["Accept": "text/html"]).response { response, error in
 
             XCTAssertNil(error, "error should be nil")
@@ -36,6 +36,25 @@ class RequestSwiftTests: XCTestCase {
         waitForExpectations()
     }
 
+    func testHttps() {
+        let ex = expectation(description: "https")
+        client.request("https://example.com", headers: ["Accept": "text/html"]).response { response, error in
+
+            XCTAssertNil(error, "error should be nil")
+            XCTAssertNotNil(response, "response should no be nil")
+            let response = response!
+            XCTAssertEqual(response.statusCode, 200)
+            XCTAssertEqual(response.reasonPhrase, "OK")
+            print(String(cString: response.body))
+            XCTAssert(String(cString: response.body).contains("<h1>Example Domain</h1>"))
+
+            ex.fulfill()
+        }
+
+        waitForExpectations()
+    }
+
+
     func testErrorTimeout() {
         let ex = expectation(description: "timeout")
         client.firesImmediately = false
@@ -113,16 +132,16 @@ class RequestSwiftTests: XCTestCase {
 
         XCTAssertEqual(writtenStringArray, requestStringArray)
     }
-
 
     static var allTests = [
-        ("testExample", testExample),
+        ("testHttp", testHttp),
+        ("testHttps", testHttps),
         ("testErrorTimeout", testErrorTimeout),
         ("testErrorDNS", testErrorDNS),
         ("testUrlEncoding", testUrlEncoding),
         ("testRequestPath", testErrorDNS),
         ("testRequestWriter", testRequestWriter),
-        ]
+    ]
 }
 
 extension XCTestCase {