Initial implementation of FTP protocol

Author: saiHemak

Foundation.xcodeproj/project.pbxproj

@@ -194,6 +194,7 @@ open class URLSession : NSObject {
     fileprivate static let registerProtocols: () = {
 	// TODO: We register all the native protocols here.
         let _ = URLProtocol.registerClass(_HTTPURLProtocol.self)
+        let _ = URLProtocol.registerClass(_FTPURLProtocol.self)
     }()
 
     /*

Foundation/NSURLSession/NSURLSession.swift

@@ -47,7 +47,7 @@ open class URLSessionConfiguration : NSObject, NSCopying {
         self.urlCredentialStorage = nil
         self.urlCache = nil
         self.shouldUseExtendedBackgroundIdleMode = false
-        self.protocolClasses = [_HTTPURLProtocol.self]
+        self.protocolClasses = [_HTTPURLProtocol.self,_FTPURLProtocol.self]
         super.init()
     }
 

Foundation/NSURLSession/NSURLSessionConfiguration.swift

@@ -0,0 +1,133 @@
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+
+import CoreFoundation
+import Dispatch
+
+internal class _FTPURLProtocol: _NativeProtocol {
+    
+    public required init(task: URLSessionTask, cachedResponse: CachedURLResponse?, client: URLProtocolClient?) {
+        super.init(task: task, cachedResponse: cachedResponse, client: client)
+    }
+    
+    public required init(request: URLRequest, cachedResponse: CachedURLResponse?, client: URLProtocolClient?) {
+        super.init(request: request, cachedResponse: cachedResponse, client: client)
+    }
+    
+    override class func canInit(with request: URLRequest) -> Bool {
+        guard request.url?.scheme == "ftp" || request.url?.scheme == "ftps" || request.url?.scheme == "sftp" else { return false }
+        return true
+    }
+    
+    override class func canonicalRequest(for request: URLRequest) -> URLRequest {
+        return request
+    }
+    
+    override func startLoading() {
+        resume()
+    }
+    
+    override func stopLoading() {
+        if task?.state == .suspended {
+            suspend()
+        } else {
+            self.internalState = .transferFailed
+            guard let error = self.task?.error else { fatalError() }
+            completeTask(withError: error)
+        }
+    }
+    
+    override  func didReceive(headerData data: Data) -> _EasyHandle._Action {
+        guard case .transferInProgress(let ts) = internalState else { fatalError("Received body data, but no transfer in progress.") }
+        do {
+            let newTS = try ts.byAppendingFTP(headerLine: data)
+            internalState = .transferInProgress(newTS)
+            let didCompleteHeader = !ts.isHeaderComplete && newTS.isHeaderComplete
+            if didCompleteHeader {
+                // The header is now complete, but wasn't before.
+                didReceiveResponse()
+            }
+            return .proceed
+        } catch {
+            return .abort
+        }
+    }
+    
+    override func seekInputStream(to position: UInt64) throws {
+        // NSUnimplemented()
+    }
+    
+    override  func updateProgressMeter(with propgress: _EasyHandle._Progress) {
+        //NSUnimplemented()
+    }
+    
+    override func configureEasyHandle(for request: URLRequest) {
+        easyHandle.set(verboseModeOn: enableLibcurlDebugOutput)
+        easyHandle.set(debugOutputOn: enableDebugOutput, task: task!)
+        easyHandle.set(skipAllSignalHandling: true)
+        
+        // Error Options:
+        //easyHandle.set(errorBuffer: nil)
+        guard let url = request.url else { fatalError("No URL in request.") }
+        easyHandle.set(url: url)
+        // easyHandle.set(upload: true)
+        //easyHandle.set(requestBodyLength: -1)
+        easyHandle.set(preferredReceiveBufferSize: Int.max)
+        
+        let timeoutHandler = DispatchWorkItem { [weak self] in
+            guard let _ = self?.task else { fatalError("Timeout on a task that doesn't exist") } //this guard must always pass
+            self?.internalState = .transferFailed
+            let urlError = URLError(_nsError: NSError(domain: NSURLErrorDomain, code: NSURLErrorTimedOut, userInfo: nil))
+            self?.completeTask(withError: urlError)
+            self?.client?.urlProtocol(self!, didFailWithError: urlError)
+        }
+        guard let task = self.task else { fatalError() }
+        easyHandle.timeoutTimer = _TimeoutSource(queue: task.workQueue, milliseconds: Int(request.timeoutInterval) * 1000, handler: timeoutHandler)
+        
+        easyHandle.set(automaticBodyDecompression: true)
+    }
+    
+}
+
+
+/// Response processing
+internal extension _FTPURLProtocol {
+    /// Whenever we receive a response (i.e. a complete header) from libcurl,
+    /// this method gets called.
+    func didReceiveResponse() {
+        guard let _ = task as? URLSessionDataTask else { return }
+        guard case .transferInProgress(let ts) = self.internalState else { fatalError("Transfer not in progress.") }
+        guard let response = ts.response else { fatalError("Header complete, but not URL response.") }
+        guard let session = task?.session as? URLSession else { fatalError() }
+        switch session.behaviour(for: self.task!) {
+        case .noDelegate:
+            break
+        case .taskDelegate(_):
+            //TODO: There's a problem with libcurl / with how we're using it.
+            // We're currently unable to pause the transfer / the easy handle:
+            // https://curl.haxx.se/mail/lib-2016-03/0222.html
+            //
+            // For now, we'll notify the delegate, but won't pause the transfer,
+            // and we'll disregard the completion handler:
+            
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            
+        case .dataCompletionHandler:
+            break
+        case .downloadCompletionHandler:
+            break
+        }
+    }
+    
+}
+
+
+
+
+

Foundation/NSURLSession/NativeProtocol.swift

@@ -40,15 +40,15 @@ internal func splitData(dispatchData data: DispatchData, atPosition position: In
 }
 
 /// A (non-blocking) source for HTTP body data.
-internal protocol _HTTPBodySource: class {
+internal protocol _BodySource: class {
     /// Get the next chunck of data.
     ///
     /// - Returns: `.data` until the source is exhausted, at which point it will
     /// return `.done`. Since this is non-blocking, it will return `.retryLater`
     /// if no data is available at this point, but will be available later.
-    func getNextChunk(withLength length: Int) -> _HTTPBodySourceDataChunk
+    func getNextChunk(withLength length: Int) -> _BodySourceDataChunk
 }
-internal enum _HTTPBodySourceDataChunk {
+internal enum _BodySourceDataChunk {
     case data(DispatchData)
     /// The source is depleted.
     case done
@@ -58,25 +58,25 @@ internal enum _HTTPBodySourceDataChunk {
 }
 
 /// A HTTP body data source backed by `dispatch_data_t`.
-internal final class _HTTPBodyDataSource {
-    var data: DispatchData! 
+internal final class _BodyDataSource {
+    var data: DispatchData!
     init(data: DispatchData) {
         self.data = data
     }
 }
 
-extension _HTTPBodyDataSource : _HTTPBodySource {
+extension _BodyDataSource : _BodySource {
     enum _Error : Error {
         case unableToRewindData
     }
-
-    func getNextChunk(withLength length: Int) -> _HTTPBodySourceDataChunk {
+    
+    func getNextChunk(withLength length: Int) -> _BodySourceDataChunk {
         let remaining = data.count
         if remaining == 0 {
             return .done
         } else if remaining <= length {
             let r: DispatchData! = data
-            data = DispatchData.empty 
+            data = DispatchData.empty
             return .data(r)
         } else {
             let (chunk, remainder) = splitData(dispatchData: data, atPosition: length)
@@ -98,10 +98,10 @@ extension _HTTPBodyDataSource : _HTTPBodySource {
 /// - Note: Calls to `getNextChunk(withLength:)` and callbacks from libdispatch
 /// should all happen on the same (serial) queue, and hence this code doesn't
 /// have to be thread safe.
-internal final class _HTTPBodyFileSource {
+internal final class _BodyFileSource {
     fileprivate let fileURL: URL
-    fileprivate let channel: DispatchIO 
-    fileprivate let workQueue: DispatchQueue 
+    fileprivate let channel: DispatchIO
+    fileprivate let workQueue: DispatchQueue
     fileprivate let dataAvailableHandler: () -> Void
     fileprivate var hasActiveReadHandler = false
     fileprivate var availableChunk: _Chunk = .empty
@@ -127,13 +127,14 @@ internal final class _HTTPBodyFileSource {
         }
         guard let channel = DispatchIO(type: .stream, path: fileSystemRepresentation,
                                        oflag: O_RDONLY, mode: 0, queue: workQueue,
-                                       cleanupHandler: {_ in }) else {
-            fatalError("Cant create DispatchIO channel")
+                                       cleanupHandler: {_ in })
+            else {
+                fatalError("Cant create DispatchIO channel")
         }
         self.channel = channel
         self.channel.setLimit(highWater: CFURLSessionMaxWriteSize)
     }
-
+    
     fileprivate enum _Chunk {
         /// Nothing has been read, yet
         case empty
@@ -146,7 +147,7 @@ internal final class _HTTPBodyFileSource {
     }
 }
 
-fileprivate extension _HTTPBodyFileSource {
+fileprivate extension _BodyFileSource {
     fileprivate var desiredBufferLength: Int { return 3 * CFURLSessionMaxWriteSize }
     /// Enqueue a dispatch I/O read to fill the buffer.
     ///
@@ -182,7 +183,7 @@ fileprivate extension _HTTPBodyFileSource {
             }
         }
     }
-
+    
     fileprivate func append(data: DispatchData, endOfFile: Bool) {
         switch availableChunk {
         case .empty:
@@ -196,7 +197,7 @@ fileprivate extension _HTTPBodyFileSource {
             fatalError("Trying to append data, but end-of-file was already detected.")
         }
     }
-
+    
     fileprivate var availableByteCount: Int {
         switch availableChunk {
         case .empty: return 0
@@ -208,8 +209,8 @@ fileprivate extension _HTTPBodyFileSource {
     }
 }
 
-extension _HTTPBodyFileSource : _HTTPBodySource {
-    func getNextChunk(withLength length: Int) -> _HTTPBodySourceDataChunk {    
+extension _BodyFileSource : _BodySource {
+    func getNextChunk(withLength length: Int) -> _BodySourceDataChunk {
         switch availableChunk {
         case .empty:
             readNextChunk()
@@ -242,3 +243,4 @@ extension _HTTPBodyFileSource : _HTTPBodySource {
         }
     }
 }
+

Foundation/NSURLSession/ftp/FTPURLProtocol.swift

@@ -20,82 +20,6 @@
 import CoreFoundation
 
 
-extension _HTTPURLProtocol {
-    /// An HTTP header being parsed.
-    ///
-    /// It can either be complete (i.e. the final CR LF CR LF has been
-    /// received), or partial.
-    internal enum _ParsedResponseHeader {
-        case partial(_ResponseHeaderLines)
-        case complete(_ResponseHeaderLines)
-        init() {
-            self = .partial(_ResponseHeaderLines())
-        }
-    }
-    /// A type safe wrapper around multiple lines of headers.
-    ///
-    /// This can be converted into an `NSHTTPURLResponse`.
-    internal struct _ResponseHeaderLines {
-        let lines: [String]
-        init() {
-            self.lines = []
-        }
-        init(headerLines: [String]) {
-            self.lines = headerLines
-        }
-    }
-}
-
-extension _HTTPURLProtocol._ParsedResponseHeader {
-    /// Parse a header line passed by libcurl.
-    ///
-    /// These contain the <CRLF> ending and the final line contains nothing but
-    /// that ending.
-    /// - Returns: Returning nil indicates failure. Otherwise returns a new
-    ///     `ParsedResponseHeader` with the given line added.
-    func byAppending(headerLine data: Data) -> _HTTPURLProtocol._ParsedResponseHeader? {
-        // The buffer must end in CRLF
-        guard
-            2 <= data.count &&
-                data[data.endIndex - 2] == _HTTPCharacters.CR &&
-                data[data.endIndex - 1] == _HTTPCharacters.LF
-            else { return nil }
-        let lineBuffer = data.subdata(in: Range(data.startIndex..<data.endIndex-2))
-        guard let line = String(data: lineBuffer, encoding: String.Encoding.utf8) else { return nil}
-        return byAppending(headerLine: line)
-    }
-    /// Append a status line.
-    ///
-    /// If the line is empty, it marks the end of the header, and the result
-    /// is a complete header. Otherwise it's a partial header.
-    /// - Note: Appending a line to a complete header results in a partial
-    ///     header with just that line.
-    private func byAppending(headerLine line: String) -> _HTTPURLProtocol._ParsedResponseHeader {
-        if line.isEmpty {
-            switch self {
-            case .partial(let header): return .complete(header)
-            case .complete: return .partial(_HTTPURLProtocol._ResponseHeaderLines())
-            }
-        } else {
-            let header = partialResponseHeader
-            return .partial(header.byAppending(headerLine: line))
-        }
-    }
-    private var partialResponseHeader: _HTTPURLProtocol._ResponseHeaderLines {
-        switch self {
-        case .partial(let header): return header
-        case .complete: return _HTTPURLProtocol._ResponseHeaderLines()
-        }
-    }
-}
-private extension _HTTPURLProtocol._ResponseHeaderLines {
-    /// Returns a copy of the lines with the new line appended to it.
-    func byAppending(headerLine line: String) -> _HTTPURLProtocol._ResponseHeaderLines {
-        var l = self.lines
-        l.append(line)
-        return _HTTPURLProtocol._ResponseHeaderLines(headerLines: l)
-    }
-}
 internal extension _HTTPURLProtocol._ResponseHeaderLines {
     /// Create an `NSHTTPRULResponse` from the lines.
     ///
@@ -230,10 +154,10 @@ private extension String {
         let methodRange = scalars.startIndex..<firstSpace.lowerBound
         let uriRange = remainder.startIndex..<secondSpace.lowerBound
         let versionRange = secondSpace.upperBound..<remainder.endIndex
-      
-        //TODO: is this necessary? If yes, this guard needs an alternate implementation 
-        //guard 0 < methodRange.count && 0 < uriRange.count && 0 < versionRange.count else { return nil } 
-
+        
+        //TODO: is this necessary? If yes, this guard needs an alternate implementation
+        //guard 0 < methodRange.count && 0 < uriRange.count && 0 < versionRange.count else { return nil }
+        
         let m = String(scalars[methodRange])
         let u = String(remainder[uriRange])
         let v = String(remainder[versionRange])
@@ -249,7 +173,7 @@ private extension String {
 ///
 /// - SeeAlso: `_HTTPURLProtocol.HTTPMessage.Header.createOne(from:)`
 private func createHeaders(from lines: ArraySlice<String>) -> [_HTTPURLProtocol._HTTPMessage._Header]? {
-
+    
     var headerLines = Array(lines)
     var headers: [_HTTPURLProtocol._HTTPMessage._Header] = []
     while !headerLines.isEmpty {
@@ -367,3 +291,5 @@ private extension UnicodeScalar {
         return !_HTTPCharacters.Separators.characterIsMember(UInt16(self.value))
     }
 }
+
+