(Unicode C) 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.

Chilkat C/C++ Library Downloads
MS Visual C/C++ Linux/CentOS C/C++ Alpine Linux C/C++ MAC OS X C/C++	armhf/aarch64 C/C++ C++ Builder iOS C/C++ Android C/C++	Solaris C/C++ MinGW C/C++

#include <C_CkBinDataW.h>
#include <C_CkSocketW.h>

void ChilkatSample(void)
    {
    HCkBinDataW bdToSend;
    BOOL success;
    HCkSocketW sndSock;
    BOOL bUseTls;
    int port;
    int maxWaitMs;
    int numBytes;
    BOOL bBigEndian;
    HCkSocketW listenSock;
    HCkSocketW rcvSock;
    int numBytesComing;
    HCkBinDataW bdReceived;
    int maxWaitMs;

    // 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.
    bdToSend = CkBinDataW_Create();
    success = CkBinDataW_LoadFile(bdToSend,L"somePath/someFile.dat");
    // Assume success for the example...

    sndSock = CkSocketW_Create();
    bUseTls = TRUE;
    port = 5555;
    maxWaitMs = 5000;
    success = CkSocketW_Connect(sndSock,L"some_domain_or_ip.com",port,bUseTls,maxWaitMs);
    // Assume success for the example...

    // Tell the receiver how many bytes are coming.
    numBytes = CkBinDataW_getNumBytes(bdToSend);
    bBigEndian = TRUE;
    success = CkSocketW_SendInt32(sndSock,numBytes,bBigEndian);

    // Send the file data (sends the entire contents of bdToSend).
    success = CkSocketW_SendBd(sndSock,bdToSend,0,0);

    // Get an acknowledgement.
    success = CkSocketW_ReceiveInt32(sndSock,bBigEndian);
    if (success != TRUE) {
        wprintf(L"%s\n",CkSocketW_lastErrorText(sndSock));
        CkBinDataW_Dispose(bdToSend);
        CkSocketW_Dispose(sndSock);
        return;
    }

    // Did the receiver get the correct number of bytes?
    if (CkSocketW_getReceivedInt(sndSock) != numBytes) {
        wprintf(L"The receiver did not acknowledge with the correct number of bytes.\n");
        CkBinDataW_Dispose(bdToSend);
        CkSocketW_Dispose(sndSock);
        return;
    }

    wprintf(L"File sent!\n");

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

    listenSock = CkSocketW_Create();

    success = CkSocketW_BindAndListen(listenSock,5555,25);
    if (success != TRUE) {
        wprintf(L"%s\n",CkSocketW_lastErrorText(listenSock));
        CkBinDataW_Dispose(bdToSend);
        CkSocketW_Dispose(sndSock);
        CkSocketW_Dispose(listenSock);
        return;
    }

    // Get the next incoming connection
    // Wait a maximum of 20 seconds (20000 millisec)

    rcvSock = CkSocketW_AcceptNextConnection(listenSock,20000);
    if (CkSocketW_getLastMethodSuccess(listenSock) == FALSE) {
        wprintf(L"%s\n",CkSocketW_lastErrorText(listenSock));
        CkBinDataW_Dispose(bdToSend);
        CkSocketW_Dispose(sndSock);
        CkSocketW_Dispose(listenSock);
        return;
    }

    // The sender will first send the big-endian integer for the number of bytes
    // that are forthcoming..
    success = CkSocketW_ReceiveInt32(rcvSock,bBigEndian);
    if (success != TRUE) {
        wprintf(L"%s\n",CkSocketW_lastErrorText(rcvSock));
        CkSocketW_Dispose(rcvSock);
        CkBinDataW_Dispose(bdToSend);
        CkSocketW_Dispose(sndSock);
        CkSocketW_Dispose(listenSock);
        return;
    }

    numBytesComing = CkSocketW_getReceivedInt(rcvSock);

    // Receive that many bytes..
    bdReceived = CkBinDataW_Create();
    success = CkSocketW_ReceiveBdN(rcvSock,numBytesComing,bdReceived);
    if (success != TRUE) {
        wprintf(L"%s\n",CkSocketW_lastErrorText(rcvSock));
        CkSocketW_Dispose(rcvSock);
        CkBinDataW_Dispose(bdToSend);
        CkSocketW_Dispose(sndSock);
        CkSocketW_Dispose(listenSock);
        CkBinDataW_Dispose(bdReceived);
        return;
    }

    // Acknowledge the sender by sending back the number of bytes we received.
    success = CkSocketW_SendInt32(rcvSock,CkBinDataW_getNumBytes(bdReceived),bBigEndian);

    // Close the connection.
    maxWaitMs = 20;
    CkSocketW_Close(rcvSock,maxWaitMs);
    CkSocketW_Dispose(rcvSock);

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

    wprintf(L"File received!\n");


    CkBinDataW_Dispose(bdToSend);
    CkSocketW_Dispose(sndSock);
    CkSocketW_Dispose(listenSock);
    CkBinDataW_Dispose(bdReceived);

    }