TCP Filelistening

[DeddyH]

Den 2. Code entspricht ja meinem, nur dass ich das FindClose noch untergebracht habe.

[Klaus01]

.. wenn eine Variable sFileList heißt,
warum verwendest Du dann keine?
Eine StringList würde sich hier anbieten.

Dann benötigst Du noch ein Übertragungs-Protokoll.

z.B.

fileCount:8Byte
fileNumber: 8Byte
fileName:1024 Byte
fileSize: 8Byte
fileData: fileSize

fileNumber: 8Byte
fileName:1024 Byte
fileSize: 8Byte
fileData: fileSize

Grüße
Klaus

[Briand]

Also ich hab das nun so gelöst weiss zwar nicht ob es der richtige Weg ist aber es funktioniert

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Winapi.Messages, SysUtils, System.Variants, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.Buttons, Web.Win.Sockets,
  System.Win.ScktComp, Vcl.ComCtrls, Vcl.StdCtrls, Vcl.ExtCtrls;
type
  TForm1 = class(TForm)
    SpeedButton1: TSpeedButton;
    client: TClientSocket;
    server: TServerSocket;
    SpeedButton2: TSpeedButton;
    lv1: TListView;
    Edit1: TEdit;
    Procedure SpeedButton1Click(Sender: TObject);
    Procedure clientError(Sender: TObject; Socket: TCustomWinSocket; ErrorEvent: TErrorEvent; var ErrorCode: Integer);
    Procedure serverClientRead(Sender: TObject; Socket: TCustomWinSocket);
    Procedure clientRead(Sender: TObject; Socket: TCustomWinSocket);
    Punction ListFiles(sDir: String): String; 
    Punction GetFileSize(sFile: PChar): Int64;
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }

  end;

var
  Form1: TForm1;
  LI2: TListItem;
  ListedFiles: Ansistring;
  TotalFiles: integer;
  i : integer;
implementation

Uses Unit3;
  {$R *.dfm}

Function ListFiles(sDir: String): String;
Var
  sFileName: String;
  sFileList: String;
  sSizeList: String;
  sRec: TWin32FindData;
  findHandle: THandle;
  Begin
  totalfiles := 0;
 If AnsiLastChar(sDir) <> '\' Then
 Begin
   sDir := sDir + '\';
 End;
  Try
    findHandle := FindFirstFile(PChar(sDir + '*.*'), sRec);
    If findHandle <> INVALID_HANDLE_VALUE Then
      Repeat
        sFileName := sRec.cFileName;
        If (sRec.dwFileAttributes And FILE_ATTRIBUTE_DIRECTORY) <> 0 Then Begin
        End
        Else
        Begin
        sFileList := sFileList + sFileName +'¦'+ IntToStr(GetFileSize(PChar(sDir + sFileName))) + '|';
        totalfiles := totalfiles + 1;
        End;
      Until FindNextFile(findHandle, sRec) = False;
  Finally
  End;
  Result :=  sFileList;
End;

Function GetFileSize(sFile: PChar): Int64;
Var
  fFile: THandle;
  wFD: TWIN32FINDDATA;
Begin
  Result := 0;
  If Not FileExists(sFile) Then
  Begin
  Exit;
  End;
  fFile := FindFirstFile(PChar(sFile), wFD);
  If fFile = INVALID_HANDLE_VALUE Then
  Begin
  Exit;
  End;
  Result := (wFD.nFileSizeHigh * (Int64(MAXDWORD) + 1)) + wFD.nFileSizeLow;
  Windows.FindClose(fFile);
End;

procedure TForm1.SpeedButton1Click(Sender: TObject);
begin
form1.server.Socket.Connections[0].SendText('FileStart|');
form1.lv1.Clear;
end;

procedure TForm1.clientError(Sender: TObject; Socket: TCustomWinSocket; ErrorEvent: TErrorEvent; var ErrorCode: Integer);
begin
errorcode := 0;
end;

procedure TForm1.clientRead(Sender: TObject; Socket: TCustomWinSocket);
var cData, Ccmd: string;

begin
 cData := socket.ReceiveText;
 Ccmd :=  copy(cData,0,pos('|',cData)-1);

 if cCmd = ('FileStart') then
 begin
 ListedFiles := ListFiles('C:\MeineFotos\ordner1');
 form1.Caption := inttostr(totalfiles);
if totalfiles = 0 then
begin
  exit
end;
 form1.client.Socket.SendText('FileADD|'+ copy(ListedFiles,0,pos('|',ListedFiles)-1));
 Delete(ListedFiles,1,pos('|',ListedFiles));
 totalfiles := totalfiles -1;
 end;

 if cCmd = ('FileNEXT') then
 begin
 if totalfiles = 0 then
 begin
 exit
 end;

 if Totalfiles = 1 then
 begin
 form1.client.Socket.SendText('FileEND|'+ copy(ListedFiles,0,pos('|',ListedFiles)-1));
 end
 else begin
 form1.client.Socket.SendText('FileADD|'+ copy(ListedFiles,0,pos('|',ListedFiles)-1));
 Delete(ListedFiles,1,pos('|',ListedFiles));
 totalfiles := totalfiles -1;
 end;
 end;

end;

procedure TForm1.serverClientRead(Sender: TObject; Socket: TCustomWinSocket);
var
  sData, sCmd: string;

begin
 sData := Socket.ReceiveText;
 sCmd := copy(SData,0,pos('|',sData)-1);

 if sCmd = ('FileADD') then
 begin
 Delete(sdata,1,pos('|',sdata));
 LI2 := form1.lv1.Items.Add;
 LI2.Caption := copy(sdata,0,pos('¦',sdata)-1);
 Delete(sdata,1,pos('¦',sdata));
 LI2.SubItems.Add(sdata);
 form1.server.Socket.Connections[0].SendText('FileNEXT|');
 end;

 if sCmd = ('FileEND') then
 begin
 Delete(sdata,1,pos('|',sdata));
 LI2 := form1.lv1.Items.Add;
 LI2.Caption := copy(sdata,0,pos('¦',sdata)-1);
 Delete(sdata,1,pos('¦',sdata));
 LI2.SubItems.Add(sdata);

 end;

end.

[Aphton]

Immernoch fehlerhaft!
Das ursprngliche Problem, wo ich eine Lösung dafür in meinem zweiten Beitrag beschrieben habe, ist ungelöst..

Edit1: Kann sein, dass ReceiveText() und SendText() das per LineBreak Marker doch regelt.. In dem Fall sollte es passen; muss halt nur einer bestätigen bzw. nachkucken.

Edit2: Ich hab schnell nachgekuckt:

Delphi-Quellcode:

function TCustomWinSocket.ReceiveText: AnsiString;
begin
  SetLength(Result, ReceiveBuf(Pointer(nil)^, -1));
  SetLength(Result, ReceiveBuf(Pointer(Result)^, Length(Result)));
end;

function TCustomWinSocket.SendText(const s: AnsiString): Integer;
begin
  Result := SendBuf(Pointer(S)^, Length(S) * SizeOf(AnsiChar));
end;

Folglich kannste mein Edit1 vergessen --> dein Problem ist weiterhin nicht gelöst! Der Fehler wird nur selten auftreten (bei hoher RTT und niedriger Window/Buffersize)

[Briand]

Also Aphton ich verstehe da leider nur Bahnhof.....Bin halt ein Neuling in dem Bereich.

Wie müsste mann dann das machen damit es richtig funktionier?

[Briand]

hmmmm bin nach fast 2 Wochen leider immer noch nicht weiter....

[Aphton]

Wie bereits erwähnt, wenn du 10 Bytes/Zeichen schicken willst, wird nicht garantiert, dass auch alle 10 geschickt werden...
Die Sendefunktion liefert dir nen Integer zurück, der dir die tatsächliche Anzahl an geschickten Bytes sagt.

Wenn du es lokal testest, wirst du auf das Problem nicht stoßen, da eben der Ping einfach zu gering ist.

Beispiel, wie so eine Kommunikation aussehen könnte, wenn man zwei Nachrichten "abCDef" und "Hallo" schicken würde:

Code:

Sende: "abCDef"
Sende liefert zurück 2 - dh. "ab" wurde geschickt, daher -->

Sende: "CDef"
Sende liefert zurück 0 - konnte nichts schicken; warum auch immer -->

Sende: "CDef"
Sende liefert zurück 4 -> passt

Sende: "Hallo"
Sender liefert zurück 5 -> passt

####

Empfange 1000 Zeichen:
Empfange liefert 0 zurück

Empfange 1000 Zeichen:
Empfange liefert 3 zurück -> "abC"

Empfange 1000 Zeichen:
Empfange liefert 1 zurück -> "D"

Empfange 1000 Zeichen:
Empfange liefert 5 zurück -> "efHal"

Empfange 1000 Zeichen:
Empfange liefert 2 zurück -> "lo"

Bei diesem Verhalten kannst du nun folgende Rückschlüsse ziehen:
- Du bist dafür zuständig, dass du deine Daten wirklich vollständig überträgst
- Beim Empfangen musst du auch Pakete unterscheiden können

Das Problem kann man - wenn man es ordentlich machen will - ganz elegant über Streams lösen:
Pro Socket ein Sende & Empfangstream instanzieren.

Alles was geschickt werden soll, wird in ein Paket gekapselt:
Ein Paket besteht aus [Größe][Daten]

Zum Schicken schreibt man die Pakete hinten im Sendestream rein.
Der Sendestream wird periodisch abgearbeitet und wie beim Beispiel oben wird der Komplette Inhalt des Streams versucht zu versenden und versendete Bytes werden verworfen!

Beim Empfangen puffert man auch alles in den Empfangsstream hinten rein. Der Empfangsstream muss auch perodisch abgerabeitet werden und es muss nach folgendes geprüft werden:
- habe ich GrößeInBytes(Paket.[Größe]) empfangen?
- falls ja, habe ich GrößeInBytes(Paket.[Größe]) + Paket.[Größe] empfangen?
- falls ja, dann erhält der Empfangsstream mindestens ein vollständiges Paket, das rausgenommen werden kann

Beispiel (hier gehen wir mal davon aus, dass die [Größe] 1 Byte groß ist):

Code:

SendePuffer.send("abCDef")
-> SendePuffer erhält folgenden Datenstrom [6]["abCDef"]

SendePuffer.send("Hallo")
-> SendePuffer erhält folgenden Datenstrom [5]["Hallo"]

Sendepuffer sieht so aus:
[6]["abCDef"][5]["Hallo"]

Periodisches abarbeiten des Sendepuffers:
Sende.. liefert zurück: 2 -->
["bCDef"][5]["Hallo"]

Sende... liefert zurück: 8 -->
["llo"]

Semde... liefert zurück: 3 -->
Leer

####

Empfange.. liefert zurück: 3 -->
Empfangspuffer:
[6]["ab"]

Paket entnehmbar?:
- ist die Größe des Empfangspuffers (3) > GrößeInBytes(Paket.[Größe]) (1) --> ja
- ist GrößeInBytes(Paket.[Größe]) (1) + Paket.[Größe] (=[6] = 6) <= Größe des Empfangspuffer?
also ist 1+6 <= 3 --> nein --> folglich kann man kein Paket rausfischen

Empfange.. liefert zurück: 10 -->
Empfangspuffer:
[6]["abCDef"][5]["Hallo"]

Paket entnehmbar?:
- 13 > 1 --> ja
- 1 + 6 <= 13 --> ja
- dh. 1 + 6 Bytes können aus dem Empfangspuffer entnommen werden
Paket: [6]["abCDef"]
Empfangspuffer:
[5]["Hallo"]

Paket entnehmbar?:
- 6 > 1 --> ja
- 1 + 5 <= 6 --> ja
- dh. 1 + 5 Bytes können aus dem Empfangspuffer entnommen werden
Paket: [5]["Hallo"]
Empfangspuffer:
Leer
[5]["Hallo"]

Alles was du nun zu tun hast, ist genau das hier umzusetzen.
Mehr nicht.

Achja, kann durchaus sein, dass es irgendwelche fertige Bibliotheken gibt, die das hier bereits für dich tun.. Da müsstest du dich erkundigen; aber an sich ist das eig. in 20 Minuten programmiert. Sollte ne Fingerübung sein.

Die Beschreibung könnte an manchen Stellen unverständlich sein; hab nicht drüber gelesen.. Sollte aber trotzdem helfen!