Probleme beim Empfangen von UDP-Paketen

[heltef]

Guten Abend zusammen,

ich habe folgendes Problem...
Delphi empfängt nur die Daten Udp Pakete, wenn Wireshark geöffnet ist. Sobald ich es beende empfängt delphi auch nichts mehr. Ich habe die Windows Firewall abgeschaltet, die .Exe-Datei zu den Vertrauenswürdigen Programmen hinzugefügt, die .Exe-Datei als Admin ausgeführt, Den Port in der Firewall freigegeben und avast komplett deaktiviert.

Die UDP-Pakete werden von einem Arduino-Mikrocontroller versendet.

Bei der IdUDPServer Komponente habe ich den Port eingestellt (ich verwende den Port: 50001) und den Hacken bei Active gesetzt. In dem Ereignis wird bisher nur das empfangene in einem Memo ausgegeben. Was auch alles klappt solange Wireshark geöffnet ist.

Mich würde es freuen wenn ihr mir helfen könnt. Danke schonmal.
Gruß Fabi

[himitsu]

Was passiert, wenn du Wireshark zwischendurch beendest oder erst später startest?

Zitat:

Zitat von heltef (Beitrag 1300342)

In dem Ereignis wird bisher nur das empfangene in einem Memo ausgegeben.

Ich hoffe das wird über TThread.Synchronize ans Memo übergeben?

[TheMiller]

I would tell you a joke about UDP, but you probably wouldn't get it. :lol:

[Captnemo]

Installiert nicht Wireshark irgendwas namens pcap in die Netzwerkverbindung? Vielleicht liegt das Problem ja da. Ggf. mal Wireshark bzw. pcap deinstallieren und dann mal probieren. Oder einfach mal in einer VM.

Und auch mal den Virenscanner beäugen.

[Sherlock]

Zitat:

Zitat von DJ-SPM (Beitrag 1300419)

I would tell you a joke about UDP, but you probably wouldn't get it. :lol:

Oh, I got it :thumb:

Sherlock

[BUG]

Zitat:

Zitat von DJ-SPM (Beitrag 1300419)

I would tell you a joke about UDP, but you probably wouldn't get it. :lol:

Hach, diese ganze Protolol-Geschichte war schon schön :mrgreen:

[TheMiller]

Zitat:

Zitat von BUG (Beitrag 1300423)

Hach, diese ganze Protolol-Geschichte war schon schön :mrgreen:

Ui, da haben wir aber Lesestoff ;) Danke!

[heltef]

Ich habe mein Programm jetzt einfach mal auf einem neu Installierten Rechner ausprobiert. Da geht es auch nicht..

Wenn ich Wireshark beende empfängt Delphi auch nichts mehr, aber wenn ich Wireshark wieder öffne dann geht es auch wieder im Delphi Programm. Also es passiert in meinem Delphi Programm nichts solange ich nicht Wireshark öffne.

@himitsu
Wie meinst du des mit "TThread.Synchronize"?
So sieht es im Moment bei mir aus:

Code:

procedure TForm1.IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
  const AData: TIdBytes; ABinding: TIdSocketHandle);
var
  sText:String;
begin
  sText := BytesToString(AData);
  Memo1.Lines.Add(sText);
end;

Fabian

[MichaelT]

Ferndiagnosen sind schwierig... Das ist schon ein wenig alt.
https://ask.wireshark.org/questions/...with-wireshark

Was steht in den Packeln drinnen?

Zitat:

Zitat von heltef (Beitrag 1300342)

Guten Abend zusammen,

ich habe folgendes Problem...
Delphi empfängt nur die Daten Udp Pakete, wenn Wireshark geöffnet ist. ...

[himitsu]

IdUDPServer1.OnUDPRead wird doch bestimmt im Thread der er Connection ausgeführt, was nicht der HauptThread ist. :?:
Die VCL ist nicht threadsicher und man darf "niemals" unsynchronisiert außerhalb des Hauptthreads drauf zugreifen.

Wireshark häckt sich böse in die Connections rein, verstellt hier und da etwas und wer weiß was dadurch alles verändert wird, welches hier eine Auswirkung zeigt.

[heltef]

Ich hab hier mal ein Screenshot von einem Paket in Wireshark
Anhang 43096

Anhang 43097


@himitsu
Ich habe in Delphi mit Threads noch nie gearbeitet. Könntest du mir zeigen wie ich es korrekt lösen würde? Danke

[Captnemo]

Naja, wenn's auf einem jungfräulichen Rechner ohne Wireshark auch nicht geht, wird's wohl am Source liegen. Poste doch mal den kompletten Source.

[heltef]

Hier ist der Komplette Code... Viel ist da zwar nicht drin, aber vielleicht habe ich auch was vergessen

Code:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, IdUDPServer, IdGlobal, IdSocketHandle,
  IdComponent, Vcl.StdCtrls, IdBaseComponent, IdUDPBase;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    IdUDPServer1: TIdUDPServer;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure IdUDPServer1Status(ASender: TObject; const AStatus: TIdStatus;
      const AStatusText: string);
    procedure IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
      const AData: TIdBytes; ABinding: TIdSocketHandle);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  IdUDPServer1.DefaultPort:=50001;
  IdUDPServer1.Active:=true;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  IdUDPServer1.Active:=false;
end;

procedure TForm1.IdUDPServer1Status(ASender: TObject; const AStatus: TIdStatus;
  const AStatusText: string);
begin
  Memo1.Lines.Add('Status'+AStatusText);
end;

procedure TForm1.IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
  const AData: TIdBytes; ABinding: TIdSocketHandle);
var
  sText:String;
begin
  sText := BytesToString(AData);
  Memo1.Lines.Add(sText);
end;

end.

[himitsu]

Zitat:

Zitat von Captnemo (Beitrag 1300531)

wird's wohl am Source liegen.

Wie MichaelT es erwähnte, muß es garnicht am eigenem Programm liegen, sondern am Code/Firmware/Hardware des Senders (Arduino).
Wireshark verbiegt hier einiges an der Konfiguration, da kann es z.B. sein, daß "ungültige" Packete plötzlich vom System durchgelassen werden, welche sonst abgelehnt würden.

Über TThread.Synchronize und anonyme Methoden kann man sehr leicht den Thread wechseln.
Hier von irgendeinem Thread in den MainThread (wenn man sich in einer TThread-Instanz befindet, dann am Besten direkt

Delphi-Quellcode:

Synchronize(procedure ...

).
Und mit TThread.CreateAnonymousThread in einem Thread ausführen (da, wo man sonst von TThread ableitet und Execute überschreibt ... nur halt mal bissl anders).
Bei anonymen Methoden kann man schön Variablen übergeben lassen, was sonst bissl schwerer wird, da Threadmethoden für Synchronize und Execute keine Parameter haben dürfen.

Delphi-Quellcode:

procedure TForm1.IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
  const AData: TIdBytes; ABinding: TIdSocketHandle);
var
  sText: String;
begin
  sText := BytesToString(AData);  // das kann im Thread bleiben (muß es aber nicht ... kommt drauf an, ob BytesToString threadsave ist)
  TThread.Synchronize(nil, procedure
    begin
      Memo1.Lines.Add(sText);  // Zugriff auf's Memo muß in den Hauptthread
    end;
end;

[heltef]

Hallöchen zusammen,

ich hab hier auch mal den Code vom Mikrocontroller (Arduino)
zur Hardware.. Der Arduino ist mit einem ENC28J60 (Netzwerk-Controller) verbunden.

Code:

#include <EtherCard.h>

static unsigned int CSPIN_ENC28J60 = 53;

byte macMy[]         = {0x00, 0x22, 0xF9, 0x01, 0x30, 0xDA }; //MAC vom Arduino
byte ipMy[]          = {192, 168, 2, 200}; //IP vom Arduino
byte ipDestination[] = {192, 168, 2, 99}; //Ziel Ip Des Paketes
byte ipGateway[]     = {192, 168, 2, 1}; //Router IP

const int portPcEmpfangen = 50001;

byte Ethernet::buffer[1000];

char msg[] = {"Hello World"};

void setup() {
  ether.begin(sizeof Ethernet::buffer, macMy, CSPIN_ENC28J60);
  ether.staticSetup(ipMy, ipGateway);

  while (ether.clientWaitingGw())
  {
    ether.packetLoop(ether.packetReceive());
  }
}

void loop()
{
  ether.sendUdp(msg, sizeof msg, portPcEmpfangen, ipDestination, portPcEmpfangen);

  word len = ether.packetReceive(); // go receive new packets
  word pos = ether.packetLoop(len); // respond to incoming pings

  ether.packetLoop(ether.packetReceive());
  delay(1000);
}

Und hier noch die Parameter der Methode sendUdp:

void EtherCard::sendUdp (const char* data, uint8_t len, uint16_t sport, const uint8_t* dip, uint16_t dport)

Sends a UDP packet.
Parameters
data Pointer to data
len Size of payload (maximum 220 octets / bytes)
sport Source port
dip Pointer to 4 byte destination IP address
dport Destination port

-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/

Mein Delphi Programm habe ich in der Sache Threads nachgearbeitet

Gruß Fabi

[Captnemo]

Warum schreibst du dir nicht schnell mal ein Windowsprogramm, welches dir die gleichen Daten von einem Windows-PC schickt. Dann weißt du recht schnell ob es beim Empfangen hapert, und kannst das gleich mal im Netzwerk auf verschiedenen Rechner ausprobieren.

[Mavarik]

Zitat:

Zitat von himitsu (Beitrag 1300488)

IdUDPServer1.OnUDPRead wird doch bestimmt im Thread der er Connection ausgeführt, was nicht der HauptThread ist. :?:

"wird doch bestimmt?"

emmm... nööö :stupid:

Zitat:

Zitat von ..\Source\Indy10\Core\IdUDPServer.pas

Delphi-Quellcode:

        // and only synchronize the OnUDPRead event handler so that descendants
        // do not need to be synchronized unnecessarily. Probably just have
        // TIdUDPServer.DoUDPRead() use TIdSync when ThreadedEvent is false...
        if FServer.ThreadedEvent then begin
          UDPRead;
        end else begin
          Synchronize(UDPRead);
        end;

Mavarik

[Sir Rufo]

Schön dass man gar nicht hoffen/glauben muss ob da was in welchem Thread-Kontext läuft, mann kann es einfach abfragen:

Delphi-Quellcode:

if TThread.Current.ThreadId = MainThreadID then
  // ich im MainThread
else
  // ich NICHT im MainThread

[mjustin]

Zitat:

Zitat von Sir Rufo (Beitrag 1300823)

Schön dass man gar nicht hoffen/glauben muss ob da was in welchem Thread-Kontext läuft, mann kann es einfach abfragen:

Delphi-Quellcode:

if TThread.Current.ThreadId = MainThreadID then
  // ich im MainThread
else
  // ich NICHT im MainThread

Für Anwender von Delphi 2009: das kompiliert zwar, ist aber erst in einer späteren Version (Build 14.0.3455.22156) brauchbar: http://qc.codegear.com/wc/qcmain.aspx?d=67726 (darin ist auch ein Workaround enthalten)

Siehe auch: Delphi TThread.CurrentThread and EAccessViolation - Is This a Bug or My Incompetence..?

[heltef]

Hallöchen zusammen,

ich habe es mal gemacht wie Captnemo es vorgeschlagen hatte.. Ich hab ein Windows Programm geschrieben und siehe da... Es funktioniert alles ohne Wireshark.

So ist Delphi ausgeschlossen und muss somit wohl am Mikrocontroller liegen. Ich werde jetzt mal mit Wireshark die Pakete vergleichen und mal sehen wo sie sich unterscheiden.

Dankeschön für eure Hilfe. Noch ein schönes Restwochenende
Fabi

[pertzschc]

Ich werfe mal noch die Vermutung in den Raum, dass Dein Microcontroller die Pakete an die falsche IP-Adresse sendet. In Deinem Coding war zumindest eine Destination "hardgecoded".

Delphi-Quellcode:

byte ipDestination[] = {192, 168, 2, 99}; //Ziel Ip Des Paketes

Wenn das so ist, dann könnte der Rechner mit dem Delphiprogramm ein andere Adresse als die obige zugewiesen bekommen und empfängt dann natürlich nichts. Soweit funktioniert es dann korrekt, nur dass Du Dein Ziel vom Mikrocontroller aus gesehen nicht erreichst.

Was dann Wireshark beim Starten auf dem Rechner macht ist, den Empfangsmodus auf den Promiscuous Mode umzustellen, um alle Pakete des Netzwerkes zu empfangen. Damit landen dann auch alle nicht richtig adressierten Pakete auf dem Rechner.

Grüße, Christoph

[Memnarch]

Einmal das, zweitens:
Hast du mehrere Netzwerkinterfaces? Und auf welchem lauscht der UDPServer?