sbindysslserveriohandler.pas

著名的SecureBlackBox控件完整源码

  Sent := 0;
  if FBinding = nil then
  begin
    Exit;
  end;
  while (Sent < Size) and (not FErrorOccured) do
  begin
    JustSent := FBinding.Send(PByteArray(Buffer)[Sent], Size - Sent, 0);
    {$ifndef LINUX}
    if (JustSent = SOCKET_ERROR) and (WSAGetLastError = WSAEWOULDBLOCK) then
    begin
      TIdAntiFreezeBase.DoProcess(False);
      Continue;
    end;
    {$endif}

    TIdAntiFreezeBase.DoProcess(False);

    if (JustSent <= 0) then
    begin
      if FBinding.HandleAllocated then
      begin
        FBinding.CloseSocket;
        raise EIdConnClosedGracefully.Create(RSConnectionClosedGracefully);
      end;
      if GStack.CheckForSocketError(JustSent, [ID_WSAESHUTDOWN]) then
      begin
        if FBinding.HandleAllocated then
          FBinding.CloseSocket;
        GStack.RaiseSocketError(ID_WSAESHUTDOWN);
      end;
    end;
    Inc(Sent, JustSent);
  end;
end;

procedure TElIndySSLIOHandlerServerSocket.DoSSLEstablished;
begin
  if Assigned(FOnSSLEstablished) then
    FOnSSLEstablished(Self, FSecureServer.CurrentVersion, FSecureServer.CipherSuite);
end;

procedure TElIndySSLIOHandlerServerSocket.HandleSend(Sender: TObject; Buffer:
  pointer;
  Size: longint);
begin
  DoActualSend(Buffer, Size);
end;

procedure TElIndySSLIOHandlerServerSocket.HandleReceive(Sender: TObject; Buffer:
  pointer; MaxSize: longint; {$ifndef BUIlDER_USED}out{$else}var{$endif} Written: longint);
var
  Val : boolean;
begin
  if FReadTimeout <> 0 then
    Val := inherited Readable(FReadTimeout)
  else
    Val := true;
  if Val then
  begin
    Written := FBinding.Recv(Buffer^, MaxSize, 0);
    {$ifndef LINUX}
    if (Written = SOCKET_ERROR) and (WSAGetLastError = WSAEWOULDBLOCK) then
    begin
      Written := 0;
      exit;
    end;
    {$endif}
    if Written <= 0 then
    begin
      FErrorOccured := true;
      Written := 0;
    end;
  end
  else
    raise EIdReadTimeout.Create(RSReadTimeout);
end;

procedure TElIndySSLIOHandlerServerSocket.HandleData(Sender: TObject; Buffer:
  pointer;
  Size: longint);
begin
  if Size = 0 then
  begin
    FDataReceived := false;
    exit;
  end;
  if Size <= FRecvMaxSize then
  begin
    Move(Buffer^, FRecvBuffer^, Size);
    FRecvWritten := Size;
  end
  else
  begin
    Move(Buffer^, FRecvBuffer^, FRecvMaxSize);
    FRecvWritten := FRecvMaxSize;
    SetLength(FBuffer, Size - FRecvMaxSize);
    Move(PByteArray(Buffer)[FRecvMaxSize], FBuffer[1], Size - FRecvMaxSize);
  end;
  FDataReceived := True;
end;

procedure TElIndySSLIOHandlerServerSocket.HandleOpenConnection(Sender: TObject);
begin
  FConnected := true;
end;

procedure TElIndySSLIOHandlerServerSocket.HandleCloseConnection(Sender: TObject;
  CloseDescription: integer);
begin
  if CloseDescription = cdCLOSED_BY_ERROR then
  begin
    raise
      EIdConnClosedGracefully.Create('Error while receiving. Connection closed.');
    Close;
  end;
  FConnected := false;
  FErrorOccured := true;
end;

procedure TElIndySSLIOHandlerServerSocket.HandleCertificateValidate(Sender:
  TObject;
  X509Certificate: TElX509Certificate; var Validate: boolean);
begin
  if Assigned(FOnCertificateValidate) then
    FOnCertificateValidate(Self, X509Certificate, Self, Validate);
end;

function TElIndySSLIOHandlerServerSocket.GetCipherSuites(Index: TSBCipherSuite):
  boolean;
begin
  Result := FSecureServer.CipherSuites[Index];
end;

function TElIndySSLIOHandlerServerSocket.GetVersions: TSBVersions;
begin
  Result := FSecureServer.Versions;
end;

function TElIndySSLIOHandlerServerSocket.GetCipherSuite: TSBCipherSuite;
begin
  Result := FSecureServer.CipherSuite;
end;

function TElIndySSLIOHandlerServerSocket.GetVersion: TSBVersion;
begin
  Result := FSecureServer.CurrentVersion;
end;

function TElIndySSLIOHandlerServerSocket.GetCertStorage: TElMemoryCertStorage;
begin
  Result := FSecureServer.CertStorage;
end;

function TElIndySSLIOHandlerServerSocket.GetClientCertStorage:
  TElCustomCertStorage;
begin
  Result := FSecureServer.ClientCertStorage;
end;

function TElIndySSLIOHandlerServerSocket.GetSessionPool: TElSessionPool;
begin
  Result := FSecureServer.SessionPool;
end;

function TElIndySSLIOHandlerServerSocket.GetClientAuthentication: boolean;
begin
  Result := FSecureServer.ClientAuthentication;
end;

function TElIndySSLIOHandlerServerSocket.GetAuthenticationLevel: TSBAuthenticationLevel;
begin
  Result := FSecureServer.AuthenticationLevel;
end;

function TElIndySSLIOHandlerServerSocket.GetCompressionAlgorithm:
    TSBSSLCompressionAlgorithm;
begin
  Result := FSecureServer.CompressionAlgorithm;
end;

function TElIndySSLIOHandlerServerSocket.GetCompressionAlgorithms(Index:
    TSBSSLCompressionAlgorithm): boolean;
begin
  Result := FSecureServer.CompressionAlgorithms[Index];
end;

function TElIndySSLIOHandlerServerSocket.GetExtensions: TElServerSSLExtensions;
begin
  Result := FSecureServer.Extensions;
end;

function TElIndySSLIOHandlerServerSocket.GetForceCertificateChain: boolean;
begin
  Result := FSecureServer.ForceCertificateChain;
end;

function TElIndySSLIOHandlerServerSocket.GetPeerExtensions:
    TElCustomSSLExtensions;
begin
  Result := FSecureServer.PeerExtensions;
end;

procedure TElIndySSLIOHandlerServerSocket.HandleCiphersNegotiated(Sender :
    TObject);
begin
  if Assigned(FOnCiphersNegotiated) then
    FOnCiphersNegotiated(Self);
end;

procedure TElIndySSLIOHandlerServerSocket.HandleError(Sender : TObject;
    ErrorCode: integer; Fatal: boolean; Remote : boolean);
begin
  if Assigned(FOnError) then
    FOnError(Self, ErrorCode, Fatal, Remote);
end;

procedure TElIndySSLIOHandlerServerSocket.SetCipherSuites(Index: TSBCipherSuite;
  Value: boolean);
begin
  FSecureServer.CipherSuites[Index] := Value;
end;

procedure TElIndySSLIOHandlerServerSocket.SetVersions(Value: TSBVersions);
begin
  FSecureServer.Versions := Value;
end;

procedure TElIndySSLIOHandlerServerSocket.SetCertStorage(Value:
  TElMemoryCertStorage);
begin
  FSecureServer.CertStorage := Value;
end;

procedure TElIndySSLIOHandlerServerSocket.SetClientCertStorage(Value:
  TElCustomCertStorage);
begin
  FSecureServer.ClientCertStorage := Value;
end;

procedure TElIndySSLIOHandlerServerSocket.SetSessionPool(Value: TElSessionPool);
begin
  FSecureServer.SessionPool := Value;
end;

procedure TElIndySSLIOHandlerServerSocket.SetClientAuthentication(Value:
  boolean);
begin
  FSecureServer.ClientAuthentication := Value;
end;

procedure TElIndySSLIOHandlerServerSocket.SetAuthenticationLevel(Value: TSBAuthenticationLevel);
begin
  FSecureServer.AuthenticationLevel := Value;
end;

procedure TElIndySSLIOHandlerServerSocket.SetForceCertificateChain(Value: boolean);
begin
  FSecureServer.ForceCertificateChain := Value;
end;

procedure TElIndySSLIOHandlerServerSocket.InternalValidate(var Validity:
  TSBCertificateValidity;
  var Reason: TSBCertificateValidityReason);
begin
  FSecureServer.InternalValidate(Validity, Reason);
end;

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

procedure TElIndySSLIOHandlerServerSocket.RenegotiateCiphers;
begin
  FSecureServer.RenegotiateCiphers;
end;

procedure TElIndySSLIOHandlerServerSocket.SetCompressionAlgorithms(Index:
    TSBSSLCompressionAlgorithm; Value: boolean);
begin
  FSecureServer.CompressionAlgorithms[Index] := Value;
end;

procedure TElIndySSLServerIOHandler.HandleExtensionsReceived(Sender : TObject);
begin
  if assigned(FOnExtensionsReceived) then
    FOnExtensionsReceived(Self);
end;

procedure TElIndySSLServerIOHandler.HandleCertificateURLs(Sender: {$ifndef DELPHI_NET}TObject{$else}System.Object{$endif};
        URLs : TElClientCertURLsSSLExtension; Certificates: TElMemoryCertStorage);
begin
  if assigned(FOnCertificateURLs) then
    FOnCertificateURLs(Self, URLs, Certificates);
end;

procedure TElIndySSLServerIOHandler.HandleKeyNeeded(Sender: TObject; const Identity : string; var Key : ByteArray);
begin
  if Assigned(FOnKeyNeeded) then
    FOnKeyNeeded(Self, Identity, Key);
end;

function TElIndySSLServerIOHandler.GetCompressionAlgorithms(Index:
    TSBSSLCompressionAlgorithm): boolean;
begin
  Result := FCompressionAlgorithms[Index];
end;

procedure TElIndySSLServerIOHandler.HandleCiphersNegotiated(Sender : TObject);
begin
  if Assigned(FOnCiphersNegotiated) then
    FOnCiphersNegotiated(Self);
end;

procedure TElIndySSLServerIOHandler.HandleError(Sender : TObject; ErrorCode:
    integer; Fatal: boolean; Remote : boolean);
begin
  if Assigned(FOnError) then
    FOnError(Self, ErrorCode, Fatal, Remote);
end;

procedure TElIndySSLServerIOHandler.HandleSSLEstablished(Sender: TObject;
  Version: TSBVersion; CipherSuite: TSBCipherSuite);
begin
  if assigned(FOnSSLEstablished) then
    FOnSSLEstablished(Self, Version, CipherSuite);
end;

procedure TElIndySSLServerIOHandler.SetCompressionAlgorithms(Index:
    TSBSSLCompressionAlgorithm; Value: boolean);
begin
  FCompressionAlgorithms[Index] := Value;
end;

end.