Amir Abbas Mousavian
f5c8f6308b
- closing streams after ftpQuit() executed. - added ability to add FTP Active Mode.
648 lines
25 KiB
Swift
648 lines
25 KiB
Swift
//
|
|
// FPSStreamTask.swift
|
|
// FileProvider
|
|
//
|
|
// Created by Amir Abbas Mousavian.
|
|
// Copyright © 2016 Mousavian. Distributed under MIT license.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
private var lasttaskIdAssociated = 1_000_000_000
|
|
|
|
|
|
/// This class is a replica of NSURLSessionStreamTask with same api for iOS 7/8
|
|
/// while it can actually fallback to NSURLSessionStreamTask in iOS 9.
|
|
public class FileProviderStreamTask: URLSessionTask, StreamDelegate {
|
|
fileprivate var inputStream: InputStream?
|
|
fileprivate var outputStream: OutputStream?
|
|
|
|
fileprivate var operation_queue: OperationQueue!
|
|
internal var _underlyingSession: URLSession
|
|
fileprivate var streamDelegate: FPSStreamDelegate? {
|
|
return (_underlyingSession.delegate as? FPSStreamDelegate)
|
|
}
|
|
fileprivate var _taskIdentifier: Int
|
|
|
|
/// Force using `URLSessionStreamTask` for iOS 9 and later
|
|
public var useURLSession = true
|
|
@available(iOS 9.0, OSX 10.11, *)
|
|
fileprivate static var streamTasks = [Int: URLSessionStreamTask]()
|
|
|
|
@available(iOS 9.0, OSX 10.11, *)
|
|
internal var _underlyingTask: URLSessionStreamTask? {
|
|
return FileProviderStreamTask.streamTasks[_taskIdentifier]
|
|
}
|
|
|
|
/**
|
|
* An identifier uniquely identifies the task within a given session.
|
|
*
|
|
* This value is unique only within the context of a single session;
|
|
* tasks in other sessions may have the same `taskIdentifier` value.
|
|
*/
|
|
open override var taskIdentifier: Int {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
return _underlyingTask!.taskIdentifier
|
|
}
|
|
}
|
|
|
|
return _taskIdentifier
|
|
}
|
|
|
|
fileprivate var _state: URLSessionTask.State = .suspended
|
|
/**
|
|
* The current state of the task—active, suspended, in the process
|
|
* of being canceled, or completed.
|
|
*/
|
|
override open var state: URLSessionTask.State {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
return _underlyingTask!.state
|
|
}
|
|
}
|
|
|
|
return _state
|
|
}
|
|
|
|
/**
|
|
* The original request object passed when the task was created.
|
|
* This value is typically the same as the currently active request (`currentRequest`)
|
|
* except when the server has responded to the initial request with a redirect to a different URL.
|
|
*/
|
|
override open var originalRequest: URLRequest? {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
return _underlyingTask!.originalRequest
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
/**
|
|
* The URL request object currently being handled by the task.
|
|
* This value is typically the same as the initial request (`originalRequest`)
|
|
* except when the server has responded to the initial request with a redirect to a different URL.
|
|
*/
|
|
override open var currentRequest: URLRequest? {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
return _underlyingTask!.currentRequest
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
fileprivate var _countOfBytesSent: Int64 = 0
|
|
fileprivate var _countOfBytesRecieved: Int64 = 0
|
|
|
|
/**
|
|
* The number of bytes that the task has sent to the server in the request body.
|
|
*
|
|
* This byte count includes only the length of the request body itself, not the request headers.
|
|
*
|
|
* To be notified when this value changes, implement the
|
|
* `urlSession(_:task:didSendBodyData:totalBytesSent:totalBytesExpectedToSend:)` delegate method.
|
|
*/
|
|
override open var countOfBytesSent: Int64 {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
return _underlyingTask!.countOfBytesSent
|
|
}
|
|
}
|
|
|
|
return _countOfBytesSent
|
|
}
|
|
|
|
/**
|
|
* The number of bytes that the task has received from the server in the response body.
|
|
*
|
|
* To be notified when this value changes, implement the `urlSession(_:dataTask:didReceive:)` delegate method (for data and upload tasks)
|
|
* or the `urlSession(_:downloadTask:didWriteData:totalBytesWritten:totalBytesExpectedToWrite:)` method (for download tasks).
|
|
*/
|
|
override open var countOfBytesReceived: Int64 {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
return _underlyingTask!.countOfBytesReceived
|
|
}
|
|
}
|
|
|
|
return _countOfBytesRecieved
|
|
}
|
|
|
|
/**
|
|
* The number of bytes that the task expects to send in the request body.
|
|
*
|
|
* The `URL` loading system can determine the length of the upload data in three ways:
|
|
* - From the length of the `NSData` object provided as the upload body.
|
|
* - From the length of the file on disk provided as the upload body of an upload task (not a download task).
|
|
* - From the `Content-Length` in the request object, if you explicitly set it.
|
|
*
|
|
* Otherwise, the value is `NSURLSessionTransferSizeUnknown` (`-1`) if you provided a stream or body data object, or zero (`0`) if you did not.
|
|
*/
|
|
override open var countOfBytesExpectedToSend: Int64 {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
return _underlyingTask!.countOfBytesExpectedToSend
|
|
} else {
|
|
return Int64(dataToBeSent.count)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The number of bytes that the task expects to receive in the response body.
|
|
*
|
|
* This value is determined based on the `Content-Length` header received from the server.
|
|
* If that header is absent, the value is `NSURLSessionTransferSizeUnknown`.
|
|
*/
|
|
override open var countOfBytesExpectedToReceive: Int64 {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
return _underlyingTask!.countOfBytesExpectedToReceive
|
|
}
|
|
}
|
|
|
|
return Int64(dataReceived.count)
|
|
}
|
|
|
|
override public init() {
|
|
fatalError("Use NSURLSession.fpstreamTask() method")
|
|
}
|
|
|
|
fileprivate var host: (hostname: String, port: Int)?
|
|
fileprivate var service: NetService?
|
|
|
|
internal init(session: URLSession, host: String, port: Int) {
|
|
self._underlyingSession = session
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
let task = session.streamTask(withHostName: host, port: port)
|
|
self._taskIdentifier = task.taskIdentifier
|
|
FileProviderStreamTask.streamTasks[_taskIdentifier] = task
|
|
return
|
|
}
|
|
}
|
|
|
|
lasttaskIdAssociated += 1
|
|
self._taskIdentifier = lasttaskIdAssociated
|
|
self.host = (host, port)
|
|
self.operation_queue = OperationQueue()
|
|
self.operation_queue.name = "FileProviderStreamTask"
|
|
self.operation_queue.maxConcurrentOperationCount = 1
|
|
}
|
|
|
|
internal init(session: URLSession, netService: NetService) {
|
|
self._underlyingSession = session
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
let task = session.streamTask(with: netService)
|
|
self._taskIdentifier = task.taskIdentifier
|
|
FileProviderStreamTask.streamTasks[_taskIdentifier] = task
|
|
return
|
|
}
|
|
}
|
|
|
|
lasttaskIdAssociated += 1
|
|
self._taskIdentifier = lasttaskIdAssociated
|
|
self.service = netService
|
|
self.operation_queue = OperationQueue()
|
|
self.operation_queue.name = "FileProviderStreamTask"
|
|
self.operation_queue.maxConcurrentOperationCount = 1
|
|
}
|
|
|
|
/**
|
|
* Cancels the task.
|
|
*
|
|
* This method returns immediately, marking the task as being canceled. Once a task is marked as being canceled,
|
|
* `urlSession(_:task:didCompleteWithError:)` will be sent to the task delegate, passing an error
|
|
* in the domain NSURLErrorDomain with the code `NSURLErrorCancelled`. A task may, under some circumstances,
|
|
* send messages to its delegate before the cancelation is acknowledged.
|
|
*
|
|
* This method may be called on a task that is suspended.
|
|
*/
|
|
override open func cancel() {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.cancel()
|
|
return
|
|
}
|
|
}
|
|
|
|
self._state = .canceling
|
|
inputStream?.setValue(kCFBooleanTrue, forKey: kCFStreamPropertyShouldCloseNativeSocket as String)
|
|
outputStream?.setValue(kCFBooleanTrue, forKey: kCFStreamPropertyShouldCloseNativeSocket as String)
|
|
|
|
self.inputStream?.close()
|
|
self.outputStream?.close()
|
|
|
|
self.inputStream?.remove(from: RunLoop.main, forMode: .defaultRunLoopMode)
|
|
self.outputStream?.remove(from: RunLoop.main, forMode: .defaultRunLoopMode)
|
|
|
|
self.inputStream?.delegate = nil
|
|
self.outputStream?.delegate = nil
|
|
|
|
self.inputStream = nil
|
|
self.outputStream = nil
|
|
|
|
self._state = .completed
|
|
self._countOfBytesSent = 0
|
|
self._countOfBytesRecieved = 0
|
|
}
|
|
|
|
var _error: Error? = nil
|
|
|
|
/**
|
|
* An error object that indicates why the task failed.
|
|
*
|
|
* This value is `NULL` if the task is still active or if the transfer completed successfully.
|
|
*/
|
|
override open var error: Error? {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if useURLSession {
|
|
return _underlyingTask!.error
|
|
}
|
|
}
|
|
|
|
return _error
|
|
}
|
|
|
|
/**
|
|
* Temporarily suspends a task.
|
|
*
|
|
* A task, while suspended, produces no network traffic and is not subject to timeouts.
|
|
* A download task can continue transferring data at a later time.
|
|
* All other tasks must start over when resumed.
|
|
*/
|
|
override open func suspend() {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.suspend()
|
|
return
|
|
}
|
|
}
|
|
|
|
self._state = .suspended
|
|
self.operation_queue.isSuspended = true
|
|
}
|
|
|
|
// Resumes the task, if it is suspended.
|
|
override open func resume() {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.resume()
|
|
return
|
|
}
|
|
}
|
|
|
|
var readStream : Unmanaged<CFReadStream>?
|
|
var writeStream : Unmanaged<CFWriteStream>?
|
|
|
|
if inputStream == nil || outputStream == nil {
|
|
if let host = host {
|
|
CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, host.hostname as CFString, UInt32(host.port), &readStream, &writeStream)
|
|
} else if let service = service {
|
|
let cfnetService = CFNetServiceCreate(kCFAllocatorDefault, service.domain as CFString, service.type as CFString, service.name as CFString, Int32(service.port))
|
|
CFStreamCreatePairWithSocketToNetService(kCFAllocatorDefault, cfnetService.takeRetainedValue(), &readStream, &writeStream)
|
|
}
|
|
|
|
inputStream = readStream?.takeRetainedValue()
|
|
outputStream = writeStream?.takeRetainedValue()
|
|
guard let inputStream = inputStream, let outputStream = outputStream else {
|
|
return
|
|
}
|
|
streamDelegate?.urlSession?(self._underlyingSession, streamTask: self, didBecome: inputStream, outputStream: outputStream)
|
|
}
|
|
|
|
guard let inputStream = inputStream, let outputStream = outputStream else {
|
|
return
|
|
}
|
|
|
|
inputStream.delegate = self
|
|
outputStream.delegate = self
|
|
|
|
operation_queue.addOperation {
|
|
inputStream.schedule(in: RunLoop.main, forMode: .defaultRunLoopMode)
|
|
outputStream.schedule(in: RunLoop.main, forMode: .defaultRunLoopMode)
|
|
}
|
|
|
|
inputStream.open()
|
|
outputStream.open()
|
|
|
|
operation_queue.isSuspended = false
|
|
_state = .running
|
|
}
|
|
|
|
fileprivate var dataToBeSent: Data = Data()
|
|
fileprivate var dataReceived: Data = Data()
|
|
|
|
/**
|
|
* Asynchronously reads a number of bytes from the stream, and calls a handler upon completion.
|
|
*
|
|
* - Parameter minBytes: The minimum number of bytes to read.
|
|
* - ParametermaxBytes: The maximum number of bytes to read.
|
|
* - Parameter timeout: A timeout for reading bytes. If the read is not completed within the specified interval,
|
|
* the read is canceled and the completionHandler is called with an error. Pass `0` to prevent a read from timing out.
|
|
* - Parameter completionHandler: The completion handler to call when all bytes are read, or an error occurs.
|
|
* This handler is executed on the delegate queue. This completion handler takes the following parameters:
|
|
* - data: The data read from the stream.
|
|
* - atEOF: Whether or not the stream reached end-of-file (`EOF`), such that no more data can be read.
|
|
* - error: An error object that indicates why the read failed, or `nil` if the read was successful.
|
|
*/
|
|
open func readData(ofMinLength minBytes: Int, maxLength maxBytes: Int, timeout: TimeInterval, completionHandler: @escaping (_ data: Data?, _ atEOF: Bool, _ error :Error?) -> Void) {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.readData(ofMinLength: minBytes, maxLength: maxBytes, timeout: timeout, completionHandler: completionHandler)
|
|
return
|
|
}
|
|
}
|
|
|
|
guard let inputStream = inputStream else {
|
|
return
|
|
}
|
|
|
|
let expireDate = Date(timeIntervalSinceNow: timeout)
|
|
operation_queue.addOperation {
|
|
var timedOut: Bool = false
|
|
while (self.dataReceived.count == 0 || self.dataReceived.count < minBytes) && !timedOut {
|
|
Thread.sleep(forTimeInterval: 0.1)
|
|
timedOut = expireDate < Date()
|
|
}
|
|
var dR: Data?
|
|
if self.dataReceived.count > maxBytes {
|
|
let range: Range = 0..<maxBytes
|
|
dR = self.dataReceived.subdata(in: range)
|
|
self.dataReceived.replaceSubrange(range, with: Data())
|
|
} else {
|
|
if self.dataReceived.count > 0 {
|
|
dR = self.dataReceived
|
|
self.dataReceived.count = 0
|
|
}
|
|
}
|
|
let isEOF = inputStream.streamStatus == .atEnd && self.dataReceived.count == 0
|
|
completionHandler(dR, isEOF, dR == nil ? inputStream.streamError : nil)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Asynchronously writes the specified data to the stream, and calls a handler upon completion.
|
|
*
|
|
* There is no guarantee that the remote side of the stream has received all of the written bytes
|
|
* at the time that `completionHandler` is called, only that all of the data has been written to the kernel.
|
|
*
|
|
* - Parameter data: The data to be written.
|
|
* - Parameter timeout: A timeout for writing bytes. If the write is not completed within the specified interval,
|
|
* the write is canceled and the `completionHandler` is called with an error.
|
|
* Pass `0` to prevent a write from timing out.
|
|
* - Parameter completionHandler: The completion handler to call when all bytes are written, or an error occurs.
|
|
* This handler is executed on the delegate queue.
|
|
* This completion handler takes the following parameter:
|
|
* - error: An error object that indicates why the write failed, or nil if the write was successful.
|
|
*/
|
|
open func write(_ data: Data, timeout: TimeInterval, completionHandler: @escaping (_ error: Error?) -> Void) {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.write(data, timeout: timeout, completionHandler: completionHandler)
|
|
return
|
|
}
|
|
}
|
|
|
|
guard outputStream != nil else {
|
|
return
|
|
}
|
|
|
|
|
|
operation_queue.addOperation {
|
|
self.dataToBeSent.append(data)
|
|
let result = self.write(timeout: timeout, close: false)
|
|
if result < 0 {
|
|
let error = self.outputStream?.streamError ?? NSError(domain: URLError.errorDomain, code: URLError.cannotWriteToFile.rawValue, userInfo: nil)
|
|
completionHandler(error)
|
|
} else {
|
|
completionHandler(nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Completes any already enqueued reads and writes, and then invokes the
|
|
* `urlSession(_:streamTask:didBecome:outputStream:)` delegate message.
|
|
*/
|
|
open func captureStreams() {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.captureStreams()
|
|
return
|
|
}
|
|
}
|
|
|
|
guard let outputStream = outputStream, let inputStream = inputStream else {
|
|
return
|
|
}
|
|
self.operation_queue.addOperation {
|
|
_=self.write(close: false)
|
|
while inputStream.streamStatus != .atEnd || outputStream.streamStatus == .writing {
|
|
Thread.sleep(forTimeInterval: 0.1)
|
|
}
|
|
self.streamDelegate?.urlSession?(self._underlyingSession, streamTask: self, didBecome: inputStream, outputStream: outputStream)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Completes any enqueued reads and writes, and then closes the write side of the underlying socket.
|
|
*
|
|
* You may continue to read data using the `readData(ofMinLength:maxLength:timeout:completionHandler:)`
|
|
* method after calling this method. Any calls to `write(_:timeout:completionHandler:)` after calling
|
|
* this method will result in an error.
|
|
*
|
|
* Because the server may continue to write bytes to the client, it is recommended that
|
|
* you continue reading until the stream reaches end-of-file (EOF).
|
|
*/
|
|
open func closeWrite() {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.closeWrite()
|
|
return
|
|
}
|
|
}
|
|
|
|
operation_queue.addOperation {
|
|
_ = self.write(close: true)
|
|
}
|
|
}
|
|
|
|
fileprivate func write(timeout: TimeInterval = 0, close: Bool) -> Int {
|
|
guard let outputStream = outputStream else {
|
|
return -1
|
|
}
|
|
|
|
var byteSent: Int = 0
|
|
let expireDate = Date(timeIntervalSinceNow: timeout)
|
|
while self.dataToBeSent.count > 0 && (timeout == 0 || expireDate > Date()) {
|
|
let bytesWritten = self.dataToBeSent.withUnsafeBytes {
|
|
outputStream.write($0, maxLength: self.dataToBeSent.count)
|
|
}
|
|
|
|
if bytesWritten > 0 {
|
|
let range = 0..<bytesWritten
|
|
self.dataToBeSent.replaceSubrange(range, with: Data())
|
|
byteSent += bytesWritten
|
|
} else if bytesWritten < 0 {
|
|
self._error = outputStream.streamError
|
|
return bytesWritten
|
|
}
|
|
if self.dataToBeSent.count == 0 {
|
|
break
|
|
}
|
|
}
|
|
self._countOfBytesSent += Int64(byteSent)
|
|
if close {
|
|
outputStream.close()
|
|
self.streamDelegate?.urlSession?(self._underlyingSession, writeClosedFor: self)
|
|
}
|
|
return byteSent
|
|
}
|
|
|
|
/**
|
|
* Completes any enqueued reads and writes, and then closes the read side of the underlying socket.
|
|
*
|
|
* You may continue to write data using the `write(_:timeout:completionHandler:)` method after
|
|
* calling this method. Any calls to `readData(ofMinLength:maxLength:timeout:completionHandler:)`
|
|
* after calling this method will result in an error.
|
|
*/
|
|
open func closeRead() {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.closeRead()
|
|
return
|
|
}
|
|
}
|
|
|
|
guard let inputStream = inputStream else {
|
|
return
|
|
}
|
|
operation_queue.addOperation {
|
|
while inputStream.streamStatus != .atEnd {
|
|
Thread.sleep(forTimeInterval: 0.1)
|
|
}
|
|
inputStream.close()
|
|
self.streamDelegate?.urlSession?(self._underlyingSession, readClosedFor: self)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Completes any enqueued reads and writes, and establishes a secure connection.
|
|
*
|
|
* Authentication callbacks are sent to the session's delegate using the
|
|
* `urlSession(_:task:didReceive:completionHandler:)` method.
|
|
*/
|
|
open func startSecureConnection() {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.startSecureConnection()
|
|
return
|
|
}
|
|
}
|
|
|
|
operation_queue.addOperation {
|
|
self.inputStream!.setProperty(StreamSocketSecurityLevel.negotiatedSSL.rawValue, forKey: .socketSecurityLevelKey)
|
|
self.outputStream!.setProperty(StreamSocketSecurityLevel.negotiatedSSL.rawValue, forKey: .socketSecurityLevelKey)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Completes any enqueued reads and writes, and closes the secure connection.
|
|
*/
|
|
open func stopSecureConnection() {
|
|
if #available(iOS 9.0, OSX 10.11, *) {
|
|
if self.useURLSession {
|
|
_underlyingTask!.stopSecureConnection()
|
|
return
|
|
}
|
|
}
|
|
operation_queue.addOperation {
|
|
self.inputStream!.setProperty(StreamSocketSecurityLevel.none.rawValue, forKey: .socketSecurityLevelKey)
|
|
self.outputStream!.setProperty(StreamSocketSecurityLevel.none.rawValue, forKey: .socketSecurityLevelKey)
|
|
}
|
|
}
|
|
|
|
open func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
|
|
if eventCode.contains(.errorOccurred) {
|
|
self._error = aStream.streamError
|
|
streamDelegate?.urlSession?(_underlyingSession, task: self, didCompleteWithError: error)
|
|
}
|
|
|
|
if aStream == inputStream && eventCode.contains(.hasBytesAvailable) {
|
|
while (inputStream!.hasBytesAvailable) {
|
|
var buffer = [UInt8](repeating: 0, count: 2048)
|
|
let len = inputStream!.read(&buffer, maxLength: buffer.count)
|
|
if len > 0 {
|
|
dataReceived.append(&buffer, count: len)
|
|
self._countOfBytesRecieved += Int64(len)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public extension URLSession {
|
|
/// Creates a bidirectional stream task to a given host and port.
|
|
func fpstreamTask(withHostName hostname: String, port: Int) -> FileProviderStreamTask {
|
|
return FileProviderStreamTask(session: self, host: hostname, port: port)
|
|
}
|
|
|
|
/**
|
|
* Creates a bidirectional stream task with an NSNetService to identify the endpoint.
|
|
* The NSNetService will be resolved before any IO completes.
|
|
*/
|
|
func fpstreamTask(withNetService service: NetService) -> FileProviderStreamTask {
|
|
return FileProviderStreamTask(session: self, netService: service)
|
|
}
|
|
}
|
|
|
|
@objc
|
|
internal protocol FPSStreamDelegate : URLSessionTaskDelegate {
|
|
|
|
|
|
/**
|
|
* Indiciates that the read side of a connection has been closed. Any
|
|
* outstanding reads complete, but future reads will immediately fail.
|
|
* This may be sent even when no reads are in progress. However, when
|
|
* this delegate message is received, there may still be bytes
|
|
* available. You only know that no more bytes are available when you
|
|
* are able to read until EOF. */
|
|
@objc optional func urlSession(_ session: URLSession, readClosedFor streamTask: FileProviderStreamTask)
|
|
|
|
|
|
/**
|
|
* Indiciates that the write side of a connection has been closed.
|
|
* Any outstanding writes complete, but future writes will immediately
|
|
* fail.
|
|
*/
|
|
@objc optional func urlSession(_ session: URLSession, writeClosedFor streamTask: FileProviderStreamTask)
|
|
|
|
|
|
/**
|
|
* A notification that the system has determined that a better route
|
|
* to the host has been detected (eg, a wi-fi interface becoming
|
|
* available.) This is a hint to the delegate that it may be
|
|
* desirable to create a new task for subsequent work. Note that
|
|
* there is no guarantee that the future task will be able to connect
|
|
* to the host, so callers should should be prepared for failure of
|
|
* reads and writes over any new interface. */
|
|
@objc optional func urlSession(_ session: URLSession, betterRouteDiscoveredFor streamTask: FileProviderStreamTask)
|
|
|
|
|
|
/**
|
|
* The given task has been completed, and unopened NSInputStream and
|
|
* NSOutputStream objects are created from the underlying network
|
|
* connection. This will only be invoked after all enqueued IO has
|
|
* completed (including any necessary handshakes.) The streamTask
|
|
* will not receive any further delegate messages.
|
|
*/
|
|
@objc optional func urlSession(_ session: URLSession, streamTask: FileProviderStreamTask, didBecome inputStream: InputStream, outputStream: OutputStream)
|
|
}
|
|
|
|
private let ports: [String: Int] = ["http": 80, "https": 443, "smb": 445,"ftp": 21,
|
|
"telnet": 23, "pop": 110, "smtp": 25, "imap": 143]
|
|
private let securePorts: [String: Int] = ["ssh": 22, "https": 443, "smb": 445, "smtp": 465,
|
|
"ftps": 990,"telnet": 992, "imap": 993, "pop": 995]
|