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.

Download Chilkat Socket ActiveX

LOCAL loSocket
LOCAL lnSuccess
LOCAL lnUseSsl
LOCAL lnMaxWaitMillisec
LOCAL lcRemoteHost
LOCAL lnRemotePort

loSocket = CreateObject('Chilkat.Socket')

lnSuccess = loSocket.UnlockComponent("Anything for 30-day trial")
IF (lnSuccess <> 1) THEN
    =MESSAGEBOX(loSocket.LastErrorText)
    QUIT
ENDIF

lnUseSsl = 0

lnMaxWaitMillisec = 20000

*  The remote hostname may be an IP address, a domain name,
*  or "localhost".  You'll need to change this:

lcRemoteHost = "123.123.88.88"

lnRemotePort = 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 1 or 0, 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 1 when completed.
*      AsyncReceiveSuccess - Set to 1 or 0 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 1 when completed.
*      AsyncSendSuccess - Set to 1 or 0 when finished.
*       AsyncSendLog - Error information if failed.

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

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

*  --------------------
*  DNS Lookup
*  --------------------
* 
*  Method for initiating a background DNS lookup:
*      AsyncDnsStart
*  Properties:
*      AsyncDnsFinished - Becomes 1 when completed.
*      AsyncDnsSuccess - Set to 1 or 0 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.
lnSuccess = loSocket.AsyncConnectStart(lcRemoteHost,lnRemotePort,lnUseSsl,lnMaxWaitMillisec)
IF (lnSuccess <> 1) THEN
    =MESSAGEBOX(loSocket.LastErrorText)
    QUIT
ENDIF

*  Wait for the socket to become connected...
DO WHILE (loSocket.AsyncConnectFinished <> 1)
    *  Sleep 1 second.
    loSocket.SleepMs(100)
ENDDO

*  Did the connect fail?
IF (loSocket.AsyncConnectSuccess <> 1) THEN
    =MESSAGEBOX(loSocket.AsyncConnectLog)
    QUIT
ENDIF

*  Set maximum timeouts for reading an writing (in millisec)
loSocket.MaxReadIdleMs = 20000
loSocket.MaxSendIdleMs = 20000

*  Send a "Hello Server! -EOM-" message:
lnSuccess = loSocket.AsyncSendString("Hello Server! -EOM-")
IF (lnSuccess <> 1) THEN
    =MESSAGEBOX(loSocket.LastErrorText)
    QUIT
ENDIF

*  Wait for the send to finish
DO WHILE (loSocket.AsyncSendFinished <> 1)
    *  Sleep 1 second.
    loSocket.SleepMs(100)
ENDDO

*  Did the send fail?
IF (loSocket.AsyncSendSuccess <> 1) THEN
    =MESSAGEBOX(loSocket.AsyncSendLog)
    QUIT
ENDIF

*  The server (in this example) is going to send a "Hello Client! -EOM-"
*  message.  Begin reading asynchronously in a background thread:
lnSuccess = loSocket.AsyncReceiveUntilMatch("-EOM-")
IF (lnSuccess <> 1) THEN
    =MESSAGEBOX(loSocket.LastErrorText)
    QUIT
ENDIF

*  Wait for the background read to finish
DO WHILE (loSocket.AsyncReceiveFinished <> 1)
    *  Sleep 1 second.
    loSocket.SleepMs(100)
ENDDO

*  Did the receive fail?
IF (loSocket.AsyncReceiveSuccess <> 1) THEN
    =MESSAGEBOX(loSocket.AsyncReceiveLog)
    QUIT
ENDIF

*  Display the received message:
=MESSAGEBOX(loSocket.AsyncReceivedString)

*  Close the connection with the server
*  Wait a max of 20 seconds (20000 millsec)
loSocket.Close(20000)