UDPServer OnUDPRead reagiert nicht

[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 ---