Indy 10 / streams via tcp ip senden

[bernhard_LA]

meine Demoprojekt zum Verschicken und Empfangen von Streams mit INDY 10 spielt leider nicht, die Verbindung wird abgebrochen, ich kann den Fehler im Code nicht erkennen ....

Delphi-Quellcode:

var aFs  : TFileStream

....
..


///
///   demo  server empfängt einen stream und sendet einen stream zurück
///


procedure TStreamServerForm.IdTCPServer1Execute(AContext: TIdContext); var
   LSize: LongInt;
begin

   Memo1.Lines.Add('Server  starting  .... ' );


    AContext.Connection.IOHandler.ReadTimeout  := 9000;

   if ( ReceiveStream(AContext, TStream(afs)) = False ) then
   begin
     TIdNotify.NotifyMethod(ShowCannotGetStreamErrorMessage);
     Exit;
   end;


   TIdNotify.NotifyMethod(StreamReceived);


   if ( SendStream(AContext,TStream(afS)) = False ) then
   begin
     TIdNotify.NotifyMethod(ShowCannotSendStreamrErrorMessage);
     Exit;
   end;

   Memo1.Lines.Add('Server  done .... ' );

end;


///
///  demo client schickt einen stream und einen bekommt einen anderen zurück ///
///

procedure TStreamExchangeClientForm.Button_SendStreamClick(Sender: TObject); var  LSize: LongInt; begin

LSize := 0;

Memo1.Lines.Add('Try send stream to server.....');

   if (SendSTream(IdTCPClient1, TStream(afs)) = False) then
   begin
     Memo1.Lines.Add('Cannot send stream/buffer to server.');
     Exit;
   end;

   if (ReceiveStream(IdTCPClient1, TStream(afs)) = False) then
   begin
     Memo1.Lines.Add('Cannot get "OK" message from server, Unknown error occured');
     Exit;
   end;

   image1.Picture.Bitmap.LoadFromStream(afs);


end;

-----------------------------------------------------------------------------

      die low level indy routinen ..... 

------------------------------------------------------------------------------

function SendStream(AContext: TIdContext; AStream: TStream): Boolean; overload; begin
   Result := False;
   try
     AContext.Connection.IOHandler.Write(LongInt(SizeOf(AStream)));
     AContext.Connection.IOHandler.WriteBufferOpen;
     AContext.Connection.IOHandler.Write(AStream, SizeOf(AStream));
     AContext.Connection.IOHandler.WriteBufferFlush;
   finally
     AContext.Connection.IOHandler.WriteBufferClose;
   end;
   Result := True;
end;



function ReceiveStream(AContext: TIdContext; var AStream: TStream): 
Boolean; overload;
var
   LSize: LongInt;
begin
   Result := False;
   LSize := AContext.Connection.IOHandler.ReadLongInt();
   AContext.Connection.IOHandler.ReadStream(AStream, LSize, False);
   Result := True;
end;


function ReceiveStream(AClient: TIdTCPClient; var  AStream: TStream): 
Boolean;  overload;
var
   LSize: LongInt;
begin
   Result := False;
   LSize := AClient.IOHandler.ReadLongInt();
   AClient.IOHandler.ReadStream(AStream, LSize, False);
   Result := True;

end;

function SendStream(AClient: TIdTCPClient; AStream: TStream): Boolean;  
overload;
var StreamSize   : LongInt;
begin

   Result := True;
   try
     StreamSize := (AStream.Size);

     AStream.Seek(0, soFromBeginning);

     AClient.IOHandler.LargeStream := True;
     AClient.IOHandler.SendBufferSize := 32768;
     AClient.IOHandler.Write(LongInt(StreamSize));
     AClient.IOHandler.WriteBufferOpen;
     AClient.IOHandler.Write(AStream, LongInt(StreamSize));
     AClient.IOHandler.WriteBufferFlush;
   finally
     AClient.IOHandler.WriteBufferClose;
   end;
   Result := True;
end;

[mjustin]

Wie wird der Stream auch erzeugt und mit Daten gefüllt? Beides ist im Code nicht zu sehen, auch das TStream(afs) ist auffällig - das afs als Unterklasse von TStream deklariert ist, braucht man keinen Typecast.

[bernhard_LA]

ich habe eine Demo-Projekzt auf Source forge eingestellte :

http://indy10clieservr.svn.sourcefor...treamExchange/ bzw. http://sourceforge.net/projects/indy10clieservr/


String Exchange (sample #1) und Record exchange (sample#2) funktionieren, Sttream Exchange (sample #4) ist nach dem selben Konzept gesztrickt, nur leider ist hier ein Bug.

Ich bin für jede Anregung Dankbar!

[chaosben]

Delphi-Quellcode:

function SendStream(AContext: TIdContext; AStream: TStream): Boolean; overload; begin
   Result := False;
   try
     AContext.Connection.IOHandler.Write(LongInt(SizeOf(AStream))); //<-- sendet 4, da die Größe eines Objektes 4 Byte sind (unter 32bit)
     AContext.Connection.IOHandler.WriteBufferOpen;
     AContext.Connection.IOHandler.Write(AStream, SizeOf(AStream)); //<-- da wolltest du bestimmt den Inhalt senden und nicht schon wieder 4 ;)
     AContext.Connection.IOHandler.WriteBufferFlush;
   finally
     AContext.Connection.IOHandler.WriteBufferClose;
   end;
   Result := True;
end;

Anbei mal ein kleines Beispiel, wie ich es machen würde.

[bernhard_LA]

Danke für die Antwort, Du verwendest "sockets2 und nicht den IOhandler warum ?

Delphi-Quellcode:

procedure TForm15.Button1Click(Sender: TObject);
var
  ms : TMemoryStream;
  g : TGraphic;
begin
  if not IdTCPClient1.Connected then
    IdTCPClient1.Connect;

  ms := TMemoryStream.Create;
  g := TGraphic(Image1.Picture.Graphic.ClassType.Create);
  try
    Image1.Picture.Graphic.SaveToStream(ms);

    ms.Seek(0,soFromBeginning);
    IdTCPClient1.Socket.Write(ms, ms.Size, true);
    ms.Clear;
    IdTCPClient1.Socket.ReadStream(ms, IdTCPClient1.Socket.ReadLongInt);

    ms.Seek(0, soFromBeginning);
    g.LoadFromStream(ms);
    Image2.Picture.Graphic := g;
  finally
    ms.Free;
    g.Free;
  end;
end;

procedure TForm15.IdTCPServer1Connect(AContext: TIdContext);
begin
  AContext.Connection.Socket.ReadTimeout := 50;
end;

procedure TForm15.IdTCPServer1Execute(AContext: TIdContext);
var
  ms : TMemoryStream;
begin
  ms := TMemoryStream.Create;
  try

    try
      AContext.Connection.Socket.ReadStream (ms, AContext.Connection.Socket.ReadLongInt);
    except
      on E: EIdReadTimeout do begin end;
    end;

    if ms.Size > 0 then
    begin
      ms.Seek(0, soFromBeginning);
      AContext.Connection.Socket.Write(ms, ms.Size, true);
    end;

  finally
    ms.Free;
  end;
end;

[bernhard_LA]

Nachtrag : mit folgendem Code bekomme ich eine AV (siehe screen dump) warum kann ich auf den Stream nicht zugreifen ?

Delphi-Quellcode:

///  server read stream
function ReceiveStream(AContext: TIdContext; var AStream: TStream): Boolean; overload;
var
  LSize: LongInt;
begin
  try
  LSize := AContext.Connection.IOHandler.ReadLongInt();
  AContext.Connection.IOHandler.ReadStream(AStream, LSize);
  Result := True;
  except
  Result := False;
  end;
end;





///  client send stream 
function SendStream(AClient: TIdTCPClient; AStream: TStream): Boolean;  overload;
var StreamSize   : LongInt;
begin

  Result := True;
  try
    StreamSize := (AStream.Size);

    AStream.Seek(0, soFromBeginning);

    AClient.IOHandler.LargeStream := True;
    AClient.IOHandler.SendBufferSize := 32768;
    AClient.IOHandler.Write(LongInt(StreamSize));
    AClient.IOHandler.WriteBufferOpen;
    AClient.IOHandler.Write(AStream, StreamSize);
    AClient.IOHandler.WriteBufferFlush;
  finally
    AClient.IOHandler.WriteBufferClose;
  end;
  Result := True;
end;

[daywalker9]

Und wo läuft das in dem Code auf?

[bernhard_LA]

die AV ist auf der Server seite bei *** AContext.Connection.IOHandler.ReadStream(AStream, LSize);
LSize ist richtig übertragen


ich habe folgende Links zu meinem Problem gefunden:

http://stackoverflow.com/questions/3...o-server-in-in

http://stackoverflow.com/questions/8...riting-streams

leider sehe ich nur nicht meinen Fehler :-) entweder ist mein Stream schreibgeschützt oder meine Kombination auf READSTEAM (SERVER) und WRITESTREAM (CLIENT) stimmt immer noch nicht

[chaosben]

Sorry ... hab erst jetzt deine Frage gesehen: ich nehme Socket weil, ich das mal so bei den Indys gelesen habe. Ob und was der "richtige" Weg ist, weiß ich nicht. :)

[bernhard_LA]

die links weiter oben geben halt leider keine komplette Anleitung wie man send and receive stream aufeinander anpasst,
bin immer noich auf der such nach meinem Fehler

[Aphton]

Änder mal das hier, auf folgendes um:

Delphi-Quellcode:

  AClient.IOHandler.Write(AStream, StreamSize);
->
  AClient.IOHandler.Write(AStream.Memory^, StreamSize);

Und definiere AStream im Rumpf als TMemoryStream (sonst hast du keine "Memory" Property, auf die du schön zugreifen kannst)

Noch ne kleine, jedoch sehr wichtige Bemerkung:
Schickst du 10 kb ab, heißt es nicht dringend, dass 10 kb auch ankommen.
Kann sein, dass zuerst 2 kb ankommen, dann 5 kb, dann 1 kb und letzendlich 2 kb.

DU musst dir ne Struktur überlegen, die damit klar kommt.

Am besten nen globalen Stream anlegen, der alle ankommenden Daten puffert. Und aus dem Puffer extrahiert er ganze Datensätze.

Senden: 5 kb (Bild), 10 kb (Audio), ... (15 kb)
Puffer ->
Empfängt: 2kb, 5kb, nix, 3kb, 4kb, 1kb, ... (15 kb)

Jedesmal nach dem empfangen guggst du nach, ob ein ganzer Datensatz (Bild = 5kb, Audio = 10kb) da ist.
Dh nach dem ersten Empfangen hast du 2 kb, du liest die ersten 4 Bytes aus (Size) und guggst, ob die Größe des Puffers - 4 Bytes diesem Wert entspricht (oder größer ist), falls nicht, ist noch kein ganzer Datensatz da.
Falls ja, dann extrahierst du diesen Datensatz und arbeitest halt damit weiter. Puffern vergisst du im Hintergrund auch nicht. Muss schön weiterlaufen.
Wichtig ist noch, dass du die Daten, die du extrahiert hast, aus dem Puffer löschen solltest, da sonst dieser riesengroß wird und deine Anwendung crasht.

EDIT:
In Windows ist es ja so, dass man nur eine bestimmte Größe von Daten abschicken kann. Der maximale Wert (der zuerst gesetzt werden muss) ist 64 kb. Standardmäßig sinds (glaube ich) nur 8 kb (8192 b).
Deshalb würde ich WIEDER nen Puffer empfehlen, in die du die Daten, die du abschicken willst, reinpufferst. Vorallem auch weil man nicht wirklich immer Daten in dieser Größe abschicken kann, weil Windows intern auch noch puffert und die Daten erst später abschickt -> ist dieser Puffer voll, wird Send() nicht funktionieren.

Daten: 10 mb
Sendegröße: 8kb
Senden: 8 kb, 4 kb, 7 kb, 8 kb, 8 kb
Jedesmal nach dem Senden muss der Positionszeiger im Sendepuffer richtig gesetzt werden -> Position = Position + BytesSent

So habe ich das einmal realisiert und das ganze in ne Komponente gepackt.

Edit:
Ich weiß nicht, ob das Indy intern macht; ich habe nur mit den Standard TServerSocket / TClientSocket Komponenten gearbeitet (die imho nicht der Indy Komponentensammlung angehören)

[bernhard_LA]

in den beiden links (sieh weiter oben( steht nach meinerm Verständnis mit den params von READSTREAM und WRITESTREAM man diese Themaik in den Griff bekommen
obige Lösung sieht sehr komplex aus, einfache Lösung möglich ??

[bernhard_LA]

komplette Lösung jetzt online unter http://indy10clieservr.svn.sourcefor...am%20Exchange/