msgconnection.old.pas

Delphi MsgCommunicator 2-10 component.I ve used, really good job. can be Server-Client message appl

unit MsgConnection;

interface

{$I MsgVer.inc}


{$IFDEF DEBUG_LOG_NETWORK_THREADS}
{$DEFINE LOG_CLIENT_THREADS}
{$DEFINE LOG_SERVER_THREADS}
{$ENDIF}


{DEFINE LOGIC_TEST}
{DEFINE CONNECTION_TEST}
{$IFNDEF CONNECTION_TEST}
 {DEFINE NETWORK_TEST}
{$ENDIF CONNECTION_TEST}

{$IFNDEF API_NETWORK}
 {$IFDEF D6H}
  {$DEFINE ProcessMessages} // Needs for Indy only
 {$ENDIF D6H}
{$ENDIF API_NETWORK}

uses
  Classes, Math, SysUtils,
{$IFDEF MSWINDOWS}
  Windows,
  Forms,
{$ENDIF}
{$IFDEF LINUX}
//  Libc,
  QForms,
{$ENDIF}

{$IFNDEF API_NETWORK}
 {$IFDEF D6H}
  IdBaseComponent, IdComponent, IdUDPBase, IdUDPClient, IdUDPServer, IdSocketHandle,
 {$ELSE}
  NMUDP,
 {$ENDIF}
{$ELSE}
// MsgCommunicator units
  MsgNetwork,
  MsgCrypto,
{$ENDIF}

{$IFDEF DEBUG_LOG}
  MsgDebug,
{$ENDIF}
  MsgCompression,
  MsgComBase,
  MsgTypes,
  MsgConst,
  MsgExcept,
  MsgLinux,
  MsgCriticalSection,
  MsgBaseEngine,
  MsgMemory;

const
 MAX_INT = 2147483647;

 MsgNoResending = 999;

{******************************************************************************}
// Connection parameters
{******************************************************************************}

// To connect - Client only
 MsgConnectRetryCount = 60;       // - Client only
 MsgConnectDelay = 50;            // - Client only

// To receive full session buffer
 MsgReceiveTimeOut = 40000;         // - Client only, time since the first packet to the latest
 MsgReceiveSleep = 1;               // - Client only, time to sleep while receive buffer to allow incoming packets processing, >=0, <= 100
 MsgServerReceiveTimeOut = 60000;   // - Server only
 MsgServerReceiveSleep = 1;         // - Server only   >=0, <= 100

// To send new request to ask other side to resend broken packet
 MsgResendDelay = 40;//40;       // - Client only, delay (msec) before resend requested packet, >=1, <= 100
 MsgRequestDelay = 20;//20;       // - Client only, delay (msec) before request lost packet, >=1, <= 100
 MsgServerResendDelay = 20;//20;         // - Server only, >=0, <= 100
 MsgServerRequestDelay = 20;//20;       // - Server only, >=0, <= 100

// To Diconnect
 MsgDisconnectRetryCount = 30;     // Both Client and Server
 MsgDisconnectDelay = 100;         // Both Client and Server

{******************************************************************************}

// Wait For Session end
 MsgWaitForTimeOut = 120000;        // Client only

// Wait for other threads finish to free shared object
 MsgThreadsTerminateDelay = 60000;  // Both Client and Server

{******************************************************************************}



{******************************************************************************}
// ControlCode (-128..127):
{******************************************************************************}
// From Client
                     //  5...9  -- reserwed for Accuracer commands
 MsgNewRequest = 10; // 10...32 -- reserwed for MsgCommunicator commands
                     // 33...63 -- reserwed for custom commands
 MsgConnect = 1;
// From Server
 MsgConnected = 2;
// Both
 MsgNoAction = 0;
 MsgMessage = 3;
// MsgLastPacket: 7th bit = 1, i.e. byte = x1xxxxxx, i.e. code >= 64
 MsgLastPacket = 64;
 MsgEcho = 4;
// single packet:
 MsgAllPacketsReceived = -1;
 MsgPacketResendRequest = -2;
 MsgMessageReceived = -3;
 MsgMessagePacketResendRequest = -4;
 MsgDisconnect = -55;

{$IFDEF MsgCommunicator}
// Both
 MsgGetUserInfo = 10;
 MsgRegisterNewUser = 11;
 MsgAddUserToContacts = 12;
 MsgRemoveUserFromContacts = 13;
 MsgGetContacts = 14;
 MsgUpdateUserInfo = 15;
 MsgGetUserID = 16;
 MsgFindUsers = 17;
 MsgFindMessages = 18;
 MsgIsUserExisting = 19;
 MsgIsUserOnline = 20;
 MsgUpdateUserInContacts = 21;
{$ENDIF}
{******************************************************************************}


{******************************************************************************}
// Sending Status - Fof Commands and Messages
{******************************************************************************}
  MsgNotSent = 0;
  MsgSent = -1;
{******************************************************************************}

{******************************************************************************}
// Receiving Status
{******************************************************************************}
 MsgNoAnswer = 0;
 MsgStartAnswer = 1;
 MsgAnswerNotFull = 2;
 MsgFullAnswer = -1;
{******************************************************************************}

{******************************************************************************}
// MsgReceiveStatus
{******************************************************************************}
 MsgNotFull = 0;
 MsgFull = -1;
{******************************************************************************}

{******************************************************************************}
// Session Control Codes
{******************************************************************************}
 MsgExecute = 0;
 MsgSuspend = 1;
 MsgTerminate = -1;
{******************************************************************************}


{******************************************************************************}
// Session Status
{******************************************************************************}
 MsgVacant = 0;
 MsgInUse = -1;
{******************************************************************************}


// To avoid multiple realloc
 MsgDefaultPacketsInAnswer = 8;
 MsgDefaultPacketsInRequest = 2;
 MsgDefaultMsgPacketsInAnswer = 1;
 MsgDefaultMsgPacketsInRequest = 1;

// Signatures
{$IFDEF MsgCommunicator}
 MsgClientPacketSign = 'MSG1';
 MsgServerPacketSign = 'MSG2';
{$ELSE}
 MsgClientPacketSign = 'Msg1';
 MsgServerPacketSign = 'Msg2';
{$ENDIF}

type

  TMsgSessionsArray = array of TMsgComBaseSession;

  TMsgNetwork = class;
  TMsgBaseConnectionManager = class;
{$IFDEF CLIENT_VERSION}
  TMsgClientConnectionManager = class;
  TMsgClientResendRequestThread = class;
  TMsgClientMsgResendRequestThread = class;
{$ENDIF}
{$IFDEF SERVER_VERSION}
  TMsgServerConnectionManager = class;
  TMsgServerSessionThread = class;
  TMsgServerResendRequestThread = class;
  TMsgServerMsgResendRequestThread = class;
{$ENDIF}

  TMsgControlCode = ShortInt;
  TMsgNetworkClientID = Integer;
  TMsgConnectionID = Integer;

  TMsgPacketHeader = packed record
    CheckSum:           Integer;
    Signature:          array [0..3] of Char;
    Recepient:          TMsgNetworkClientID;
    Sender:             TMsgNetworkClientID;
    ConnectionID:       TMsgConnectionID;
    SessionID:          TMsgSessionID;
    CurrentRequestID:   Integer;
    PacketID:           Integer;
    ControlCode:        TMsgControlCode;
  end;
  PMsgPacketHeader = ^TMsgPacketHeader;

  TMsgPacket = packed record
    Buffer:             PChar;
    BufferSize:         Integer;
  end;
  PMsgPacket = ^TMsgPacket;

  TMsgConnectionParams = packed record
    PacketSize:                   Integer;
    CompressionAlgorithm:         Byte;
    CompressionMode:              Byte;
  end;
  PMsgConnectionParams = ^TMsgConnectionParams;

{$IFDEF CLIENT_VERSION}
  TMsgClntSession = packed record
    Session:                TMsgComBaseSession;
    ServerSessionID:        TMsgSessionID;
    CurrentRequestID:       Integer;
    Packets:                TList;
    ListeningThreads:       TThreadList;
    MsgListeningThreads:    TThreadList;
    ResendRequestThread:    TMsgClientResendRequestThread;
    MsgResendRequestThread: TMsgClientMsgResendRequestThread;
    AnswerStatus:           Integer;
    SendStatus:             Integer;
    PacketIDsToResend:      TMsgIntegerArray;
    ClientMessageID:        Integer;
    ServerMessageID:        Integer;
    MsgPackets:             TList;
    MsgPacketIDsToResend:   TMsgIntegerArray;
    MsgSendStatus:          Integer;
    MsgReceiveStatus:       Integer;
    ConnectionID:           TMsgConnectionID;
    RemoteConnectionID:     TMsgConnectionID;
    ControlCode:            Shortint;
    MsgControlCode:         Shortint;
    Status:                 Shortint;
  end;
  PMsgClntSession = ^TMsgClntSession;

  TMsgClntConnection = packed record
    ConnectionID:       TMsgConnectionID;
    Network:            TMsgNetwork;
  end;
  PMsgClntConnection = ^TMsgClntConnection;
{$ENDIF}

{$IFDEF SERVER_VERSION}
  TMsgSrvrSession = packed record
    Session:                      TMsgComBaseSession;
    CurrentRequestID:             Integer;
    Packets:                      TThreadList;
    AnswerStatus:                 Shortint;               // for ReceiveBuffer
    SendStatus:                   Shortint;               // for SendBuffer
    MsgSendStatus:                Shortint;
    MsgReceiveStatus:             Shortint;
    PacketIDsToResend:            TMsgThreadIntArray;
    ClientMessageID:              Integer;
    ServerMessageID:              Integer;
    MsgPackets:                   TThreadList;
    MsgPacketIDsToResend:         TMsgThreadIntArray;
    ClientSessionID:              TMsgSessionID;
    ConnectionID:                 TMsgConnectionID;
    RemoteClientID:               TMsgNetworkClientID;
    RemoteHost:                   String;
    RemotePort:                   Integer;
    Application:                  String;
    ControlCode:                  Shortint;
    MsgControlCode:               Shortint;
    ListeningThreads:             TThreadList;
    MsgListeningThreads:          TThreadList;
    Thread:                       TMsgServerSessionThread;
    MsgThread:                    TMsgServerSessionThread;
    Status:                       Shortint;
  end;

  PMsgSrvrSession = ^TMsgSrvrSession;
{$ENDIF}



////////////////////////////////////////////////////////////////////////////////
//
// TMsgNetwork
//
////////////////////////////////////////////////////////////////////////////////

  TMsgNetwork = class (TObject)
   private
    FManager:             TMsgBaseConnectionManager;
    FLocalClient:         TMsgNetworkClientID;
{$IFNDEF API_NETWORK}
    FLocalHost:           String;
    FRemoteHost:          String;
    FRemotePort:          Integer;
{$ENDIF API_NETWORK}
    function RndClientID: TMsgNetworkClientID;
    procedure SetRemoteHost(Host: String);
    function GetRemoteHost: String;
    procedure SetRemotePort(Port: Integer);
    function GetRemotePort: Integer;
    procedure SetLocalHost(Host: String);
    function GetLocalHost: String;
    procedure SetLocalPort(Port: Integer);
    function GetLocalPort: Integer;
   public
{$IFDEF API_NETWORK}
    FMsgNetwork:          TMsgapiNetwork;
{$ELSE}
 {$IFDEF D6H}
//    FNetworkClient:       TIdUDPClient;
    FNetworkServer:       TIdUDPServer;
 {$ELSE}
    FTransport:           TNMUDP;
 {$ENDIF}
{$ENDIF}
   public
    constructor Create(ConnectionManager: TMsgBaseConnectionManager);
    destructor Destroy; override;
    procedure SendBuffer(
                          Buffer: PChar;
                          Count:  Integer
                         );
    procedure OnDisconnect(
                             FromHost:  String;
                             FromPort:  Integer
                             );
{$IFDEF API_NETWORK}
    procedure OnDataReceived(
                             Buffer:    PChar;
                             Count:     Integer;
                             FromHost:  String;
                             FromPort:  Integer
                             );
{$ELSE}
 {$IFDEF D6H}
    procedure OnDataReceived(
                             Sender:   TObject;
                             AData:    TStream;
                             ABinding: TIdSocketHandle
                             );
 {$ELSE}
    procedure OnDataReceived(
                             Sender: TComponent;
                             BufferSize: Integer;
                             FromIP: string;
                             Port: integer
                             );
 {$ENDIF}
{$ENDIF}
   public