UDPServer OnUDPRead reagiert nicht

[Anonymos]

Moin,

Ich will eine Konsolenanwendung schreiben, die sich mit einem anderen Computer im Netzwerk über UDP verbindet.
Ich benutze Indy 9
Und hab jetz leider folgendes Problem festgestellt:

Hier erstmal mein QC

Delphi-Quellcode:

type
  vForm = class                 
    UDPClient: TIdUDPClient;
    UDPServer: TIDUDPServer;         
    constructor Create;
    destructor Destroy;
  private
    procedure UDPServerUDPRead(Sender: TObject; AData: TStream; ABinding: TIdSocketHandle);
  end;

var
  Form: vForm;

implementation

constructor vForm.Create;
begin                       
  inherited Create;
  UDPClient := TIdUDPClient.Create(nil);
  UDPClient.Port := Port;
  UDPClient.BroadcastEnabled := true;
  UDPServer := TIdUDPServer.Create(nil);
  UDPServer.DefaultPort := Port;
  UDPServer.BroadcastEnabled := true;
  UDPServer.OnUDPRead := UDPServerUDPRead;       

  UDPServer.Active := true;
end;

destructor vForm.Destroy;
begin
  UDPServer.Active := false;                                    
  UDPClient.Free;    
  UDPServer.Free;
  inherited Destroy;
end;

procedure vForm.UDPServerUDPRead(Sender: TObject; AData: TStream; ABinding: TIdSocketHandle);
begin
  {...}        
end;

Aufgerufen wird das ganze im mom einfach in der Programmroutine:

Delphi-Quellcode:

begin
  // Variablen erstellen
  Form := vForm.Create; 
  with Form do
  try
    UDPClient.Active := true;
    UDPClient.Host := HostPC;                      
    UDPClient.Broadcast('%Anwesenheit%' + ComputerName,Port);  
    UDPClient.Active := false; 
    write('Gesendet'+#10#13);
    sleep(100);
  except
    write('Senden Fehlgeschlagen'+#10#13);
  end;
  // Variablen löschen
  Form.Destroy;
end.

Wobei HostPC zu testzwecken einfach mein eigener Name ist.

Das Senden funktioniert dabei auch super, aber das mit dem Empfangen nicht.
Die oben aufgeführte OnUDPRead wird überhaupt nicht angesprochen.

Ich hab mir gedacht, dass des ganze damit zusammenhängt, dass ich in ner Konsolenanwendung keine Application hab, die die einzenen Prozeduren aufrufen kann.

Gibt es eine Möglichkeit, dass das Programm trotzdem die UDPRead-Prozedure aufruft ?

Danke schonmal für alle Antworten

[sirius]

Ich vermute, dass Indy mit Messages arbeitet, welche du aber in einer Konsolenanwendung nicht beachtest.

[Anonymos]

Das hieße soviel wie:
geht nicht, ich muss ein sinnloses Formular erzeugen, dass ich nicht anzeige um den UDP-Server benutzen zu können?

Gibt es vllt noch andere Möglichkeiten sowas zu machen?
- Eine Application-Anwendung ohne Formular ???
- Oder könnt ich mir en eigenen Message-Handler inne Endlosschleife schreiben, der des entsprechende Ereignis aufruft ???
- Oder ne ganz ne andere Mgl :gruebel:

Ich bin für alles offen ^^

[sirius]

Das hat mit einem Formular nix zu tun. Du musst eine Messageschleife bauen. Brauchst du dringend die Konsole dafür, oder geht es auch völlig ohne visuelle Sachen (Konsole, Form)?

[Anonymos]

Ich muss also doch von Hand en MessageHandler schreiben?

Nein, ich brauch die Konsole nicht unbedingt. Die hab ich nur für Testzwecke nicht auskommentiert.
Gibt es da ne Möglichkeit die die ganze Handarbeit erspaart?

thx

[sirius]

Zitat:

Zitat von Anonymos

Ich muss also doch von Hand en MessageHandler schreiben?

Nein, ich brauch die Konsole nicht unbedingt. Die hab ich nur für Testzwecke nicht auskommentiert.
Gibt es da ne Möglichkeit die die ganze Handarbeit erspaart?

thx

Der sieht so aus:

Delphi-Quellcode:

var msg:Tmsg;
begin
  while getmessage(msg,0,0,0) do
    dispatchmessage(msg);
end;

Um das Programm/diese Schleife zu beenden nutze PostQuitMessage. Und vorher erstellst du ganz normal deine Komponenten.

[Anonymos]

Des problem an der Sache is (fällt mir grad auf):
ich hab ja garkein eigenes Handle, an das ich ne Windows-Message senden könnte.

Oder hab ich doch eins und kenn nur die Funktion nicht um an ebendieses ranzukommen?

mfg

[Astat]

Hallo Anonymos.

Wie sirius schon schrieb, wird die Komponente intern WSAAsyncSelect ohne IOCP, verwenden?!
Also mit Windows Messages arbeiten, wobei diese mit Callbacks (Eventprocedures) public gemacht werden.

• Normalerweise sind solche Komponenten so aufgebaut.

Im Constructor der Komponente wird mit CreateWindows(Ex) ein Fenster erzeugt,
und dieses einer zugehörigen WindowsProcedure übergeben.
Da im Normalfall die Komponente auf ein Fensterobjekt (TForm) geklatscht wird, und für diese in der *.dpr meist schon eine
Messageloop gestartet wird Application.Run, funktioniert das Teil, auch ohne zusaätzlich eine MessageLoop zu implementieren.

Für Konsolenanwendungen, mach das was sirius vorgeschlagen hat, ein Handle brauchst du da nicht.

lg. Astat

[sx2008]

Das ALLERWICHTIGSTE ist, ein UDP Testtool zu haben, mit dem man überprüfen kann, ob die UDP Pakete überhaupt ankommen!
Ohne so ein Tool stochert man doch nur im Nebel.
Neben http://udp-test-tool.software.informer.com/ gibt es viele andere Tools, die UDP senden und empfangen können.

Schritt 1: man startet das Tool auf zwei Rechnern und versucht die gesendeten UDP-Daten zu empfangen
erst wenn das geglückt ist, geht's weiter zu
Schritt 2: man sendet mit dem Indy-Client und empfängt mit dem Tool
Schritt 3: man sendet mit dem Tool und empfängt mit dem Indy-Server
Schritt 4: erst jetzt dürfen Indy-Server und Client direkt miteinander in Kontakt treten

PS: der obige Link scheint wenig zu taugen; man läuft auf eine Zwangsanmeldung. Einfach mal selber suchen...

[Anonymos]

Hallo,

Ich hab mir jetz grad wie gesagt ein kleines UDP-Testproc geschrieben.
1. Von Testproc zu Testproc senden funzt -> ok

Dann hab ich in meinem Programm den UDP-Server komplett auskemmentiert und mit dem UDP-Client gesendet
2. Das Tool hat einwandfrei empfangen -> ok

Soweit so gut.
Dann hab ich Schritt 3 ausprobiert:
Hab also den UDP-Clienten auskommentiert und den Server wieder "einkommentiert"
Hab mit dem Tool gesendet (was aus 1. ja geht)
Hab mit meinem Programm aber nix empfangen können -> Schlecht!

Jetz hab ich in die Nachrichtenroutine von sirius eingebaut, dass er jedesmal, wenn er eine Nachricht empfängt, diese in der Konsole ausgibt.
Un hab festgestellt, ich krieg zwar messages, wenn die Konsole den Focus veriert, wieder bekommt, etc.
Aber wenn ich mit dem Tool was sende, dann kommt überhaupt KEINE Nachricht an mein Programm an.

Kann man auch manuell prüfen, ob so ein UDP-Broadcast angekommen ist ?
z.B. in nem extra Thread ?

Eine Application-Anwendung ohne Formular kann ich nicht erstellen?

mfg

[sirius]

Zitat:

Zitat von Anonymos

Eine Application-Anwendung ohne Formular kann ich nicht erstellen?

mfg

Du nimmst Konsolenanwendung und löschst dieses {$Apptype Console} raus. fertig.

[Anonymos]

Zitat:

Zitat von sirius

Zitat:

Zitat von Anonymos

Eine Application-Anwendung ohne Formular kann ich nicht erstellen?

mfg

Du nimmst Konsolenanwendung und löschst dieses {$Apptype Console} raus. fertig.

Ja, dann wird keine Konsole mehr erzeugt.
Aber es kommt immernoch keine Message an, wenn ich einen UDP-Broadcast sende.

Der UDP-Server wird ganz ordnungsgemäß erstellt und blockiert auch den Port, aber ich weiß nicht, wie ich an dieses OnUDPRead event auslösen kann.

Kann ich des nicht vllt in nem externen Thread machen?

[sirius]

** upps, mein Kind hatte auf der Tastatur rumgespielt ****

[Anonymos]

hm,

ich glaub ich mach des jetz einfach auf die unschöne Art:

Delphi-Quellcode:

Application.ShowMainForm := false;

Auch wenn ich von sowas normalerweise das halte :kotz:

Trotzdem Danke für eure Hilfe :cheers:

[sirius]

Problem gefunden.
Indy (zumindest Version 9) arbeitet doch mit TThread. Und wenn TThread synchronize aufruft, was hier der Fall ist, dann funktioniert das nur mit dem globalen TApplication-Objekt.
Das synchronize beim Empfangen kann man mit der Eigenschaft ThreadedEvent:=true abschalten (allerdings läuft dann onUDPRead im separaten Thread). Das ist aber letztendlich auch keine perfekte Lösung, da man nicht wies, was diese Komponente noch so macht.
Hier ist der Testcode, aber er ist nicht empfehlenswert:

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

uses
  SysUtils, Windows, idSocketHandle, idUDPServer,
  Classes;


type TServer=Class
       Constructor Create;
       Destructor Destroy; override;
      private
       FUDPServer:TidUDPServer;
       procedure onUDPRead(Sender: TObject; AData: TStream;
                           ABinding: TIdSocketHandle);
      public
       procedure Run;
     end;


{ TServer }

constructor TServer.Create;
begin
  FUDPServer:=TidUDPServer.Create(nil);
  FUDPServer.OnUDPRead:=onUDPRead;
  FUDPServer.DefaultPort:=21000;
  FUDPServer.ThreadedEvent:=true;
  FUDPServer.Active:=true;
end;

destructor TServer.Destroy;
begin
  FUDPServer.Free;
  inherited;
end;

procedure TServer.onUDPRead(Sender: TObject; AData: TStream;
  ABinding: TIdSocketHandle);
var s:string;
begin
  setlength(s,AData.Size);
  AData.Read(s[1],length(s));
  writeln(s);
  if s='Ende' then PostquitMessage(0);
end;

procedure TServer.Run;
var msg:TMsg;
begin
  while getmessage(msg,0,0,0) do
    dispatchmessage(msg);
end;



var Server:TServer;
begin
  Server:=TServer.Create;
  try
    Server.Run;
  finally
    Server.Free;
  end;
end.

Ich würde lieber eine eigne UDP-Komponente nehmen.

[sirius]

Hier eine andere Möglichkeit:

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

uses
  MEssages, Classes, SysUtils, Windows, Winsock;


const cPort=12000;
      WM_Socket=WM_User;


type TProgram=class
       Constructor Create;
       Destructor Destroy; override;
      private
       FSocket:TSocket;
       Fwnd:hwnd;
       procedure WMSocket(var msg:TMEssage); message WM_Socket;
      protected
       procedure WndProc(var msg:TMessage);
       procedure DoUDPRead(const IP:String; Port:Word;
                           const msg:String); virtual;
      public
       procedure Run;
     end;



procedure showError(const msg:String);
begin
  writeln(msg);
  readln;
end;



procedure startProgram;
var wsadata:TWSAData;
    myProgram:TPRogram;
begin
  if WSAStartup($0202,wsadata)<>0 then
    showError('Fehler beim Initialisieren der Sockets');
  try
    myProgram:=TProgram.Create;
    try
      myProgram.Run;
    finally
      myProgram.Free;
    end;
  except
    on e:Exception do
      showError(e.Message);
  end;
  WSACleanup;
end;

{ TProgram }

constructor TProgram.Create;
var addr:TSockAddrIn;
begin
  Fwnd:=allocatehwnd(wndProc);

  FSocket:=socket(af_inet,SOCK_DGRAM,IPPROTO_UDP);
  if FSocket=INVALID_SOCKET then
    raise Exception.Create('Socket: '+syserrormessage(wsagetlasterror));

  addr.sin_family:=af_inet;
  addr.sin_port:=htons(cPort);
  addr.sin_addr.S_addr:=INADDR_ANY;
  if bind(FSocket,addr,sizeof(addr))=Socket_Error then
    raise Exception.Create('Bind: '+syserrormessage(wsagetlasterror));

  WSAAsyncSelect(FSocket,Fwnd,WM_Socket,FD_Read);


end;

destructor TProgram.Destroy;
begin
  closesocket(FSocket);
  DeallocateHWnd(Fwnd);
end;

procedure TProgram.Run;
var msg:Tmsg;
begin
  while getmessage(msg,0,0,0) do
    dispatchmessage(msg);
end;

procedure TProgram.WMSocket(var msg: TMEssage);
var addr:TSockAddrIn;
    addrlen:Integer;
    buf:string;
    len:Integer;
    msgbuf:String;
    res:Integer;
    err:Integer;
    Port:Word;
    IP:string;
begin
  addrlen:=sizeof(addr);
  msgbuf:='';
  repeat
    setlength(buf,1024);
    len:=length(buf);
    res:=recvfrom(FSocket,buf[1],len,0,addr,addrlen);
    if res=socket_error then
    begin
      err:=wsagetlasterror;
      case err of
        WSAEWOULDBLOCK: break;
        WSAEMSGSIZE: begin
          msgbuf:=msgbuf+buf;
          //hier evtl noch Addresse merken
        end;
        else
          raise Exception.Create(syserrormessage(err));
      end;
    end else
    begin
      setlength(buf,res);
      msgbuf:=msgbuf+buf;
      break;
    end;
  until false;

  Port:=ntohs(addr.sin_port);
  IP:=inet_ntoa(addr.sin_addr);

  //Abbruchbedingung:
  if msgBuf='Ende' then PostQuitMEssage(0);

  DoUDPRead(IP,Port,msgbuf);
end;

procedure TPRogram.DoUDPRead(const IP:string; Port:Word; const Msg:String);
begin
  writeln(IP+':'+inttostr(Port)+'  '+Msg);
end;

procedure TProgram.WndProc(var msg: TMessage);
begin
  try
    dispatch(msg);
  except
    on e:Exception do
      showerror(e.Message);
  end;
end;

begin
  startProgram;
end.

[sirius]

Mir fällt grad noch etwas ein. Wenn du ein "einfaches" Programm als UDPServer basteln willst, welches nur auf Ereignisse am UDP-Port reagieren soll und sonst nichts, dann kannst du auch recvfrom blockierend aufrufen. Dadurch musst du dich weder mit Events noch mit Messages rumschlagen. Das sähe etwa so aus (WINAPI-Befehle verwendet):

Delphi-Quellcode:

//ohne Fehlerbearbeitung
uses Winsock;

var wsaData:TWsaData;
    udpSocket:TSocket;
    addr:TSockAddrIn;
    buf:array[0..511] of AnsiChar;
begin
  //Variablen initialisieren
  addr.sin_family:=af_inet; 
  addr.sin_port:=htons(cPort); //bsp: const cPort=12000;
  addr.sin_addr.S_addr:=INADDR_ANY; 
 


  WSAStartUp($0202,wsadata); //Socket-DLL laden
  udpSocket:=socket(af_inet,Sock_DGram,IPProto_UDP); //Socket initialisieren
  bind(udpSocket,addr,sizeof(addr)); //UDP-Socket an Port cPort für alle Netwerkverbindungen (INADDR_ANY) binden
  

  repeat
    //recv muss besser ausgebaut werden
    addrlen:=sizeof(addr);
    recvfrom(udpSocket,buf,512,addr,addrlen); //UDP_Packet empfangen (und warten bis eins ankommt!)
     
    //in addr ist der Absender enthalten und in buf die Message
    //Fehlerbehandlung nicht vergessen!
    //Umwandlung des Ports von Big Endian zu Little Endian mittels ntohs(...)
    //Umwandlung der Adresse von 32Bit zu String mittels inet_ntoa(...)

  until ...;
end;

Allerdings kann das Programm jetzt nichts anderes machen, als ganz ruhig auf Nachrichten am Port "cPort" zu warten und ggf. darauf zu reagieren. Andere Interaktionen sind nicht möglich.

[Anonymos]

Hey,

Danke für die vielen Antworten

Also des mit dem UDPServer hab ich vorher auch schon ohne Syncronize probiert.
Hat nich gefunzt. -> Weiter, in den QT von den Indy hatte ich aber keine Lust mich einzulesen und nach möglichen Fehlerquellen zu suchen.

Ich hatte bisher noch nie mit Sockets gearbeitet, hab mich jetz aber mal en bissl damit beschäftigt und ich muss sagen, mit etwas anfänglichen Problemen find ich des jetz eigentlich richtig gut. Hab mir den Code jetz noch en bissl verändert/angepasst und funzt einwandfrei. :thumb:

Also dann nochmal DANKE

Des Problem wär dann hiermit gelöst ---