Streamdaten mit TTCPBlockSocket.RecvStream von Synapse empfangen

[jus]

Hallo,

möchte zwischen 2 Programmen Daten, die als Stream vorliegen, mit der Synapse Komponente austauschen. Ich vermute, dass ich beim Empfang der Daten irgendwas falsch mache. Kann wer mir bitte einen Tipp geben?

Und zwar sende ich die Daten von Programm_A so:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
(Sender: TObject);
var
  fs: TFileStream;
  s: string;
  fsTest: TFileStream;
  Sock:TTCPBlockSocket;
begin
  Sock := TTCPBlockSocket.Create;
  sock.Connect('127.0.0.1', '8008');

  fs := TFileStream.Create('echo.txt', fmOpenRead );
  fs.Seek(0, soBeginning);

  Sock.SendStreamRAW(fs);
  fs.Free;

  Sock.CloseSocket;
  Sock.Free;
end;

Das Empfangen in Programm_B:

Delphi-Quellcode:

unit echo;

interface

uses
  Classes, blcksock, synsock;

type
  TTCPEchoDaemon = class(TThread)
  private
    fSock:TTCPBlockSocket;
  public
    anzahl: Integer;
    Constructor Create;
    Destructor Destroy; override;
    procedure Execute; override;
  end;

  TTCPEchoThrd = class(TThread)
  private
    Sock:TTCPBlockSocket;
    CSock: TSocket;
  public
    Constructor Create (hsock:tSocket);
    procedure Execute; override;
  end;

implementation
uses Windows, SysUtils;

{ TEchoDaemon }

Constructor TTCPEchoDaemon.Create;
begin
  inherited create(false);
  fsock := TTCPBlockSocket.create;
  FreeOnTerminate := true;
end;

Destructor TTCPEchoDaemon.Destroy;
begin
  fSock.free;
end;

procedure TTCPEchoDaemon.Execute;
var
  ClientSock:TSocket;
begin
  fSock.CreateSocket;
//  fSock.setLinger(true,10000);
  fSock.bind('0.0.0.0','8008');
  fSock.listen;
  while not Terminated and (fSock.LastError = 0) do
  begin
    if terminated then break;
    if fSock.canread(2000) and not terminated then
    begin
      ClientSock:=fSock.accept;
      if fSock.lastError = 0 then
      begin
        MessageBox(Self.Handle, PChar('Clientanmeldung'), '', MB_OK or MB_ICONINFORMATION);
        TTCPEchoThrd.create(ClientSock);
      end;
      inc(anzahl);
    end;
  end;
end;

{ TEchoThrd }

Constructor TTCPEchoThrd.Create(Hsock:TSocket);
begin
  inherited create(false);
  Csock := Hsock;
  FreeOnTerminate:=true;
end;

procedure TTCPEchoThrd.Execute;
var
  i: Integer;
  fs: TFileStream;
begin
  fs := TFileStream.Create('test.bin',fmCreate  );
  sock:=TTCPBlockSocket.create;
  try
    Sock.socket:=CSock;
    sock.GetSins;
    repeat
      if terminated then break;
      if sock.CanRead(200) then 
      begin
        i:=sock.WaitingData;
        if i>0  then
        begin
          Sock.RecvStream (fs, 200);
        end
        else if fs.Size>0 then break;
      end;
    until terminated;
  finally
    Sock.Free;
  end;
  fs.Free;
end;

end.

Und zwar bleibt beim Programm_B fs.Size immer 0, sprich der Stream wird irgendwie nicht empfangen.

lg,
jus