Add default headers. Support gzip, deflate encoding.

danieleggert · danieleggert · commit f43c554ea20a · 2016-04-06T23:36:31.000+02:00
Accept: */*
Accept-Encoding: deflate, gzip
Connection: keep-alive
User-Agent: TestFoundation (unknown version) curl/7.43.0
diff --git a/CoreFoundation/URL.subproj/CFURLSessionInterface.c b/CoreFoundation/URL.subproj/CFURLSessionInterface.c
@@ -714,9 +714,18 @@ CFURLSessionPoll const CFURLSessionPollOut = { CURL_POLL_OUT };
 CFURLSessionPoll const CFURLSessionPollInOut = { CURL_POLL_INOUT };
 CFURLSessionPoll const CFURLSessionPollRemove = { CURL_POLL_REMOVE };
 
-char *CFURLSessionCurlVersion(void) {
+char *CFURLSessionCurlVersionString(void) {
     return curl_version();
 }
+CFURLSessionCurlVersion CFURLSessionCurlVersionInfo(void) {
+    curl_version_info_data *info = curl_version_info(CURLVERSION_NOW);
+    CFURLSessionCurlVersion v = {
+        info->version_num >> 16 & 0xff,
+        info->version_num >> 8 & 0xff,
+        info->version_num & 0xff,
+    };
+    return v;
+}
 
 
 int const CFURLSessionWriteFuncPause = CURL_WRITEFUNC_PAUSE;
diff --git a/CoreFoundation/URL.subproj/CFURLSessionInterface.h b/CoreFoundation/URL.subproj/CFURLSessionInterface.h
@@ -673,7 +673,13 @@ CF_EXPORT CFURLSessionProtocol const CFURLSessionProtocolALL; // CURLPROTO_ALL
 
 CF_EXPORT size_t const CFURLSessionMaxWriteSize; // CURL_MAX_WRITE_SIZE
 
-CF_EXPORT char * _Nonnull CFURLSessionCurlVersion(void);
+CF_EXPORT char * _Nonnull CFURLSessionCurlVersionString(void);
+typedef struct CFURLSessionCurlVersion {
+    int major;
+    int minor;
+    int patch;
+} CFURLSessionCurlVersion;
+CF_EXPORT CFURLSessionCurlVersion CFURLSessionCurlVersionInfo(void);
 
 
 CF_EXPORT int const CFURLSessionWriteFuncPause;
diff --git a/Foundation/NSURLSession/EasyHandle.swift b/Foundation/NSURLSession/EasyHandle.swift
@@ -217,12 +217,6 @@ extension NSURLSessionTask.EasyHandle {
         // We need to retain the list for as long as the rawHandle is in use.
         headerList = list
     }
-    /// Disable HTTP content decoding
-    /// - SeeAlso: https://curl.haxx.se/libcurl/c/CURLOPT_HTTP_CONTENT_DECODING.html
-    func setDisableContentDecoding() {
-        //TODO: Darwin Foundation appears to automatically handle content decoding (gzip) ?!?
-        try! CFURLSession_easy_setopt_long(rawHandle, CFURLSessionOptionHTTP_CONTENT_DECODING, 0).asError()
-    }
     /// Wait for pipelining/multiplexing
     /// - SeeAlso: https://curl.haxx.se/libcurl/c/CURLOPT_PIPEWAIT.html
     func setWaitForPipeliningAndMultiplexing(flag: Bool) {
@@ -241,7 +235,20 @@ extension NSURLSessionTask.EasyHandle {
         let w = 1 + max(0, min(255, Int(round(weight * 255))))
         try! CFURLSession_easy_setopt_long(rawHandle, CFURLSessionOptionPIPEWAIT, w).asError()
     }
-    
+    /// Enable automatic decompression of HTTP downloads
+    /// - SeeAlso: https://curl.haxx.se/libcurl/c/CURLOPT_ACCEPT_ENCODING.html
+    /// - SeeAlso: https://curl.haxx.se/libcurl/c/CURLOPT_HTTP_CONTENT_DECODING.html
+    func setAutomaticBodyDecompression(flag: Bool) {
+        if flag {
+            "".withCString {
+                try! CFURLSession_easy_setopt_ptr(rawHandle, CFURLSessionOptionACCEPT_ENCODING, UnsafeMutablePointer($0)).asError()
+            }
+            try! CFURLSession_easy_setopt_long(rawHandle, CFURLSessionOptionHTTP_CONTENT_DECODING, 1).asError()
+        } else {
+            try! CFURLSession_easy_setopt_ptr(rawHandle, CFURLSessionOptionACCEPT_ENCODING, nil).asError()
+            try! CFURLSession_easy_setopt_long(rawHandle, CFURLSessionOptionHTTP_CONTENT_DECODING, 0).asError()
+        }
+    }
     /// Set request method
     /// - SeeAlso: https://curl.haxx.se/libcurl/c/CURLOPT_CUSTOMREQUEST.html
     func setRequestMethod(method: String) {
diff --git a/Foundation/NSURLSession/NSURLSessionTask.swift b/Foundation/NSURLSession/NSURLSessionTask.swift
@@ -541,23 +541,97 @@ private extension NSURLSessionTask {
         
         // HTTP Options:
         easyHandle.setFollowLocation(false)
-        //TODO: Fix headers
-        var headers: [String] = []
-        if case .none = body {
-        } else {
-            headers.append("Expect:")
-        }
-        easyHandle.setCustomHeaders(headers)
-        easyHandle.setDisableContentDecoding()
+        easyHandle.setCustomHeaders(curlHeaders(for: request))
         easyHandle.setWaitForPipeliningAndMultiplexing(true)
         easyHandle.setStreamWeight(priority)
+        easyHandle.setAutomaticBodyDecompression(true)
         easyHandle.setRequestMethod(request.HTTPMethod ?? "GET")
         if request.HTTPMethod == "HEAD" {
             easyHandle.setNoBody(true)
         }
     }
 }
 
+private extension NSURLSessionTask {
+    /// These are a list of headers that should be passed to libcurl.
+    ///
+    /// Headers will be returned as `Accept: text/html` strings for
+    /// setting fields, `Accept:` for disabling the libcurl default header, or
+    /// `Accept;` for a header with no content. This is the format that libcurl
+    /// expects.
+    ///
+    /// - SeeAlso: https://curl.haxx.se/libcurl/c/CURLOPT_HTTPHEADER.html
+    func curlHeaders(for request: NSURLRequest) -> [String] {
+        var result: [String] = []
+        var names = Set<String>()
+        if let hh = currentRequest?.allHTTPHeaderFields {
+            hh.forEach {
+                let name = $0.0.lowercased()
+                guard !names.contains(name) else { return }
+                names.insert(name)
+                
+                if $0.1.isEmpty {
+                    result.append($0.0 + ";")
+                } else {
+                    result.append($0.0 + ": " + $0.1)
+                }
+            }
+        }
+        curlHeadersToSet.forEach {
+            let name = $0.0.lowercased()
+            guard !names.contains(name) else { return }
+            names.insert(name)
+            
+            if $0.1.isEmpty {
+                result.append($0.0 + ";")
+            } else {
+                result.append($0.0 + ": " + $0.1)
+            }
+        }
+        curlHeadersToRemove.forEach {
+            let name = $0.lowercased()
+            guard !names.contains(name) else { return }
+            names.insert(name)
+            result.append($0 + ":")
+        }
+        return result
+    }
+    /// Any header values that should be passed to libcurl
+    ///
+    /// These will only be set if not already part of the request.
+    /// - SeeAlso: https://curl.haxx.se/libcurl/c/CURLOPT_HTTPHEADER.html
+    var curlHeadersToSet: [(String,String)] {
+        var result = [("Connection", "keep-alive"),
+                      ("User-Agent", userAgentString),
+                      ]
+        if let language = NSLocale.currentLocale().objectForKey(NSLocaleLanguageCode) as? String {
+            result.append(("Accept-Language", language))
+        }
+        return result
+    }
+    /// Any header values that should be removed from the ones set by libcurl
+    /// - SeeAlso: https://curl.haxx.se/libcurl/c/CURLOPT_HTTPHEADER.html
+    var curlHeadersToRemove: [String] {
+        if case .none = body {
+            return []
+        } else {
+            return ["Expect"]
+        }
+    }
+}
+
+private var userAgentString: String = {
+    // Darwin uses something like this: "xctest (unknown version) CFNetwork/760.4.2 Darwin/15.4.0 (x86_64)"
+    let info = NSProcessInfo.processInfo()
+    let name = info.processName
+    let curlVersion = CFURLSessionCurlVersionInfo()
+    //TODO: Should probably use sysctl(3) to get these:
+    // kern.ostype: Darwin
+    // kern.osrelease: 15.4.0
+    //TODO: Use NSBundle to get the version number?
+    return "\(name) (unknown version) curl/\(curlVersion.major).\(curlVersion.minor).\(curlVersion.patch)"
+}()
+
 private func errorCodeFromFileSystemError(error: ErrorProtocol) -> Int {
     func fromCocoaErrorCode(code: Int) -> Int {
         switch code {
diff --git a/TestFoundation/TestNSURLSession.swift b/TestFoundation/TestNSURLSession.swift
@@ -194,6 +194,7 @@ class TestNSURLSession : XCTestCase {
             ("test_functional_serverClosingConnection", test_functional_serverClosingConnection),
             ("test_functional_delegate_GET_withRedirect", test_functional_delegate_GET_withRedirect),
             ("test_functional_completionHandler_GET", test_functional_completionHandler_GET),
+            ("test_functional_GET_compressedData", test_functional_GET_compressedData),
             ("test_functional_POST_fromData", test_functional_POST_fromData),
             ("test_functional_POST_fromFile", test_functional_POST_fromFile),
             ("test_functional_POST_fromFileThatDoesNotExist", test_functional_POST_fromFileThatDoesNotExist),
@@ -467,6 +468,57 @@ extension TestNSURLSession {
         }
     }
     
+    func test_functional_GET_compressedData() {
+        var baseURL: NSURL?
+        guard let (server, _baseURL) = createServer(handler: { request in
+            switch request.URI.path! {
+            case "/hello":
+                let bytes = ContiguousArray<UInt8>([0x1f, 0x8b, 0x08, 0x08, 0xa3, 0x7b, 0x05, 0x57,
+                                                    0x00, 0x03, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x74,
+                                                    0x78, 0x74, 0x00, 0xf3, 0x48, 0xcd, 0xc9, 0xc9,
+                                                    0x57, 0x08, 0x2e, 0xcf, 0x4c, 0x2b, 0x51, 0x04,
+                                                    0x00, 0xef, 0xc5, 0x65, 0x17, 0x0c, 0x00, 0x00,
+                                                    0x00])
+                let body = bytes.withUnsafeBufferPointer { return dispatch_data_create($0.baseAddress, $0.count, nil, nil) }
+                let fields = [("Content-Type", "text/plain"), ("Content-Encoding", "gzip")]
+                return HTTPResponse(statusCode: 200, additionalHeaderFields: fields, bodyData: body)
+            default:
+                XCTFail("Unexpected URI \(request.URI.absoluteString)")
+                return HTTPResponse(statusCode: 500, additionalHeaderFields: [], body: "")
+            }
+        }) else { XCTFail(); return }
+        baseURL = _baseURL
+        withExtendedLifetime(server) {
+            let delegate = TaskDelegate()
+            let sut = NSURLSession(configuration: NSURLSessionConfiguration.defaultSessionConfiguration(), delegate: delegate, delegateQueue: queue)
+            withExtendedLifetime(sut) {
+                let URL = NSURL(string: "/hello", relativeToURL: baseURL)!
+                
+                let completionExpectation = expectationWithDescription("Task did complete")
+                let task = sut.dataTaskWithURL(URL, completionHandler: {
+                    (data, response, error) in
+                    
+                    XCTAssertNil(error)
+                    if let d = data, let s = String(data: d, encoding: NSUTF8StringEncoding) {
+                        XCTAssertEqual(s, "Hello Swift!")
+                    } else {
+                        XCTFail()
+                    }
+                    guard let r = response as? NSHTTPURLResponse else { XCTFail(); return }
+                    XCTAssertEqual(r.URL?.absoluteString, URL.absoluteString)
+                    XCTAssertEqual(r.statusCode, 200)
+                    XCTAssertEqual(r.MIMEType, "text/plain")
+                    
+                    completionExpectation.fulfill()
+                })
+                
+                task.resume()
+                waitForExpectationsWithTimeout(1, handler: nil)
+            }
+        }
+    }
+
+    
     //MARK: Upload
     //
     // NSURLSessionUploadTask
@@ -649,11 +701,12 @@ extension TestNSURLSession {
             let port = Int(baseURL?.port ?? 0)
             let expected = ["Host": "\(baseURL?.host ?? ""):\(String(port))",
                             "Accept": "*/*",
-                            "Accept-Language": "en-us",
-                            "Accept-Encoding": "gzip, deflate",
+                            //"Accept-Language": "en",
+                            "Accept-Encoding": "deflate, gzip",
+                            "Connection": "keep-alive",
                             ]
             AssertHeaderFieldsEqual(headers, expected)
-            AssertHeaderFieldNamesEqual(headers, ["Host", "Accept", "Accept-Language", "Accept-Encoding", "Connection", "User-Agent"])
+            AssertHeaderFieldNamesEqual(headers, ["Host", "Accept", /*"Accept-Language",*/ "Accept-Encoding", "Connection", "User-Agent"])
         }) else { XCTFail(); return }
         baseURL = _baseURL
         with(server: server) { (session, delegate) in
@@ -669,19 +722,23 @@ extension TestNSURLSession {
             XCTAssertEqual(task.state, NSURLSessionTaskState.Completed)
         }
     }
+    
 }
 
 private extension HTTPResponse {
-    init(statusCode: Int, additionalHeaderFields: [(String, String)], body: String) {
+    init(statusCode: Int, additionalHeaderFields: [(String, String)], bodyData: dispatch_data_t) {
         var headerFields = additionalHeaderFields
         // This simple server does not support persistent connections.
         // C.f. RFC 2616 section 8.1.2.1
         headerFields.append(("Connection", "close"))
         // https://tools.ietf.org/html/rfc2616#section-14.13
-        let bodyData = dispatchData(body)
         headerFields.append(("Content-Length", String(dispatch_data_get_size(bodyData))))
         self.init(statusCode: statusCode, headerFields: headerFields, body: bodyData)
     }
+    init(statusCode: Int, additionalHeaderFields: [(String, String)], body: String) {
+        let bodyData = dispatchData(body)
+        self.init(statusCode: statusCode, additionalHeaderFields: additionalHeaderFields, bodyData: bodyData)
+    }
 }
 
 /// Encodes the string as UTF-8 into a dispatch_data_t without copying memory.
