Understanding Asynchronous Sockets

Discusses how asynchronous sockets (in Chilkat) are used for reading, writing, connecting, and accepting connections. The same code works for both SSL/TLS and non-SSL/TLS (unencrypted) sockets.

Downloads:

MS Windows Visual C/C++ Libraries

Linux/CentOS C/C++ Libraries

MAC OS X C/C++ Libraries

Solaris C/C++ Libraries

C++ Builder Libraries

// Needs #include <CkSocket.h>

    CkString strOut;

    CkSocket socket;

    bool success;
    success = socket.UnlockComponent("Anything for 30-day trial");
    if (success != true) {
        strOut.append(socket.lastErrorText());
        strOut.append("\r\n");
        SetDlgItemText(IDC_EDIT1,strOut.getUnicode());
        return;
    }

    bool useSsl;
    useSsl = false;
    long maxWaitMillisec;
    maxWaitMillisec = 20000;

    //  The remote hostname may be an IP address, a domain name,
    //  or "localhost".  You'll need to change this:
    const char * remoteHost;
    remoteHost = "123.123.88.88";
    long remotePort;
    remotePort = 8125;

    //  The meaning of "asynchronous" is that the socket operation, whether
    //  it be a read, write, connect, or accept, happens in a background
    //  thread and thus leaves your application free to do something
    //  else while the socket operation is running.
    // 
    //  Note: If your application is simply going to initiate an asynchronous operation
    //  and do nothing except wait for it to complete, then it may as
    //  well use the synchronous socket methods -- there's no point in adding
    //  complexity to your application if it's not necessary.  The meaning of "synchronous"
    //  is that the method call (for reading, writing, connecting, accepting) does not
    //  return until the socket operation is complete.
    // 
    //  All asynchronous socket operations follow these basic steps:
    //  1) Initiate the asynchronous socket operation.  This starts a background thread
    //  that does the work. The method called to initiate the asynchronous operation
    //  returns immediately.
    //  2) Wait until the operation is completed by periodically examining the
    //  "Finished" property.  Each type of socket operation has it's own "Finished" property, such as AsyncReceiveFinished.
    //  Once it becomes true or false, you may check the "Success" property (see next step).
    //  3) Once finished, you may check the "Success" property to see if the asynchronous operation
    //  succeeded or failed.  Each type of socket operation has it's own "Success" property,
    //  such as AsynchReceiveSuccess.
    //  4) If it failed, the error information is available in the "Log" property, such as "AsyncReceiveLog".
    //  5) If success, then the return data is available in another property (see below).

    //  -------------------------------------------------------------------------
    //  Asynchronous Socket Methods and Properties
    //  -------------------------------------------------------------------------
    // 
    //  --------------------
    //  Receiving Data:
    //  --------------------
    // 
    //   Methods for initiating a background receive:
    //      AsyncReceiveBytes
    //      AsyncReceiveBytesN
    //      AsyncReceiveString
    //      AsyncReceiveToCRLF
    //      AsyncReceiveUntilMatch
    //   Properties:
    //      AsyncReceiveFinished - Becomes true when completed.
    //      AsyncReceiveSuccess - Set to true or false when finished.
    //       AsyncReceiveLog - Error information if failed.
    //      AsyncReceivedBytes - Data received if receiving binary data.
    //       AsyncReceivedString -- Data received if receiving a string.
    // 
    //  --------------------
    //  Sending Data:
    //  --------------------
    // 
    //  Methods for initiating a background send:
    //      AsyncSendBytes
    //      AsyncSendString
    //  Properties:
    //      AsyncSendFinished - Becomes true when completed.
    //      AsyncSendSuccess - Set to true or false when finished.
    //       AsyncSendLog - Error information if failed.

    //  --------------------
    //  Making a TCP Connection:
    //  --------------------
    // 
    //  Method for initiating a background connect:
    //      AsyncConnectStart
    //  Properties:
    //      AsyncConnectFinished - Becomes true when completed.
    //      AsyncConnectSuccess - Set to true or false when finished.
    //       AsyncConnectLog - Error information if failed.

    //  --------------------
    //  Accepting an Incoming a TCP Connection:
    //  --------------------
    // 
    //  Method for initiating a background accept:
    //      AsyncAcceptStart
    //  Properties:
    //      AsyncAcceptFinished - Becomes true when completed.
    //      AsyncAcceptSuccess - Set to true or false when finished.
    //       AsyncAcceptLog - Error information if failed.
    // 
    //  ** After AsyncAcceptFinished becomes true *and* AsyncAcceptSuccess
    //  is true, the connected socket may be retrieved by calling AsyncAcceptSocket.

    //  --------------------
    //  DNS Lookup
    //  --------------------
    // 
    //  Method for initiating a background DNS lookup:
    //      AsyncDnsStart
    //  Properties:
    //      AsyncDnsFinished - Becomes true when completed.
    //      AsyncDnsSuccess - Set to true or false when finished.
    //       AsyncDnsLog - Error information if failed.
    //       AsyncDnsResult - The IP address of the DNS lookup if successful.

    //  The following code demonstrates connecting, sending, and receiving asynchronously.
    //  NOTE: This example simply waits for each background operation
    //  to complete.  In general, the whole point of doing something
    //  asynchronously is so your application is free to do other things,
    //  such as manage the user-interface.

    //  Connect to the remote host asynchronously in a background thread.
    success = socket.AsyncConnectStart(remoteHost,remotePort,useSsl,maxWaitMillisec);
    if (success != true) {
        strOut.append(socket.lastErrorText());
        strOut.append("\r\n");
        SetDlgItemText(IDC_EDIT1,strOut.getUnicode());
        return;
    }

    //  Wait for the socket to become connected...
    while ((socket.get_AsyncConnectFinished() != true)) {
        //  Sleep 1 second.
        socket.SleepMs(100);
    }

    //  Did the connect fail?
    if (socket.get_AsyncConnectSuccess() != true) {
        strOut.append(socket.get_AsyncConnectLog());
        strOut.append("\r\n");
        SetDlgItemText(IDC_EDIT1,strOut.getUnicode());
        return;
    }

    //  Set maximum timeouts for reading an writing (in millisec)
    socket.put_MaxReadIdleMs(20000);
    socket.put_MaxSendIdleMs(20000);

    //  Send a "Hello Server! -EOM-" message:
    success = socket.AsyncSendString("Hello Server! -EOM-");
    if (success != true) {
        strOut.append(socket.lastErrorText());
        strOut.append("\r\n");
        SetDlgItemText(IDC_EDIT1,strOut.getUnicode());
        return;
    }

    //  Wait for the send to finish
    while ((socket.get_AsyncSendFinished() != true)) {
        //  Sleep 1 second.
        socket.SleepMs(100);
    }

    //  Did the send fail?
    if (socket.get_AsyncSendSuccess() != true) {
        strOut.append(socket.get_AsyncSendLog());
        strOut.append("\r\n");
        SetDlgItemText(IDC_EDIT1,strOut.getUnicode());
        return;
    }

    //  The server (in this example) is going to send a "Hello Client! -EOM-"
    //  message.  Begin reading asynchronously in a background thread:
    success = socket.AsyncReceiveUntilMatch("-EOM-");
    if (success != true) {
        strOut.append(socket.lastErrorText());
        strOut.append("\r\n");
        SetDlgItemText(IDC_EDIT1,strOut.getUnicode());
        return;
    }

    //  Wait for the background read to finish
    while ((socket.get_AsyncReceiveFinished() != true)) {
        //  Sleep 1 second.
        socket.SleepMs(100);
    }

    //  Did the receive fail?
    if (socket.get_AsyncReceiveSuccess() != true) {
        strOut.append(socket.get_AsyncReceiveLog());
        strOut.append("\r\n");
        SetDlgItemText(IDC_EDIT1,strOut.getUnicode());
        return;
    }

    //  Display the received message:
    strOut.append(socket.get_AsyncReceivedString());
    strOut.append("\r\n");

    //  Close the connection with the server
    //  Wait a max of 20 seconds (20000 millsec)
    socket.Close(20000);

    SetDlgItemText(IDC_EDIT1,strOut.getUnicode());