FTPServer.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2019 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
//

#if !os(Windows)
//This is a very rudimentary FTP server written plainly for testing URLSession FTP Implementation.
import Dispatch

#if canImport(Glibc)
@preconcurrencyimport Glibc
#elseif canImport(Darwin)
import Darwin
#elseif canImport(Android)
@preconcurrencyimport Android
#endif

finalclassServerSemaphore:Sendable{
letdispatchSemaphore=DispatchSemaphore(value:0)

func wait(timeout:DispatchTime)->DispatchTimeoutResult{
return dispatchSemaphore.wait(timeout: timeout)
}

func signal(){
 dispatchSemaphore.signal()
}
}

class_FTPSocket{

privatevarlistenSocket:Int32!
privatevarsocketAddress= UnsafeMutablePointer<sockaddr_in>.allocate(capacity:1)
privatevarsocketAddress1= UnsafeMutablePointer<sockaddr_in>.allocate(capacity:1)
privatevarconnectionSocket:Int32!
vardataSocket:Int32! // data socket for communication
vardataSocketPort:UInt16! // data socket port, should be sent as part of header
privatefunc isNotMinusOne(r:CInt)->Bool{
return r !=-1
}

privatefunc isZero(r:CInt)->Bool{
return r ==0
}

privatefunc attempt(_ name:String, file:String= #file, line:UInt= #line, valid:(CInt)->Bool, _ b:@autoclosure()->CInt)throws->CInt{
letr=b()
guardvalid(r)else{throwServerError(operation: name, errno: r, file: file, line: line)}
return r
}

init(port:UInt16)throws{
#if os(Linux)
letSOCKSTREAM=Int32(SOCK_STREAM.rawValue)
#else
letSOCKSTREAM= SOCK_STREAM
#endif
 listenSocket =tryattempt("socket", valid: isNotMinusOne,socket(AF_INET, SOCKSTREAM,Int32(IPPROTO_TCP)))
varon:Int=1
 _ =tryattempt("setsockopt", valid: isZero,setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR,&on,socklen_t(MemoryLayout<Int>.size)))
letsa=createSockaddr(port)
 socketAddress.initialize(to: sa)
try socketAddress.withMemoryRebound(to: sockaddr.self, capacity: MemoryLayout<sockaddr>.size,{
letaddr=UnsafePointer<sockaddr>($0)
 _ =tryattempt("bind", valid: isZero,bind(listenSocket, addr,socklen_t(MemoryLayout<sockaddr>.size)))
})

 dataSocket =tryattempt("socket", valid: isNotMinusOne,
socket(AF_INET, SOCKSTREAM,Int32(IPPROTO_TCP)))
varon1:Int=1
 _ =tryattempt("setsockopt", valid: isZero,
setsockopt(dataSocket, SOL_SOCKET, SO_REUSEADDR,&on1,socklen_t(MemoryLayout<Int>.size)))
letsa1=createSockaddr(port+1)
 socketAddress1.initialize(to: sa1)
try socketAddress1.withMemoryRebound(to: sockaddr.self, capacity: MemoryLayout<sockaddr>.size,{
nonisolated(unsafe)letaddr=UnsafeMutablePointer<sockaddr>($0)
 _ =tryattempt("bind", valid: isZero,bind(dataSocket, addr,socklen_t(MemoryLayout<sockaddr>.size)))
 _ =tryattempt("listen", valid: isZero,listen(dataSocket, SOMAXCONN))
 // Open the data port asynchronously. Port should be opened before ESPV header communication.
nonisolated(unsafe)letnonisolatedSelf=self
DispatchQueue(label:"delay").async{
do{
varsockLen=socklen_t(MemoryLayout<sockaddr>.size)
 nonisolatedSelf.dataSocket =try nonisolatedSelf.attempt("accept", valid: nonisolatedSelf.isNotMinusOne,accept(nonisolatedSelf.dataSocket, addr,&sockLen))
 nonisolatedSelf.dataSocketPort = sa1.sin_port
}catch{
NSLog("Could not open data port.")
}
}
})
}

privatefunc createSockaddr(_ port:UInt16)->sockaddr_in{
 // Listen on the loopback address so that OSX doesnt pop up a dialog
 // asking to accept incoming connections if the firewall is enabled.
letaddr=UInt32(INADDR_LOOPBACK).bigEndian
letnetPort= port.bigEndian
#if os(Linux)
returnsockaddr_in(sin_family:sa_family_t(AF_INET), sin_port: netPort, sin_addr:in_addr(s_addr: addr), sin_zero:(0,0,0,0,0,0,0,0))
#elseif os(Android)
returnsockaddr_in(sin_family:sa_family_t(AF_INET), sin_port: netPort, sin_addr:in_addr(s_addr: addr), __pad:(0,0,0,0,0,0,0,0))
#else
returnsockaddr_in(sin_len:0, sin_family:sa_family_t(AF_INET), sin_port: netPort, sin_addr:in_addr(s_addr: addr), sin_zero:(0,0,0,0,0,0,0,0))
#endif
}

func acceptConnection(notify:ServerSemaphore)throws{
 _ =tryattempt("listen", valid: isZero,listen(listenSocket, SOMAXCONN))
try socketAddress.withMemoryRebound(to: sockaddr.self, capacity: MemoryLayout<sockaddr>.size,{
letaddr=UnsafeMutablePointer<sockaddr>($0)
varsockLen=socklen_t(MemoryLayout<sockaddr>.size)
 notify.signal()
 connectionSocket =tryattempt("accept", valid: isNotMinusOne,accept(listenSocket, addr,&sockLen))
})
}

func readData()throws->String{
varbuffer=[UInt8](repeating:0, count:4096)
 _ =tryattempt("read", valid: isNotMinusOne,CInt(read(connectionSocket,&buffer,4096)))
returnString(cString:&buffer)
}

func readDataOnDataSocket()throws->String{
varbuffer=[UInt8](repeating:0, count:4096)
 _ =tryattempt("read", valid: isNotMinusOne,CInt(read(dataSocket,&buffer,4096)))
returnString(cString:&buffer)
}

func writeRawData(_ data:Data)throws{
 _ =try data.withUnsafeBytes{(rawBuffer:UnsafeRawBufferPointer)in
letptr= rawBuffer.baseAddress
 _ =tryattempt("write", valid: isNotMinusOne,CInt(write(connectionSocket, ptr, data.count)))
}
}

func writeRawData(socket data:Data)throws->Int32{
varbytesWritten:Int32=0
 _ =try data.withUnsafeBytes{(rawBuffer:UnsafeRawBufferPointer)in
letptr= rawBuffer.baseAddress
 bytesWritten =tryattempt("write", valid: isNotMinusOne,CInt(write(dataSocket, ptr, data.count)))
}
return bytesWritten
}

func shutdown(){
close(connectionSocket)
close(listenSocket)
close(dataSocket)
}
}

class_FTPServer{

letsocket:_FTPSocket
letcommandPort:UInt16

init(port:UInt16)throws{
 commandPort = port
 socket =try_FTPSocket(port: port)
}

classfunc create(port:UInt16)throws->_FTPServer{
returntry_FTPServer(port: port)
}

func listen(notify:ServerSemaphore)throws{
try socket.acceptConnection(notify: notify)
}

func stop(){
 socket.shutdown()
}

 // parse header information and respond accordingly
func parseHeaderData()throws{
letsaveData="""
 FTP implementation to test FTP
 upload, download and data tasks. Instead of sending a file,
 we are sending the hardcoded data.We are going to test FTP
 data, download and upload tasks with delegates & completion handlers.
 Creating the data here as we need to pass the count
 as part of the header.\r\n
""".data(using:String.Encoding.utf8)

letdataCount= saveData?.count
letread=try socket.readData()
if read.contains("anonymous"){
tryrespondWithRawData(with:"331 Please specify the password.\r\n")
}elseif read.contains("PASS"){
tryrespondWithRawData(with:"230 Login successful.\r\n")
}elseif read.contains("PWD"){
tryrespondWithRawData(with:"257 \"/\"\r\n")
}elseif read.contains("EPSV"){
tryrespondWithRawData(with:"229 Entering Extended Passive Mode (|||\(commandPort+1)|).\r\n")
}elseif read.contains("TYPE I"){
tryrespondWithRawData(with:"200 Switching to Binary mode.\r\n")
}elseif read.contains("SIZE"){
tryrespondWithRawData(with:"213 \(dataCount!)\r\n")
}elseif read.contains("RETR"){
tryrespondWithRawData(with:"150 Opening BINARY mode data, connection for test.txt (\(dataCount!) bytes).\r\n")
 // Send data here through data port
do{
letdataWritten=tryrespondWithData(with: saveData!)
if dataWritten !=-1{
 // Send the end header on command port
tryrespondWithRawData(with:"226 Transfer complete.\r\n")
}
}catch{
NSLog("Transfer failed.")
}
}elseif read.contains("STOR"){
 // Request is for upload. As we are only dealing with data, just read the data and ignore
tryrespondWithRawData(with:"150 Ok to send data.\r\n")
 // Read data from the data socket and respond with completion header after the transfer
do{
 _ =tryreadDataOnDataSocket()
tryrespondWithRawData(with:"226 Transfer complete.\r\n")
}catch{
NSLog("Transfer failed.")
}
}
}

func respondWithRawData(with string:String)throws{
tryself.socket.writeRawData(string.data(using:String.Encoding.utf8)!)
}

func respondWithData(with data:Data)throws->Int32{
returntryself.socket.writeRawData(socket: data)
}
func readDataOnDataSocket()throws->String{
returntryself.socket.readDataOnDataSocket()
}
}

classTestFTPURLSessionServer{
letftpServer:_FTPServer

init(port:UInt16)throws{
 ftpServer =try _FTPServer.create(port: port)
}
func start(started:ServerSemaphore)throws{
 started.signal()
try ftpServer.listen(notify: started)
}
func parseHeaderAndRespond()throws{
try ftpServer.parseHeaderData()
}

func writeStartHeaderData()throws{
try ftpServer.respondWithRawData(with:"220 (vsFTPd 2.3.5)\r\n")
}

func stop(){
 ftpServer.stop()
}
}

classLoopbackFTPServerTest:XCTestCase{
nonisolated(unsafe)staticvarserverPort:Int=-1

overrideclassfunc setUp(){
 super.setUp()
@Sendablefunc runServer(with condition:ServerSemaphore,
 startDelay:TimeInterval?=nil,
 sendDelay:TimeInterval?=nil, bodyChunks:Int?=nil)throws{
letstart=21961 // 21961
forportin start...(start+100){ //we must find at least one port to bind
do{
 serverPort = port
lettest=tryTestFTPURLSessionServer(port:UInt16(port))
try test.start(started: condition)
try test.writeStartHeaderData() // Welcome message to start the transfer
for_in1...7{
try test.parseHeaderAndRespond()
}
 test.stop()
}catchlet err as ServerError{
if err.operation =="bind"{continue}
throw err
}
}
}

letserverReady=ServerSemaphore()
 globalDispatchQueue.async{
do{
tryrunServer(with: serverReady)
}catch{
XCTAssertTrue(true)
return
}
}
lettimeout=DispatchTime(uptimeNanoseconds:DispatchTime.now().uptimeNanoseconds +2_000_000_000)

 _ = serverReady.wait(timeout: timeout)
}
}
#endif