Pascal (Lazarus/Delphi)

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. Pascal (Lazarus/Delphi)

program ChilkatDemo;

// Demonstrates using the Chilkat Pascal wrapper via the C bridge DLL.
// Builds as a console application under Lazarus (FPC) or Delphi.

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}
{$APPTYPE CONSOLE}

uses
  {$IFDEF UNIX}
  cthreads,
  {$ENDIF}
  SysUtils,
  CkDllLoader,
  Chilkat.Task,
  Chilkat.Socket;

// ---------------------------------------------------------------------------

procedure RunDemo;
var
  success: Boolean;
  tlsRead: TSocket;
  bUseTls: Boolean;
  maxWaitMs: Integer;
  tlsWrite: TSocket;
  task: TTask;
  httpGetReq: string;

begin
  success := False;

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

  tlsRead := TSocket.Create;

  //  We'll just use an HTTPS server for this example...
  bUseTls := True;
  maxWaitMs := 5000;
  success := tlsRead.Connect('www.chilkatsoft.com',443,bUseTls,maxWaitMs);
  if (success = False) then
    begin
      WriteLn(tlsRead.LastErrorText);
      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 := TSocket.Create;
  success := tlsRead.DupSocket(tlsWrite);
  if (success = False) then
    begin
      WriteLn(tlsRead.LastErrorText);
      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 := tlsRead.ReceiveUntilMatchAsync(#13#10 + #13#10);
  task.Run();

  //  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 := tlsWrite.SendString(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 := task.Wait(maxWaitMs);
  if (not success or (task.StatusInt <> 7) or (task.TaskSuccess <> True)) then
    begin
      if (not success) then
        begin
          //  The task.LastErrorText applies to the Wait method call.
          WriteLn(task.LastErrorText);
        end
      else
        begin
          //  The ResultErrorText applies to the underlying task method call (i.e. the Connect)
          WriteLn(task.Status);
          WriteLn(task.ResultErrorText);
        end;
      task.Free;
      Exit;
    end;

  //  Examine the received HTTP response header:
  WriteLn('HTTP response header:');
  WriteLn(task.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

  task.Free;

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


  tlsRead.Free;
  tlsWrite.Free;

end;

// ---------------------------------------------------------------------------

begin

  try
    RunDemo;
  except
    on E: Exception do
      WriteLn('Unhandled exception: ', E.ClassName, ': ', E.Message);
  end;

  WriteLn;
  {$IFDEF MSWINDOWS}
  WriteLn('Press Enter to exit...');
  ReadLn;
  {$ENDIF}
end.