Socket C&S

[Zacherl]

Zitat von tomkupitz:

Ergebnis meiner Tests: Es scheint ein Zeitproblem zu geben. Baue ich eine Pause nach jedem

Sorry, aber ... Die "Pause" löst dein Problem in keinster Weise.

[himitsu]

Zitat von Zacherl:

Zitat von tomkupitz:

Ergebnis meiner Tests: Es scheint ein Zeitproblem zu geben. Baue ich eine Pause nach jedem

Sorry, aber ... Die "Pause" löst dein Problem in keinster Weise.

Ist das Netz langsamer als deine Pause, dann mußt du die Pause weiter vergrößern, sonst knallt es wieder.
Und hängt es mal noch mehr, ...


Besser du baust sicherheitshalber gleich ein Sleep(3600000); ein.

[tomkupitz]

Zitat:

Sorry, aber ... Die "Pause" löst dein Problem in keinster Weise.

Genau so sehe ich das auch. Bisher habe ich aber noch keine "saubere" Übertragung für meinen Kontext gefunden.

[jfheins]

TCP ist immer ein "Stream", das heißt die Daten können schlimmstenfalls byteweise ankommen. (Bytes kommen aber immer ganz oder gar nicht an, darauf kann man sich zum Glück verlassen )

Ich habe das damals so gelöst, dass ich einen struct/record mit den Nutzdaten verschickt habe (konstante Länge). Auf Empfangsseite habe ich einen passend dimensionierten Puffer vorgehalten. Immer, wenn was angekommen ist, habe ich die Daten (in einer Schleife, solange neue Daten da waren!) ein Byte nach links geschoben, ein Byte neue Daten hinten angehängt und geprüft ob das ein gültiges Paket ist. (Konstante prüfen plus Checksumme)
Bei einem gültigen Paket wurde ein Callback ausgelöst.

Du kannst auch immer einen Längenwert vor die Daten schreiben. Oder ein Trennzeichen (Zeilenumbruch) zwischen die Daten. Du brauchst irgendein Verfahren, um deine Daten in einen kontinuierlichen Stream zu schreiben und (kniffeliger) sie aus einem kontinuierlichen Stream wieder herauszufischen.

Ich bin mir nicht sicher, was du mit "sauberer Übertragung" meinst. Um noch deine ursprüngliche Frage zu beantworten:

Zitat:

Wie groß darf buf max. sein? Oder kann erzwingen das alles komplett empfangen werden kann?

Ein Byte. Alles über einem Byte kann zerstückelt ankommen.

[stahli]

Du kannst halt nie sicher sagen, wann welche Paketteile auf der anderen Seite ankommen.

Wenn Du etwa sendest:
---
Dies
ist
Paket
1
---
Jetzt
kommt
Paket
2
---

kann auf der anderen Seite ankommen:
---
Dies
ist
Paket
1
Jetzt
kom
---
mt
Paket
2
---

oder alles in einem Block oder in 3 Blöcken.

Du musst also die Eingangsdaten puffern und selbst ermitteln, ob ein vollständiges Paket vorliegt, welches Du verarbeiten kannst.
Dabei können aber auch schon Daten für 2 und 1/4 weitere Pakete im Puffer vorliegen.

Dabei ist auch noch zu beachten, dass Daten von unterschiedlichen Clients reinkommen können. Also brauchst Du den o.g. Puffer ggf. pro Client.

[tomkupitz]

Schön wäre wenn immer alles ankommen würde. Ich habe n * 1024 Bytes geschickt (gesamt ca. 200000 Bytes). Angekommen sind ca. 65000 Bytes. Immer! Nur mit Pause beim Senden hat es funktioniert.

[jfheins]

Moin,
was benutzt du eigentlich genau für Komponenten und Einstellungen? Beispielsweise steht in der Hilfe zu TCustomWinSocket.SendBuf:

Zitat:

Bei nicht-blockierenden Sockets werden die Daten an die WinSock DLL gesendet, die über eigene interne Puffer verfügt. Wenn WinSock weitere Daten akzeptieren kann, gibt SendBuf sofort die Anzahl der Byte in der Warteschlange zurück. Wenn der interne Puffer von WinSock den gesendeten Puffer nicht mehr aufnehmen kann, gibt SendBuf -1 zurück, und es werden keine Daten in die Warteschlange übernommen. In diesem Fall müssen Sie etwas warten, bis WinSock die sich bereits in der Warteschlange befindlichen Daten gesendet hat und es dann erneut versuchen.

Bei nicht-blockierenden Sockets gibt SendBuf die Anzahl der tatsächlich geschriebenen Bytes zurück.

Du musst also eigentlich den Rückgabewert prüfen und dann ggf. eine Pause einlegen.

[Zacherl]

Zitat von tomkupitz:

Zitat:

Sorry, aber ... Die "Pause" löst dein Problem in keinster Weise.

Genau so sehe ich das auch. Bisher habe ich aber noch keine "saubere" Übertragung für meinen Kontext gefunden.

Eine Möglichkeit (Längenprefix) - die du wirklich 1 zu 1 übernehmen kannst - habe ich dir doch schon gegeben. Die weiteren Varianten (feste Größe pro "Paket" und Trennzeichen) hat jfheins dir jetzt auch genannt. Alle diese Verfahren sind absolut sauber und bieten keinen Spielraum für inkorrekt übertragene Daten (sofern korrekt implementiert natürlich). Welches Verfahren man nimmt, ist Geschmackssache. Trennzeichen sind problematisch bei Binärdaten und durch Pakete mit fester Größe hat man natürlich Probleme bei dynamischen Daten z.b. String mit variabler Länge, etc. Deshalb bevorzuge ich das Längenprefix.

[tomkupitz]

Sooo...

Server:

Code:

procedure TForm1.Button1Click(Sender: TObject);
var bmp: TBitmap;
    buf: array of Byte;
    res, len, bufidx, bufsize: Integer;

    procedure BmpToBuf;
    var i, x, y, w, h: Integer;
        p: PByteArray;

    begin
      w:=bmp.Width;
      h:=bmp.Height;

      bmp.PixelFormat:=pf24bit;

      i:=1234;

      Move(i, buf[0], sizeof(Integer));

      Move(w, buf[sizeof(Integer)], sizeof(Integer));
      Move(h, buf[2*sizeof(Integer)], sizeof(Integer));

      i:=sizeof(Integer)+2*sizeof(Integer);

      for y:=0 to h-1 do
      begin
        p:=bmp.Scanline[y];
        Move(p[0], buf[i], w*3);
        inc(i, w*3);
      end;
    end;

begin
  bmp:=<MacheinScreenshotvomFenster>(Handle);

  len:=sizeof(Integer)+2*sizeof(Integer)+bmp.Height*bmp.Width*3;

  if len mod 1024 <> 0 then
    inc(len, 1024-(len mod 1024));

  SetLength(buf, len);
  BmpToBuf;

  bmp.Free;

  if ServerSocket.Socket.ActiveConnections>0 then
  begin
    bufidx:=0; bufsize:=Length(buf);

    while bufsize>0 do
    begin
      repeat
        res:=ServerSocket.Socket.Connections[0].SendBuf(buf[bufidx], Min(1024, bufsize));
        if res<>1024 then <MacheinePause>(50);
      until res<>-1;

      inc(bufidx, Min(1024, bufsize));
      dec(bufsize, Min(1024, bufsize));
    end;
  end;

  Finalize(buf);
end;

Client:

Code:

var
  buf: array of Byte;
  sz: Integer = -1;

  id, wi, hi: Integer;

procedure TForm1.ClientSocketRead(Sender: TObject; Socket: TCustomWinSocket);
var bmp: TBitmap;
    len, res: Integer;

    procedure BufToBmp;
    var i, x, y, w, h: Integer;
        p: PByteArray;

    begin
      bmp:=TBitmap.Create;
      bmp.PixelFormat:=pf24Bit;

      Move(buf[0], i, sizeof(Integer));

      Move(buf[sizeof(Integer)], w, sizeof(Integer));
      Move(buf[2*sizeof(Integer)], h, sizeof(Integer));

      bmp.Width:=w;
      bmp.Height:=h;

      i:=sizeof(Integer)+2*sizeof(Integer);

      for y:=0 to h-1 do
      begin
        if i+w*3-1>Length(buf) then
          Break;

        p:=bmp.Scanline[y];
        Move(buf[i], p[0], w*3);
        inc(i, w*3);
      end;
    end;

begin
  len:=Length(buf);

  SetLength(buf, len+1024);

  res:=Socket.ReceiveBuf(buf[len], 1024);

  if (sz=-1) and (Length(buf)>=sizeof(Integer)+2*sizeof(Integer)) then
  begin
    Move(buf[0], id, sizeof(Integer));

    Move(buf[sizeof(Integer)], wi, sizeof(Integer));
    Move(buf[2*sizeof(Integer)], hi, sizeof(Integer));

    if id=1234 then
    begin
      sz:=sizeof(Integer)+2*sizeof(Integer)+hi*wi*3;

      if sz mod 1024 <> 0 then
        inc(sz, 1024-(sz mod 1024));
    end;
  end;

  if (sz>-1) and (Length(buf)=sz) then
  begin
    BufToBmp;
    Image1.Picture.Bitmap.Assign(bmp);
    bmp.Free;

    Finalize(buf);
    sz:=-1;
  end;
end;

[Zacherl]

Also tatsächlich nonblocking Sockets?

Eine Sache, die mir grade noch auffällt, ist das Speichern/Laden des Bitmaps. Gibt es einen Grund, warum du nicht z.b. TMemoryStream verwendest? Dann reduziert sich dein kompletter Code mit den ScanLine s nämlich auf ein

Delphi-Quellcode:

I := 1234;
Stream.Write(I);
Bitmap.SaveToStream(Stream)

analog dazu das Laden:

Delphi-Quellcode:

Stream.Read(I);
if (I = 1234) then
  Bitmap.LoadFromStream(Stream)