(Visual FoxPro) Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

This example demonstrates how to simultaneously read/write on a single socket connection.

Chilkat ActiveX Downloads ActiveX for 32-bit and 64-bit Windows

LOCAL loTlsRead
LOCAL lnBUseTls
LOCAL lnMaxWaitMs
LOCAL lnSuccess
LOCAL loTlsWrite
LOCAL loTask
LOCAL lcHttpGetReq

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

* For versions of Chilkat < 10.0.0, use CreateObject('Chilkat_9_5_0.Socket')
loTlsRead = CreateObject('Chilkat.Socket')

* We'll just use an HTTPS server for this example...
lnBUseTls = 1
lnMaxWaitMs = 5000
lnSuccess = loTlsRead.Connect("www.chilkatsoft.com",443,lnBUseTls,lnMaxWaitMs)
IF (lnSuccess <> 1) THEN
    ? loTlsRead.LastErrorText
    RELEASE loTlsRead
    CANCEL
ENDIF

* Chilkat classes are thread-safe.  This means that only one method call can be active
* at a time for a given object instance.  It would seem that this would prevent the possibility
* to simultaneously read/write a given connection because it would require two method calls
* to be simultaneously active: one for reading and one for writing.
* 
* There's a trick to doing it...
* 
* The CloneSocket method is provided to get a new object instance that shares the same socket
* connection.  This allows for the coarse-grained object-level thread safety to be maintained, 
* while finer-grained thread-safety mechanisms keep things kosher internally.

* One object will be used for reading, and the cloned socket is used for writing.
* It doesn't matter which --  you can use the cloned socket for reading or the original for writing.
* However.. if you try to read simultneously from both the original and cloned objects at the same
* time, then one will block until the other finishes.  (This is because of the finer-grained thread
* safety internally.)  The same is true if you try to write both socket objects simultaneously.

loTlsWrite = loTlsRead.CloneSocket()

* Let's start an async read on the socket.  Nothing will be arriving until we actually send the GET
* request and the server responds.  This will read until the end of the HTTP response header.
loTask = loTlsRead.ReceiveUntilMatchAsync(CHR(13) + CHR(10) + CHR(13) + CHR(10))
loTask.Run()

* Now send the request.  This should not block because the read is happening on the tlsRead object.
lcHttpGetReq = "GET / HTTP/1.1" + CHR(13) + CHR(10) + "Host: www.chilkatsoft.com" + CHR(13) + CHR(10) + CHR(13) + CHR(10)
lnSuccess = loTlsWrite.SendString(lcHttpGetReq)
* Assuming success for the example...

* Wait for the read task to finish.
* The 1/0 returned by Wait applies to the Wait method call, not the task.
lnMaxWaitMs = 5000
lnSuccess = loTask.Wait(lnMaxWaitMs)
IF (NOT lnSuccess OR (loTask.StatusInt <> 7) OR (loTask.TaskSuccess <> 1)) THEN
    IF (NOT lnSuccess) THEN
        * The task.LastErrorText applies to the Wait method call.
        ? loTask.LastErrorText
    ELSE
        * The ResultErrorText applies to the underlying task method call (i.e. the Connect)
        ? loTask.Status
        ? loTask.ResultErrorText
    ENDIF

    RELEASE loTask
    RELEASE loTlsWrite
    RELEASE loTlsRead
    CANCEL
ENDIF

* Examine the received HTTP response header:
? "HTTP response header:"
? loTask.GetResultString()

* We should get a response that looks like this:
* 	HTTP response header:
* 	HTTP/1.1 200 OK
* 	Cache-Control: private
* 	Content-Length: 7477
* 	Content-Type: text/html
* 	Server: Microsoft-IIS/8.5
* 	Set-Cookie: ASPSESSIONIDSWDSTRTQ=BBNMIKGCHFJNILFFPLDIOGDE; secure; path=/
* 	X-Powered-By: ASP.NET
* 	X-Powered-By-Plesk: PleskWin
* 	Date: Thu, 06 Apr 2017 12:03:30 GMT

RELEASE loTask
RELEASE loTlsWrite

* Forget about the remainder of the HTTP response... The example was only to demonstrate
* simultaneous reading/writing..
lnMaxWaitMs = 20
loTlsRead.Close(lnMaxWaitMs)

RELEASE loTlsRead