Xbase++ Requires Chilkat v11.0.0+

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

See more Socket/SSL/TLS Examples

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

LOCAL nSuccess
LOCAL oTlsRead
LOCAL nBUseTls
LOCAL nMaxWaitMs
LOCAL oTlsWrite
LOCAL oTask
LOCAL cHttpGetReq

nSuccess := 0

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

oTlsRead := CreateObject("Chilkat.Socket")

//  We'll just use an HTTPS server for this example...
nBUseTls := 1
nMaxWaitMs := 5000
nSuccess := oTlsRead:Connect("www.chilkatsoft.com", 443, nBUseTls, nMaxWaitMs)
IF (nSuccess == 0)
    ? oTlsRead:LastErrorText
    oTlsRead:destroy()
    RETURN
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 DupSocket 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.

oTlsWrite := CreateObject("Chilkat.Socket")
nSuccess := oTlsRead:DupSocket(oTlsWrite)
IF (nSuccess == 0)
    ? oTlsRead:LastErrorText
    oTlsRead:destroy()
    oTlsWrite:destroy()
    RETURN
ENDIF

//  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.
oTask := oTlsRead:ReceiveUntilMatchAsync(Chr(13) + Chr(10) + Chr(13) + Chr(10))
oTask:Run()

//  Now send the request.  This should not block because the read is happening on the tlsRead object.
cHttpGetReq := "GET / HTTP/1.1" + Chr(13) + Chr(10) + "Host: www.chilkatsoft.com" + Chr(13) + Chr(10) + Chr(13) + Chr(10)
nSuccess := oTlsWrite:SendString(cHttpGetReq)
//  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.
nMaxWaitMs := 5000
nSuccess := oTask:Wait(nMaxWaitMs)
IF (.NOT. nSuccess .OR. (oTask:StatusInt != 7) .OR. (oTask:TaskSuccess != 1))
    IF (.NOT. nSuccess)
        //  The task.LastErrorText applies to the Wait method call.
        ? oTask:LastErrorText
    ELSE
        //  The ResultErrorText applies to the underlying task method call (i.e. the Connect)
        ? oTask:Status
        ? oTask:ResultErrorText
    ENDIF

    oTask:destroy()
    oTlsRead:destroy()
    oTlsWrite:destroy()
    RETURN
ENDIF

//  Examine the received HTTP response header:
? "HTTP response header:"
? oTask: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

oTask:destroy()

//  Forget about the remainder of the HTTP response... The example was only to demonstrate
//  simultaneous reading/writing..
nMaxWaitMs := 20
oTlsRead:Close(nMaxWaitMs)

oTlsRead:destroy()
oTlsWrite:destroy()