Proxy Server

Overview

TsgcWebSocketProxyServer implements a WebSocket Server Component that listens for client WebSocket connections and forwards data connections to a normal TCP/IP server.

At a glance

Features

• Native Delphi implementation with full ANSI/Unicode support.

Technical specification

Main properties

The principal published / public properties used to configure and drive the component. Consult the online help for the full list.

Main methods

The principal public methods exposed by the component.

Public events

The component exposes the following published events; consult the online help for full event-handler signatures.

Quick Start

Drop the component on a form, configure the properties below and activate it. The snippet that follows shows the typical TsgcWebSocketProxyServer.Authentication — Authentication configuration sourced from the online help.

Delphi (VCL / FireMonkey)

oProxy := TsgcWebSocketProxyServer.Create(nil);
oProxy.Authentication.Enabled := true;
oProxy.Authentication.Basic.Enabled := true;
oProxy.Authentication.AuthUsers.Add('user=secret');
oProxy.Proxy.Host := 'upstream.example.com';
oProxy.Proxy.Port := 8080;
oProxy.Active := true;

Common scenarios

The following scenarios are lifted verbatim from the online help. Each shows the configuration and method calls needed to drive the component through a specific real-world flow.

1 · OnAuthentication

Fires when authentication is enabled so the application can check user and password and accept or reject the downstream client connection.

procedure OnAuthentication(Connection: TsgcWSConnection; aUser, aPassword: string;
  var Authenticated: Boolean);
begin
  if ((aUser = 'user') and (aPassword = 'secret')) then
    Authenticated := True
  else
    Authenticated := False;
end;

void OnAuthentication(TsgcWSConnection *Connection, string aUser, string aPassword,
  bool &Authenticated)
{
  if ((aUser == "user") && (aPassword == "secret"))
    Authenticated = true;
  else
    Authenticated = false;
}

void OnAuthentication(TsgcWSConnection Connection, string aUser, string aPassword,
  ref bool Authenticated)
{
  if ((aUser == "user") && (aPassword == "secret"))
    Authenticated = true;
  else
    Authenticated = false;
}

2 · OnUnknownAuthentication

Fires when authentication is enabled and the authentication method of a downstream client is not recognized by the server.

procedure OnUnknownAuthentication(Connection: TsgcWSConnection; AuthType, AuthData: string;
  var aUser, aPassword: string; var Authenticated: Boolean);
begin
  if AuthType = 'Bearer' then
  begin
    if AuthData = 'jwt_token' then
      Authenticated := True
    else
      Authenticated := False;
  end
  else
    Authenticated := False;
end;

void OnUnknownAuthentication(TsgcWSConnection *Connection, string AuthType, string AuthData,
  string &aUser, string &aPassword, bool &Authenticated)
{
  if (AuthType == "Bearer")
  {
    if (AuthData == "jwt_token")
      Authenticated = true;
    else
      Authenticated = false;
  }
  else
    Authenticated = false;
}

void OnUnknownAuthenticationEvent(TsgcWSConnection Connection, string AuthType, string AuthData,
  ref string User, ref string Password, ref bool Authenticated)
{
  if (AuthType == "Bearer")
  {
    if (AuthData == "jwt_token")
      Authenticated = true;
    else
      Authenticated = false;
  }
  else
    Authenticated = false;
}

3 · DisconnectAll

Disconnects every active WebSocket client and its paired upstream TCP link while keeping the proxy listening for new connections.

oServer.DisconnectAll;

oServer->DisconnectAll();

oServer.DisconnectAll();

4 · OnBeforeHeartBeat

Fires before each HeartBeat ping so the application can implement a custom keep-alive for a downstream WebSocket client.

procedure OnBeforeHeartBeat(Sender: TObject; const Connection: TsgcWSConnection;
  var Handled: Boolean);
begin
  Connection.WriteData('ping');
  Handled := True;
end;

void OnBeforeHeartBeat(TObject *Sender, const TsgcWSConnection *Connection,
  bool &Handled)
{
  Connection->WriteData("ping");
  Handled = true;
}

void OnBeforeHeartBeat(TObject Sender, TsgcWSConnection Connection, out bool Handled)
{
  Connection.WriteData("ping");
  Handled = true;
}

5 · OnBinary

Fires every time a downstream WebSocket client sends a binary message, before the proxy forwards it upstream.

procedure OnBinary(Connection: TsgcWSConnection; const Data: TMemoryStream);
var
  oBitmap: TBitmap;
begin
  oBitmap := TBitmap.Create;
  try
    oBitmap.LoadFromStream(Data);
    Image1.Picture.Assign(oBitmap);
  finally
    FreeAndNil(oBitmap);
  end;
end;

void OnBinary(TsgcWSConnection *Connection, const TMemoryStream *Data)
{
  TBitmap *oBitmap = new TBitmap();
  oBitmap->LoadFromStream(Data);
  Image1->Picture->Assign(oBitmap);
  delete oBitmap;
}

private void OnBinary(TsgcWSConnection Connection, byte[] Bytes)
{
  MemoryStream stream = new MemoryStream(Bytes);
  pictureBox1.Image = new Bitmap(stream);
}

6 · OnConnect

Fires every time a WebSocket connection is established with a downstream client and the proxy opens the upstream TCP session.

procedure OnConnect(Connection: TsgcWSConnection);
begin
  Log('Client connected: ' + Connection.Guid + ' from ' + Connection.PeerIP);
end;

void OnConnect(TsgcWSConnection *Connection)
{
  Log("Client connected: " + Connection->Guid + " from " + Connection->PeerIP);
}

void OnConnect(TsgcWSConnection Connection)
{
  Console.WriteLine("Client connected: " + Connection.Guid + " from " + Connection.PeerIP);
}

Sources used to build this document

Every external claim links back to a primary source. The online-help references decode the canonical deep-link the company maintains for this component.