(Swift) Transfer a File using Sockets (TLS or non-TLS)

Demonstrates how to two programs, one a socket writer and the other a socket reader, can transfer a file. The connection can be TLS or a regular non-encrypted TCP connection.

Note: This example requires Chilkat v11.0.0 or greater.

Chilkat Downloads for the Swift Programming Language MAC OS X (Cocoa) Objective-C/Swift Libs iOS Objective-C/Swift Libs

func chilkatTest() {
    var success: Bool = false

    // This example requires the Chilkat API to have been previously unlocked.
    // See Global Unlock Sample for sample code.

    // On the sending side, we'll load the file into a BinData object and send.
    // On the receiving side, we'll read from the socket connection into a BinData, and save to a file.
    // This example assumes the file is not crazy-large, and that the entire contents
    // can fit into memory.  
    // (If the file is too large for memory, there are other ways to send. It just involves streaming or 
    // sending the file chunk-by-chunk..)

    // This section of code is for the sender.
    let bdToSend = CkoBinData()!
    success = bdToSend.loadFile("somePath/someFile.dat")
    // Assume success for the example...

    let sndSock = CkoSocket()!
    var bUseTls: Bool = true
    var port: Int = 5555
    var maxWaitMs: Int = 5000
    success = sndSock.connect("some_domain_or_ip.com", port: port, ssl: bUseTls, maxWaitMs: maxWaitMs)
    // Assume success for the example...

    // Tell the receiver how many bytes are coming.
    var numBytes: Int = bdToSend.numBytes.intValue
    var bBigEndian: Bool = true
    success = sndSock.sendInt32(numBytes, bigEndian: bBigEndian)

    // Send the file data (sends the entire contents of bdToSend).
    success = sndSock.sendBd(bdToSend, offset: 0, numBytes: 0)

    // Get an acknowledgement.
    success = sndSock.receiveInt32(bBigEndian)
    if success == false {
        print("\(sndSock.lastErrorText!)")
        return
    }

    // Did the receiver get the correct number of bytes?
    if sndSock.receivedInt.intValue != numBytes {
        print("The receiver did not acknowledge with the correct number of bytes.")
        return
    }

    print("File sent!")

    // ------------------------------------------------------------------------------------
    // The code below is for the receiving side (running on some other computer..)

    let listenSock = CkoSocket()!

    success = listenSock.bindAndListen(5555, backlog: 25)
    if success == false {
        print("\(listenSock.lastErrorText!)")
        return
    }

    // Get the next incoming connection
    // Wait a maximum of 20 seconds (20000 millisec)
    let rcvSock = CkoSocket()!
    success = listenSock.acceptNext(20000, socket: rcvSock)
    if success == false {
        print("\(listenSock.lastErrorText!)")
        return
    }

    // The sender will first send the big-endian integer for the number of bytes
    // that are forthcoming..
    success = rcvSock.receiveInt32(bBigEndian)
    if success != true {
        print("\(rcvSock.lastErrorText!)")
        return
    }

    var numBytesComing: Int = rcvSock.receivedInt.intValue

    // Receive that many bytes..
    let bdReceived = CkoBinData()!
    success = rcvSock.receiveBdN(numBytesComing, binData: bdReceived)
    if success != true {
        print("\(rcvSock.lastErrorText!)")
        return
    }

    // Acknowledge the sender by sending back the number of bytes we received.
    success = rcvSock.sendInt32(bdReceived.numBytes.intValue, bigEndian: bBigEndian)

    // Close the connection.
    var maxWaitMs: Int = 20
    rcvSock.close(maxWaitMs)

    // Save the received data to a file.
    success = bdReceived.writeFile("somePath/someFile.dat")
    // Assume success for the example...

    print("File received!")

}