TSSHKexAlgorithm; Value : boolean);
begin
  FClient.KexAlgorithms[Index] := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetPublicKeyAlgorithms(Index :
  TSSHPublicKeyAlgorithm) : boolean;
begin
  Result := FClient.PublicKeyAlgorithms[Index];
end;

procedure TElIndySSHShellIOHandlerSocket.SetPublicKeyAlgorithms(Index :
  TSSHPublicKeyAlgorithm; Value : boolean);
begin
  FClient.PublicKeyAlgorithms[Index] := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetServerSoftwareName : string;
begin
  Result := FClient.ServerSoftwareName;
end;

function TElIndySSHShellIOHandlerSocket.GetVersion : TSSHVersion;
begin
  Result := FClient.Version;
end;

function TElIndySSHShellIOHandlerSocket.GetServerCloseReason : string;
begin
  Result := FClient.ServerCloseReason;
end;

function TElIndySSHShellIOHandlerSocket.GetEncryptionAlgorithmSC :
  TSSHEncryptionAlgorithm;
begin
  Result := FClient.EncryptionAlgorithmServerToClient;
end;

function TElIndySSHShellIOHandlerSocket.GetEncryptionAlgorithmCS :
  TSSHEncryptionAlgorithm;
begin
  Result := FClient.EncryptionAlgorithmClientToServer;
end;

function TElIndySSHShellIOHandlerSocket.GetCompressionAlgorithmSC :
  TSSHCompressionAlgorithm;
begin
  Result := FClient.CompressionAlgorithmServerToClient;
end;

function TElIndySSHShellIOHandlerSocket.GetCompressionAlgorithmCS :
  TSSHCompressionAlgorithm;
begin
  Result := FClient.CompressionAlgorithmClientToServer;
end;

function TElIndySSHShellIOHandlerSocket.GetMacAlgorithmSC : TSSHMacAlgorithm;
begin
  Result := FClient.MacAlgorithmServerToClient;
end;

function TElIndySSHShellIOHandlerSocket.GetMacAlgorithmCS : TSSHMacAlgorithm;
begin
  Result := FClient.MacAlgorithmClientToServer;
end;

function TElIndySSHShellIOHandlerSocket.GetKexAlgorithm : TSSHKexAlgorithm;
begin
  Result := FClient.KexAlgorithm;
end;

function TElIndySSHShellIOHandlerSocket.GetPublicKeyAlgorithm :
  TSSHPublicKeyAlgorithm;
begin
  Result := FClient.PublicKeyAlgorithm;
end;

function TElIndySSHShellIOHandlerSocket.GetSoftwareName : string;
begin
  Result := FClient.SoftwareName;
end;

procedure TElIndySSHShellIOHandlerSocket.SetSoftwareName(Value : string);
begin
  FClient.SoftwareName := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetVersions : TSSHVersions;
begin
  Result := FClient.Versions;
end;

procedure TElIndySSHShellIOHandlerSocket.SetVersions(Value : TSSHVersions);
begin
  FClient.Versions := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetUserName : string;
begin
  Result := FClient.Username;
end;

procedure TElIndySSHShellIOHandlerSocket.SetUserName(Value : string);
begin
  FClient.Username := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetPassword : string;
begin
  Result := FClient.Password;
end;

procedure TElIndySSHShellIOHandlerSocket.SetPassword(Value : string);
begin
  FClient.Password := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetClientUserName : string;
begin
  Result := FClient.ClientUserName;
end;

procedure TElIndySSHShellIOHandlerSocket.SetClientUserName(Value : string);
begin
  FClient.ClientUsername := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetClientHostName : string;
begin
  Result := FClient.ClientHostName;
end;

procedure TElIndySSHShellIOHandlerSocket.SetClientHostname(Value : string);
begin
  FClient.ClientHostName := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetKeyStorage : TElSSHCustomKeyStorage;
begin
  Result := FClient.KeyStorage;
end;

procedure TElIndySSHShellIOHandlerSocket.SetKeyStorage(Value : TElSSHCustomKeyStorage);
begin
  FClient.KeyStorage := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetRequestCompression : boolean;
begin
  Result := FClient.ForceCompression;
end;

procedure TElIndySSHShellIOHandlerSocket.SetRequestCompression(Value : boolean);
begin
  FClient.ForceCompression := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetCompressionLevel : integer;
begin
  Result := FClient.CompressionLevel;
end;

procedure TElIndySSHShellIOHandlerSocket.SetCompressionLevel(Value : integer);
begin
  FClient.CompressionLevel := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetAuthenticationTypes : cardinal;
begin
  Result := FClient.AuthenticationTypes;
end;

procedure TElIndySSHShellIOHandlerSocket.SetAuthenticationTypes(Value : cardinal);
begin
  FClient.AuthenticationTypes := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetOnAuthenticationSuccess : TNotifyEvent;
begin
  Result := FClient.OnAuthenticationSuccess;
end;

procedure TElIndySSHShellIOHandlerSocket.SetOnAuthenticationSuccess(Value :
  TNotifyEvent);
begin
  FClient.OnAuthenticationSuccess := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetOnAuthenticationFailed :
  TSSHAuthenticationFailedEvent;
begin
  Result := FClient.OnAuthenticationFailed;
end;

procedure TElIndySSHShellIOHandlerSocket.SetOnAuthenticationFailed(Value :
  TSSHAuthenticationFailedEvent);
begin
  FClient.OnAuthenticationFailed := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetOnAuthenticationKeyboard :
  TSSHAuthenticationKeyboardEvent;
begin
  Result := FClient.OnAuthenticationKeyboard;
end;

procedure TElIndySSHShellIOHandlerSocket.SetOnAuthenticationKeyboard(Value :
  TSSHAuthenticationKeyboardEvent);
begin
  FClient.OnAuthenticationKeyboard := Value;
end;

function TElIndySSHShellIOHandlerSocket.GetOnKeyValidate : TSSHKeyValidateEvent;
begin
  Result := FClient.OnKeyValidate;
end;

procedure TElIndySSHShellIOHandlerSocket.SetOnKeyValidate(Value : TSSHKeyValidateEvent);
begin
  FClient.OnKeyValidate := Value;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleClientSend(Sender : TObject;
  Buffer : pointer; Size : integer);
var
  Sent, Portion : integer;
begin
  if FBinding = nil then
    Exit;
  Sent := 0;
  while Sent < Size do
  begin
    Portion := FBinding.Send(PByteArray(Buffer)[Sent], Size - Sent, 0);
    TIdAntiFreezeBase.DoProcess(false);
    if Portion <= 0 then
    begin
      if FBinding.HandleAllocated then
      begin
        FBinding.CloseSocket;
        raise EIdConnClosedGracefully.Create(RSConnectionClosedGracefully);
      end;
      if GStack.CheckForSocketError(Portion, [ID_WSAESHUTDOWN]) then
      begin
        if FBinding.HandleAllocated then
          FBinding.CloseSocket;
        GStack.RaiseSocketError(ID_WSAESHUTDOWN);
      end;
    end;
    Inc(Sent, Portion);
  end;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleClientReceive(Sender : TObject;
  Buffer : pointer; Size : integer; out Written : integer);
begin
  if (inherited Connected) and FBinding.Readable then
  begin
    Written := FBinding.Recv(Buffer^, Size, 0);
    if Written < 0 then
      Written := 0;
  end
  else
    Written := 0;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleClientOpenConnection(Sender :
  TObject);
begin
  FClientState := CLIENT_STATE_CONNECTED;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleClientCloseConnection(Sender :
  TObject);
begin
  FClientState := CLIENT_STATE_NOT_CONNECTED;
  raise EIdConnClosedGracefully.Create('Connection closed');
end;

procedure TElIndySSHShellIOHandlerSocket.HandleClientError(Sender : TObject;
  Error : integer);
begin
  FClientState := CLIENT_STATE_ERROR;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleTunnelOpen(Sender : TObject;
  Connection : TElSSHTunnelConnection);
begin
  FConnection := Connection;
  FConnection.OnData := HandleConnectionData;
  FConnection.OnExtendedData := HandleConnectionExtendedData;
  FConnection.OnError := HandleConnectionError;
  FConnection.OnClose := HandleConnectionClose;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleTunnelClose(Sender : TObject;
  Connection : TElSSHTunnelConnection);
begin
  FClientState := CLIENT_STATE_DISCONNECTED;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleTunnelError(Sender : TObject;
  Error : integer; Data : Pointer);
begin
  FClientState := CLIENT_STATE_ERROR;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleConnectionData(Sender : TObject;
  Buffer : pointer; Size : integer);
var
  OldLen : integer;
begin
  OldLen := Length(FDataBuffer);
  SetLength(FDataBuffer, OldLen + Size);
  Move(Buffer^, FDataBuffer[OldLen + 1], Size);
  FDataReceived := true;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleConnectionExtendedData(Sender :
  TObject; Buffer : pointer; Size : integer);
var
  OldLen : integer;
begin
  OldLen := Length(FExtendedDataBuffer);
  SetLength(FExtendedDataBuffer, OldLen + Size);
  Move(Buffer^, FExtendedDataBuffer[OldLen + 1], Size);
end;

procedure TElIndySSHShellIOHandlerSocket.HandleConnectionError(Sender : TObject;
  Error : integer);
begin
  FClientState := CLIENT_STATE_ERROR;
end;

procedure TElIndySSHShellIOHandlerSocket.HandleConnectionClose(Sender : TObject;
  CloseType : TSSHCloseType);
begin
  FClientState := CLIENT_STATE_DISCONNECTED;
  FConnection := nil;
end;

function TElIndySSHShellIOHandlerSocket.Readable(AMSec: integer): boolean;
begin
  if Length(FDataBuffer) > 0 then
    Result := true
  else
    Result := inherited Readable(AMSec);
end;

end.