Delphi DLL

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. Delphi DLL

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Task, Socket;

...

procedure TForm1.Button1Click(Sender: TObject);
var
success: Boolean;
tlsRead: HCkSocket;
bUseTls: Boolean;
maxWaitMs: Integer;
tlsWrite: HCkSocket;
task: HCkTask;
httpGetReq: PWideChar;

begin
success := False;

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

tlsRead := CkSocket_Create();

// We'll just use an HTTPS server for this example...
bUseTls := True;
maxWaitMs := 5000;
success := CkSocket_Connect(tlsRead,'www.chilkatsoft.com',443,bUseTls,maxWaitMs);
if (success = False) then
  begin
    Memo1.Lines.Add(CkSocket__lastErrorText(tlsRead));
    Exit;
  end;

// 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.

tlsWrite := CkSocket_Create();
success := CkSocket_DupSocket(tlsRead,tlsWrite);
if (success = False) then
  begin
    Memo1.Lines.Add(CkSocket__lastErrorText(tlsRead));
    Exit;
  end;

// 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.
task := CkSocket_ReceiveUntilMatchAsync(tlsRead,#13#10 + #13#10);
CkTask_Run(task);

// Now send the request.  This should not block because the read is happening on the tlsRead object.
httpGetReq := 'GET / HTTP/1.1' + #13#10 + 'Host: www.chilkatsoft.com' + #13#10 + #13#10;
success := CkSocket_SendString(tlsWrite,httpGetReq);
// Assuming success for the example...

// Wait for the read task to finish.
// The True/False returned by Wait applies to the Wait method call, not the task.
maxWaitMs := 5000;
success := CkTask_Wait(task,maxWaitMs);
if (not success or (CkTask_getStatusInt(task) <> 7) or (CkTask_getTaskSuccess(task) <> True)) then
  begin
    if (not success) then
      begin
        // The task.LastErrorText applies to the Wait method call.
        Memo1.Lines.Add(CkTask__lastErrorText(task));
      end
    else
      begin
        // The ResultErrorText applies to the underlying task method call (i.e. the Connect)
        Memo1.Lines.Add(CkTask__status(task));
        Memo1.Lines.Add(CkTask__resultErrorText(task));
      end;
    CkTask_Dispose(task);
    Exit;
  end;

// Examine the received HTTP response header:
Memo1.Lines.Add('HTTP response header:');
Memo1.Lines.Add(CkTask__getResultString(task));

// 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

CkTask_Dispose(task);

// Forget about the remainder of the HTTP response... The example was only to demonstrate
// simultaneous reading/writing..
maxWaitMs := 20;
CkSocket_Close(tlsRead,maxWaitMs);

CkSocket_Dispose(tlsRead);
CkSocket_Dispose(tlsWrite);

end;