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.

Chilkat Module for Perl 5.8.*

Chilkat Module for Perl 5.10.*

Chilkat Module for Perl 5.8.* (x64)

Chilkat Module for Perl 5.10.* (x64)

use chilkat;

$socket = new chilkat::CkSocket();

$success = $socket->UnlockComponent("Anything for 30-day trial");
if ($success != 1) {
    print $socket->lastErrorText() . "\n";
    exit;
}

$useSsl = 0;
$maxWaitMillisec = 20000;

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

$remoteHost = "123.123.88.88";
$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 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.
$success = $socket->AsyncConnectStart($remoteHost,$remotePort,$useSsl,$maxWaitMillisec);
if ($success != 1) {
    print $socket->lastErrorText() . "\n";
    exit;
}

#  Wait for the socket to become connected...
while (($socket->get_AsyncConnectFinished() != 1)) {
    #  Sleep 1 second.
    $socket->SleepMs(100);
}

#  Did the connect fail?
if ($socket->get_AsyncConnectSuccess() != 1) {
    print $socket->asyncConnectLog() . "\n";
    exit;
}

#  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 != 1) {
    print $socket->lastErrorText() . "\n";
    exit;
}

#  Wait for the send to finish
while (($socket->get_AsyncSendFinished() != 1)) {
    #  Sleep 1 second.
    $socket->SleepMs(100);
}

#  Did the send fail?
if ($socket->get_AsyncSendSuccess() != 1) {
    print $socket->asyncSendLog() . "\n";
    exit;
}

#  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 != 1) {
    print $socket->lastErrorText() . "\n";
    exit;
}

#  Wait for the background read to finish
while (($socket->get_AsyncReceiveFinished() != 1)) {
    #  Sleep 1 second.
    $socket->SleepMs(100);
}

#  Did the receive fail?
if ($socket->get_AsyncReceiveSuccess() != 1) {
    print $socket->asyncReceiveLog() . "\n";
    exit;
}

#  Display the received message:
print $socket->asyncReceivedString() . "\n";

#  Close the connection with the server
#  Wait a max of 20 seconds (20000 millsec)
$socket->Close(20000);