BSOne.SFC/Tocsg.Module/RemoteSecu/EXE_RemoteSecuClient/RSecuClient.pas

{*******************************************************}
{                                                       }
{       CrmOeAgentClient                                }
{                                                       }
{       Copyright (C) 2022 kku                          }
{                                                       }
{*******************************************************}

unit RSecuClient;

interface

uses
  Tocsg.ClientBase, Tocsg.Packet, Tocsg.PacketDefine, System.Classes, System.SysUtils,
  Tocsg.StoredPacket, Winapi.Windows, Winapi.Messages;

const
  DIR_TASK = 'Task\';
  NAME_STORED_HEAD = 'DcsStd';

  WM_CRMCLIENT_NOTIFICATION = WM_USER + 4939;
  NOTI_RCV_TEST = 0;
  NOTI_CLIENT_CONN = 1;
  NOTI_CLIENT_DISCONN = 2;
  REQ_RDP_OPEN = 3;
  REQ_RDP_CLOSE = 4;

type
  TSendStateKind = (sskDirect, sskStored);
  TRSecuClient = class(TTgClientBase)
  private
    SendState_: TSendStateKind;
    StdPkt_: TTgStoredPacket;
    bSvLocal_: Boolean; // 서버와 연결 해제 시 지정된 패킷을 로컬에 저장할지
  // 상태알림 메시지 전송 핸들 22_0411 08:57:10 kku
    hRcvHwnd_: THandle;
    sEmpNo_: String;
  protected
    function _ProcessSend(Send: ISendPacket): Boolean; override;
    function _ProcessOther: Boolean; override;
    procedure _ProcessSendFail(Send: ISendPacket); override;

    procedure ConnectedEvent; override;
    procedure DisconnectedEvent; override;
    procedure ProcessRcvPacket(aRcv: IRcvPacket); override;
  public
    Constructor Create(hRcvHwnd: HWND; const sHost: String = ''; nPort: Integer = 0;
                nReConnTerm: Integer = 2000; nPingTerm: Integer = 60000);
    Destructor Destroy; override;

    property EmpNo: String read sEmpNo_ write sEmpNo_;
  end;

var
  gClient: TRSecuClient = nil;

implementation

uses
  Tocsg.Path, Tocsg.Encrypt, Tocsg.Network, Tocsg.DateTime, GlobalSocketDefine;

{ TRSecuClient }

Constructor TRSecuClient.Create(hRcvHwnd: HWND; const sHost: String = ''; nPort: Integer = 0;
                nReConnTerm: Integer = 2000; nPingTerm: Integer = 60000);

  procedure Init;
  var
    sCurDir: String;
  begin
    bSvLocal_ := false;
    SendState_ := sskStored;

    sCurDir := GetRunExePathDir;
    StdPkt_ := TTgStoredPacket.Create(sCurDir + NAME_STORED_HEAD, ekAes256cbc);
  end;

begin
  Inherited Create(sHost, nPort, nReConnTerm, nPingTerm);
  ASSERT(gClient = nil);
  gClient := Self;
  hRcvHwnd_ := hRcvHwnd;
  sEmpNo_ := '';
  Init;
end;

Destructor TRSecuClient.Destroy;
begin
  gClient := nil;
  Inherited;
  FreeAndNil(StdPkt_);
end;

function TRSecuClient._ProcessSend(Send: ISendPacket): Boolean;
begin
  Result := false;
  if Send = nil then
    exit;

  try
  // todo : 지연 전송 처리등
    if not bConnected_ then
    begin
      if bSvLocal_ and (StdPkt_ <> nil) then
      begin
        case Send.Command of
          3409345 : ;
          else exit; // 로컬에 저장하고 서버에 접속 시 다시 보낼 패킷인지 체크
        end;

        StdPkt_.PushPacket(Send);
      end;
    end else
      Result := Inherited;
  except
    on E: Exception do
      ECrmClient.TraceException(Self, E, 'Fail .. _ProcessSend()');
  end;
end;

function TRSecuClient._ProcessOther: Boolean;
var
  sSend: String;
  Send: ISendPacket;
begin
  Result := false;
  try
    if bConnected_ then
    begin
      if SendState_ = sskStored then
      begin
      // 암호화 정보 송수신 완료 체크 22_0408 10:47:52 kku
        if GetSendPauseState then
          exit;

        try
          Lock;
          try
            sSend := StdPkt_.PopPacketStr;
          finally
            Unlock;
          end;
        except
          on E: Exception do
          begin
            ECrmStoredPacket.TraceException(Self, E, 'Fail .. _ProcessOther() - PopPacketStr()');
            exit;
          end;
        end;

        if sSend <> '' then
        begin
          Result := true;

          Send := TTgPacket.Create(sSend);
          case Send.Command of
            223434 :
            begin
            // 수집된 데이터 파일큐 처리 전송
              Send.PacketKind := pkNormal;
              Send.S['S0'] := ''; // 에이전트 식별 정보
            end;
            else exit;
          // todo : 지정된 패킷만 처리 할지 판단
          end;

        // todo : 수집된 로컬 데이터 전송을 서버에 알림

          SendPacket(Send);
        end else begin
          SendState_ := sskDirect;

        // todo : 수집된 로컬 데이터 전송을 끝냈다고 서버에 알림
        end;
      end;
    end;
  except
    on E: Exception do
      ECrmClient.TraceException(Self, E, 'Fail .. _ProcessOther()');
  end;
end;

procedure TRSecuClient._ProcessSendFail(Send: ISendPacket);
begin
  try
    if Send = nil then
      exit;

    Lock;
    try
      if StdPkt_ <> nil then
      begin
        case Send.Command of
          23984239 : ;
          else exit; // 다시 전송, 로컬 저장할 패킷인지 체크
        end;
      end;
    finally
      Unlock;
    end;
  except
    on E: Exception do
      ECrmClient.TraceException(Self, E, 'Fail .. _ProcessSendFail()');
  end;
end;

procedure TRSecuClient.ConnectedEvent;
var
  Send: ISendPacket;
begin
  try
    Inherited;

    Send := TTgPacket.Create(RC_RSECU_INFO);
    Send.S['EmpNo'] := sEmpNo_;
    SendPacket(Send);

    if hRcvHwnd_ <> 0 then
      SendMessage(hRcvHwnd_, WM_CRMCLIENT_NOTIFICATION, NOTI_CLIENT_CONN, 0);
  except
    on E: Exception do
      ECrmClient.TraceException(Self, E, 'Fail .. ConnectedEvent()');
  end;
end;

procedure TRSecuClient.DisconnectedEvent;
begin
  try
    SendState_ := sskStored;
    Inherited;

    if hRcvHwnd_ <> 0 then
      SendMessage(hRcvHwnd_, WM_CRMCLIENT_NOTIFICATION, NOTI_CLIENT_DISCONN, 0);
  except
    on E: Exception do
      ECrmClient.TraceException(Self, E, 'Fail .. DisconnectedEvent()');
  end;
end;

procedure TRSecuClient.ProcessRcvPacket(aRcv: IRcvPacket);

  procedure process_TOC_TEST;
  begin
    if hRcvHwnd_ <> 0 then
      SendMessage(hRcvHwnd_, WM_CRMCLIENT_NOTIFICATION, NOTI_RCV_TEST, NativeInt(aRcv));
  end;

  procedure process_RS_REQ_RDP_OPEN;
  begin
    if hRcvHwnd_ <> 0 then
      SendMessage(hRcvHwnd_, WM_CRMCLIENT_NOTIFICATION, REQ_RDP_OPEN, NativeInt(aRcv));
  end;

  procedure process_RS_REQ_RDP_CLOSE;
  begin
    if hRcvHwnd_ <> 0 then
      SendMessage(hRcvHwnd_, WM_CRMCLIENT_NOTIFICATION, REQ_RDP_CLOSE, NativeInt(aRcv));

    SendPacket(TTgPacket.Create(RS_REQ_RDP_CLOSE));
  end;

begin
  try
    case aRcv.Command of
      TOC_TEST : process_TOC_TEST;

      RS_REQ_RDP_DESTLIST,
      RS_REQ_RDP_CONNECT : SendMessage(aRcv.Handle, aRcv.WndMessage, 0, NativeUInt(aRcv));

      RS_REQ_RDP_OPEN : process_RS_REQ_RDP_OPEN;
      RS_REQ_RDP_CLOSE : process_RS_REQ_RDP_CLOSE;
      else Inherited;
    end;
  except
    on E: Exception do
      ECrmClient.TraceException(Self, E, 'Fail .. ProcessRcvPacket()');
  end;
end;

end.