Send a file from the server to client with Indy

Question

I have two programs, one for the server and another for the client.

The server sends a file to the client. In the client, I use the TIdTCPClient, TIdThreadComponent, and TIdAntiFreeze components.

The file is well created, but the thread never finishes. When debugging, I never get to Fs.Free.

This is my client code:

procedure TForm1.IdThreadComponentRun(Sender: TIdThreadComponent);
var
  MsgDuServeur: string;
  Taille: Integer;
  Fs : TFileStream;
begin
  MsgDuServeur:= Trim(IdTCPClient.IOHandler.ReadLn(nil));
  MemoService.Lines.Add('Serveur : ' + MsgDuServeur);
  if (MsgDuServeur = 'RECUP_ENCOURS') then
  begin
    try
      Fs:= TFileStream.Create('C:\temp\client\1test.cds', fmCreate);
      try
        IdTCPClient.IOHandler.LargeStream:= True;
        Taille:= IdTCPClient.IOHandler.ReadInt64();
        IdTCPClient.IOHandler.ReadStream(Fs, -1, False); 
        IdThreadComponent1.Active:= False;
      finally
        Fs.Free;
      end;
    except
      on E: Exception do
      _MessageDlg(E.message, mtWarning, [mbOK], 0);
    end;
  end;
end;

this is my server code

procedure TServiceServeurTrf.IdTCPServerExecute(AContext: TIdContext);
var
  Flux: TMemoryStream;
  LStreamSize : int64;
begin
  try
    // Transfert de fichiers volumineux
    Context.Connection.Socket.WriteLn('RECUP_ENCOURS'); 
    AContext.Connection.IOHandler.LargeStream:= True;
    Flux:= TMemoryStream.Create;
    try
      Flux.LoadFromFile(C:\Windows\Temp\Transfert\3000\1test.cds);
      Flux.Position:= 0;
      AContext.Connection.IOHandler.Write(Flux.Size);
      AContext.Connection.IOHandler.Write(Flux, 0, True);
    finally
      FreeAndNil(Flux);
    end;
  except
    EcrireLog('Erreur');
  end;
end;

i deleted the antifreeze and after ReadStream() i use IdThreadComponent1.Active:= False; Now it's ok. How synchronised ? Indeed i want use progressbar with IdTCPClientWork, IdTCPClientWorkBegin, IdTCPClientWorkEnd but i don't see it progress

Answer 1

You are misusing the TIdIOHandler.Write(TStream) and TIdIOHandler.ReadStream() methods.

On the client side, setting the AByteCount parameter of ReadStream() to -1 and the AReadUntilDisconnect parameter to False (which are the default values) causes ReadStream() to read the stream size for you before it reads the stream data, where the size is read using ReadInt32() or ReadInt64(), depending on the LargeStream property.

Originally, your client was calling ReadInt64() (and saving the result into an Integer!) followed by calling ReadStream() with AByteCount set to the result of ReadInt64() and AReadUntilDisconnect set to True. So, no matter how many bytes were actually being sent, ReadStream() would read indefinitely until the server closed the connection.

Then you changed your client code to call ReadStream() with AByteCount set to -1 and AReadUntilDisconnect set to False, but you did not remove the call to ReadInt64() beforehand, so now you have a double-read of the stream size.

On the server side, setting the AWriteByteCount parameter to True causes Write(TStream) to send the stream size before sending the stream data, where the size is sent using Write(Int32) or Write(Int64), depending on the LargeStream property. But, your server code is calling Write(Int64) before calling Write(TStream), so you have a double-send of the stream size.

You are also not synchronizing with the main thread when accessing your UI.

Try this instead:

procedure TForm1.IdThreadComponentRun(Sender: TIdThreadComponent);
var
  MsgDuServeur: string;
  Fs : TFileStream;
begin
  MsgDuServeur := Trim(IdTCPClient.IOHandler.ReadLn);
  TThread.Synchronize(
    procedure
    begin
      MemoService.Lines.Add('Serveur : ' + MsgDuServeur);
    end
  );
  if (MsgDuServeur = 'RECUP_ENCOURS') then
  begin
    try
      Fs := TFileStream.Create('C:\temp\client\1test.cds', fmCreate);
      try
        IdTCPClient.IOHandler.LargeStream := True;
        IdTCPClient.IOHandler.ReadStream(Fs, -1, False); // <-- calls ReadInt64() internally for you!
      finally
        Fs.Free;
      end;
    except
      on E: Exception do
        IdTCPClient.Disconnect;
        TThread.Queue(
          procedure
          begin
            MessageDlg(E.message, mtWarning, [mbOK], 0);
          end
        );
    end;
  end;
end;

procedure TServiceServeurTrf.IdTCPServerExecute(AContext: TIdContext);
var
  Flux: TMemoryStream;
begin
  try
    // Transfert de fichiers volumineux
    Flux := TMemoryStream.Create; // <-- consider using TFileStream instead...
    try
      Flux.LoadFromFile(C:\Windows\Temp\Transfert\3000\1test.cds);
      AContext.Connection.IOHandler.LargeStream := True;
      AContext.Connection.IOHandler.WriteLn('RECUP_ENCOURS'); 
      AContext.Connection.IOHandler.Write(Flux, 0, True); // <-- calls Write(Int64) internally for you!
    finally
      Flux.Free;
    end;
  except
    EcrireLog('Erreur'); // <-- make sure this is thread-safe!
    raise;
  end;
end;