1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

uses
  ..., WinSock; // für den Typ in_addr

// Nachricht an den angegebenen Host senden
procedure TForm1.BtnSendClick(Sender: TObject);
begin
  UdpSockUtil1.RemoteHost := RemoteHost.Text;
  UdpSockUtil1.RemotePort := StrToIntDef(RemotePort.Text,12345);
  UdpSockUtil1.SendText(Input.Text);
end;

// Nachricht an alle Hosts im Netzwerk senden
procedure TForm1.BtnBroadcastClick(Sender: TObject);
begin
  UdpSockUtil1.RemotePort := StrToIntDef(RemotePort.Text,12345);
  UdpSockUtil1.BroadcastText(Input.Text);
end;

// Ereignis: Nachricht eingetroffen
procedure TForm1.UdpSockUtil1Receive(Sender: TObject);
var
  Msg: String;
  vonIP: in_addr; // für diesen Typ:  uses ..., WinSock;  ergänzen!
begin
  // Nachricht einlesen; in vonIP wird die Absender-IP zurückgegeben
  Msg := UdpSockUtil1.ReceiveText(vonIP);
  // Länge der Nachricht, die Nachricht und den Absender anzeigen
  ShowMessage(IntToStr(Length(Msg))+#13+Msg+#13+inet_ntoa(vonIP));
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

[...]
uses
  Windows, Messages, SysUtils, Classes, WinSock, SyncObjs;

resourcestring
  sWindowsSocketError = 'Windows-Socket-Fehler: %s (%d), auf API ''%s''';
  sCannotCreateSocket = 'Es kann kein neuer Socket erzeugt werden';

const
  USU_WM_ASYNCSELECT = WM_USER +4711; // eigene Fensternachricht
[...]                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

[Warnung] UdpSockUtil.pas(230): Konstantenausdruck verletzt untere Grenzen
[Fehler] UdpSockUtil.pas(263): Undefinierter Bezeichner: 'DeallocateHWnd'
[Fehler] UdpSockUtil.pas(301): Undefinierter Bezeichner: 'AllocateHWnd'
[Fehler] UdpSockUtil.pas(301): Nicht genügend wirkliche Parameter
[Warnung] UdpSockUtil.pas(373): Konstantenausdruck verletzt untere Grenzen
[Warnung] UdpSockUtil.pas(387): Der Vergleich ergibt immer Falsch
[Warnung] UdpSockUtil.pas(406): Der Vergleich ergibt immer Falsch
[Warnung] UdpSockUtil.pas(496): Konstantenausdruck verletzt untere Grenzen
[Fataler Fehler] dclusr50.dpk(34): Verwendete Unit 'UdpSockUtil.pas' kann nicht compiliert werden                    

1:
2:

[Fehler] UdpSockUtil.pas(263): Undefinierter Bezeichner: 'DeallocateHWnd'
[Fehler] UdpSockUtil.pas(301): Undefinierter Bezeichner: 'AllocateHWnd'                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

// vom Empfänger-Socket lesen; Puffer-Variante  
function TUdpSockUtil.ReceiveBuf(var Buf; BufSize: Integer; var RemoteAddr: in_addr; Flags: Integer = 0): Integer;  
  var  
    FromAddr: TSockAddrIn;  
    FromAddrLen: Integer;  
    ErrorCode: Integer;
    RemotePort: Integer;  
begin  
  FSocketLock.Enter;  
  try  
    Result := 0;  
    RemoteAddr.S_addr := -1;  
    if (FRecvSock <> INVALID_SOCKET) then begin  
      FromAddrLen := SizeOf(FromAddr);  
      ZeroMemory(@FromAddr,FromAddrLen);  
      Result := WinSock.RecvFrom(FRecvSock,Buf,BufSize,Flags,FromAddr,FromAddrLen);  
      if (Result = SOCKET_ERROR) then begin  
        ErrorCode := WSAGetLastError;  
        Result := 0;  
        if (ErrorCode <> WSAEWOULDBLOCK) then  
          if Assigned(FOnError) then begin  
            FOnError(Self,ErrorCode);  
            Abort;  
          end  
          else  
            raise EUSUError.CreateResFmt(@sWindowsSocketError,  
              [SysErrorMessage(ErrorCode), ErrorCode, 'RecvFrom']);  
      end  
      else begin
        RemoteAddr := FromAddr.sin_addr;  
        RemotePort := ntohs(FromAddr.sin_port); // Achtung! network-byteorder!
      end;
    end;  
  finally  
    FSocketLock.Leave;  
  end;  
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:

unit uglsn_engine;

interface

uses UdpSockUtil, SysUtils, Classes, IdIPWatch, Dialogs;

const
  GLSN_DEFAULTPORT = 42768;
  GLSN_STR = 0;
  GLSN_POS = 1;

type
  TGLS_IPString = string[18];   { size: 18    4*3+3 }
  TGLS_SString = string[20];    { size: 20          }
  TGLS_LString = string[255];   { size: 255         }
  TGLS_Point = packed record    { size: 24    3*8   }
    X,
    Y,
    Z: Double;
  end;

type
  TGLS_NetSend = packed record { 394 }
    C: Integer;
    K: Integer;
    P: Integer;          { 12  }
    Name: TGLS_SString;  { 32  }
    case Integer of
      0:(
       M1,
       M2,
       M3,
       M4,
       M5: TGLS_SString;    { 142 }
       ML: TGLS_LString;    { 387 }
      );
      1:(
       Pos: TGLS_Point;     { 56  }
       Dir: TGLS_Point;     { 70  }
       Speed: Double;
       Power: Double;       { 86  }
      );
  end;

type
  TGLS_OnReceiveEvent = procedure(r: TGLS_NetSend;ip: string) of object;
  TGLS_Network = class (TUdpSockUtil)
  protected
    IP: TIdIPWatch;
    FOnRecieveRecord: TGLS_OnReceiveEvent;
    procedure Receive(Sender: TObject);
  public
    constructor Create(AOwner: TComponent); override;
    procedure BroadcastRecord(r: TGLS_NetSend);
    procedure SendRecord(r: TGLS_NetSend);
  published
    property OnReceiveRecord: TGLS_OnReceiveEvent read FOnRecieveRecord write
                                                          FOnRecieveRecord;
  end;

implementation

uses WinSock;

{ TGLS_Network }

procedure TGLS_Network.BroadcastRecord(r: TGLS_NetSend);
var
  s: string;
begin
  Move(r, s, sizeof(TGLS_NetSend));
  Self.BroadcastText(s); // also auch hier
end;

constructor TGLS_Network.Create(AOwner: TComponent);
begin
  inherited;
  IP:= TIdIPWatch.Create(self);
  IP.HistoryEnabled:= false;
  Self.OnReceive:= Receive;
  Self.LocalPort:= GLSN_DEFAULTPORT;
  Self.RemotePort:= GLSN_DEFAULTPORT;
  Self.Listen:=true;
end;

procedure TGLS_Network.Receive(Sender: TObject);
var
  Len: Integer;
  Msg: String;
  vonIP: in_addr;
  r: TGLS_NetSend;
begin
  // wieviel ist angekommen?
  Len := Self.ReceiveLength;
  if (Len > 0) then begin // wenn auch was da ist...

    // Nachricht einlesen; in vonIP wird die Absender-IP zurückgegeben
    Msg := Self.ReceiveText(vonIP);
    if inet_ntoa(vonIP)<>IP.LocalIP then
    begin
      if Len=sizeof(TGLS_NetSend) then begin
        if Assigned(FOnRecieveRecord) then begin
          Move(msg, r, sizeof(TGLS_NetSend));
          FOnRecieveRecord(r, inet_ntoa(vonIP));
        end;
      end;
    end;
  end;
end;

procedure TGLS_Network.SendRecord(r: TGLS_NetSend);
var
  s: string;
begin
  Move(r, s, sizeof(TGLS_NetSend));
  Self.SendText(s);
end;

end.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

unit uglsn_demo;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, uglsn_engine, StdCtrls;

type
  TGLSNWindow = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    n:TGLS_Network;
    procedure Receive(r: TGLS_NetSend; ip: string);
  end;

var
  GLSNWindow: TGLSNWindow;

implementation

uses WinSock;

{$R *.dfm}

procedure TGLSNWindow.FormCreate(Sender: TObject);
begin
  n:=TGLS_Network.Create(self);
  n.OnReceiveRecord:= Receive;
end;

procedure TGLSNWindow.Receive(r: TGLS_NetSend; ip: string);
begin
  case r.K of
    GLSN_STR:showmessage(r.ML);
    GLSN_POS:;
  end;
end;

procedure TGLSNWindow.Button1Click(Sender: TObject);
var
  r: TGLS_NetSend;
begin
  n.BroadcastRecord(r);// hier der fehler
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:

interface

uses
  SysUtils, Classes, IdBaseComponent, IdComponent, IdIPWatch, UdpSockUtil,
  WinSock, Forms, Dialogs;

const
  ALL = '255.255.255.255';
  GLSN_DEFAULTPORT = 42768;
  GLSN_STR = 0;
  GLSN_POS = 1;

type
  TGLS_IPString = string[18];   { size: 18    4*3+3 }
  TGLS_SString = string[20];    { size: 20          }
  TGLS_LString = string[255];   { size: 255         }
  TGLS_Point = packed record    { size: 24    3*8   }
    X,
    Y,
    Z: Double;
  end;

type
  TGLS_NetSend = packed record { 394 }
    C: Integer;
    K: Integer;
    P: Integer;
    Name: TGLS_SString;
    case Integer of
      0:(
       M1,
       M2,
       M3,
       M4,
       M5: TGLS_SString;
       ML: TGLS_LString;
      );
      1:(
       Pos: TGLS_Point;
       Dir: TGLS_Point;
       Speed: Double;
       Power: Double;
      );
  end;

type
  TGLSN_Exception = Exception;
  TGLS_OnReceiveEvent = procedure(r: TGLS_NetSend;ip: string) of object;
  TGLSN_Engine = class(TDataModule)
    UdpSockUtil: TUdpSockUtil;
    IP: TIdIPWatch;
    procedure UdpSockUtilError(Sender: TObject; Error: Integer);
    procedure UdpSockUtilReceive(Sender: TObject);
    procedure DataModuleCreate(Sender: TObject);
  protected
    FOnRecieveRecord: TGLS_OnReceiveEvent;
  public
    { Public-Deklarationen }
    Eceptions: boolean;
    procedure BroadcastRecord(r: TGLS_NetSend);
    procedure SendRecord(r: TGLS_NetSend; toip: string);
  published
    property OnReceiveRecord: TGLS_OnReceiveEvent read FOnRecieveRecord write
                                                          FOnRecieveRecord;
  end;

var
  GLSN_Engine: TGLSN_Engine;

implementation

{$R *.dfm}

procedure TGLSN_Engine.UdpSockUtilError(Sender: TObject; Error: Integer);
begin
  if Eceptions then
     TGLSN_Exception.Create('GLSN Socket Error: '+inttostr(Error));
end;

procedure TGLSN_Engine.UdpSockUtilReceive(Sender: TObject);
var
  Len: Integer;
  Msg: String;
  vonIP: in_addr;
  buffer: TGLS_NetSend;
begin
  // wieviel ist angekommen?
  Len := UdpSockUtil.ReceiveLength;
  if (Len > 0) then begin // wenn auch was da ist...
    // Nachricht einlesen; in vonIP wird die Absender-IP zurückgegeben
    UdpSockUtil.ReceiveBuf(buffer, sizeof(buffer), vonIP);
    if inet_ntoa(vonIP)<>IP.LocalIP then
    begin
      if Assigned(FOnRecieveRecord) then begin
        FOnRecieveRecord(buffer, inet_ntoa(vonIP));
      end;
    end;
  end;
end;

procedure TGLSN_Engine.DataModuleCreate(Sender: TObject);
begin
  UdpSockUtil.Listen:=true;
end;

procedure TGLSN_Engine.BroadcastRecord(r: TGLS_NetSend);
var
  s: string;
begin
  s:=UdpSockUtil.RemoteHost;
  UdpSockUtil.RemoteHost:=ALL;
  UdpSockUtil.SendBuf(r, sizeof(r));
  UdpSockUtil.RemoteHost:=s;
end;

procedure TGLSN_Engine.SendRecord(r: TGLS_NetSend; toip: string);
var
  s: string;
begin
  s:=UdpSockUtil.RemoteHost;
  UdpSockUtil.RemoteHost:=toip;
  UdpSockUtil.SendBuf(r, sizeof(r));
  UdpSockUtil.RemoteHost:=s;
end;

end.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

uses ...,UDPSockUtil,Winsock;

type

...
procedure UdpSockUtil1Receive(Sender: TObject);

...
private
  udp:TUDPSockUtil;

...


udp:=TUDpSockutil.Create(self);
udp.Name:='Udp1';
udp.LocalPort:=2555;
udp.Listen:=True;
udp.OnReceive:=Form1.UdpSockUtil1Receive;

...

procedure TForm1.UdpSockUtil1Receive(Sender: TObject);
var
  Msg: String;
  vonIP: in_addr;
begin
  
Msg := Udp.ReceiveText(vonIP);
ShowMessage(Msg);
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

procedure TForm1.Button5Click(Sender: TObject);
var i,j:integer;
byte1,byte2,byte3:byte;
begin
button5.Enabled:=false;
memo1.Enabled:=false;
button5.Caption:='Removing empty Data';
for i:=0 to memo1.Lines.Count do begin
 memo1.Lines[i]:=stringreplace(memo1.Lines[i],' ','',[rfReplaceAll]);
 memo1.Lines[i]:=stringreplace(memo1.Lines[i],#13+#10,'',[rfReplaceAll]);
 if memo1.Lines.ValueFromIndex[i]='' then memo1.Lines.Delete(i);end;
button5.Caption:='Removing dublicates';
for i:=0 to memo1.Lines.Count do begin
for j:=0 to memo1.Lines.Count do if (memo1.Lines[i]=memo1.Lines[j]) AND (i<>j) then memo1.Lines.Delete(j); 
end;
button5.Caption:='Scanning';
byte1:=00;
byte2:=02;
byte3:=32;
progressbar1.Max:=memo1.Lines.Count;
for i:=0 to memo1.Lines.Count do begin
udpsockutil1.RemoteHost:=stringreplace(memo1.Lines[i],#13+#10,'',[rfReplaceAll]);
if udpsockutil1.RemoteHost='255.255.255.255' then memo1.Lines.Delete(i) else
udpsockutil1.SendText(chr(byte2)+chr(byte1)+chr(byte1)+chr(byte3)+chr(byte1)+chr(byte1)+chr(byte1)+chr(byte1)+chr(byte1));
progressbar1.Position:=i;
end;
button5.Caption:='Scan for Games';
button5.Enabled:=true;
memo1.Enabled:=true;
progressbar1.Position:=0;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

procedure TForm1.UdpSockUtil1Receive(Sender: TObject);
  var
  Len: Integer;
  servername,gamemode,levelname,s,ip: String;
  vonIP: in_addr;
  i,currentlyplaying,maxplayers:integer;
  newserver:TTreenode;
begin
  Len := UdpSockUtil1.ReceiveLength;
  if Len =166 then begin
    servername:='';
    gamemode:='';
    levelname:='';
    s:=udpSockUtil1.ReceiveText(vonIP);
    ip:=string(inet_ntoa(vonIP));
    ips.Add(ip);
    for I:=62 to 93 do servername:=servername+s[i];
    for I:=94 to 125 do gamemode:=gamemode+s[i];
    for I:=126 to 157 do levelname:=levelname+s[i];
    currentlyplaying:=ord(s[158]);
    maxplayers:=ord(s[162]);
    newserver:=treeview1.Items.add(nil,ip+': '+servername);
    treeview1.items.AddChild(newserver,'Gamemode: '+gamemode);
    treeview1.items.AddChild(newserver,'Level: '+levelname);
    treeview1.items.AddChild(newserver,'Players: '+inttostr(currentlyplaying)+'/'+inttostr(maxplayers));
    ping1.Hostname:=ip;
    ping1.ResetStatistics;
    ping1.action;
    pinging:=true;
    while pinging do application.ProcessMessages;
    treeview1.items.AddChild(newserver,'Ping: '+inttostr(lastping)+'ms');
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

procedure TForm1.Button5Click(Sender: TObject);
var i,j:integer;
byte1,byte2,byte3:byte;
begin
button5.Enabled:=false; //damit nich noch einmal draufgeklickt wird
memo1.Enabled:=false; //das ist die liste mit den IPs
button5.Caption:='Removing empty Data';
for i:=0 to memo1.Lines.Count do begin
 memo1.Lines[i]:=stringreplace(memo1.Lines[i],' ','',[rfReplaceAll]); //leere Lines löschen
 memo1.Lines[i]:=stringreplace(memo1.Lines[i],#13+#10,'',[rfReplaceAll]); //leere Lines löschen
 if memo1.Lines.ValueFromIndex[i]='' then memo1.Lines.Delete(i);end; //leere Lines löschen
button5.Caption:='Removing dublicates';
for i:=0 to memo1.Lines.Count do begin
for j:=0 to memo1.Lines.Count do if (memo1.Lines[i]=memo1.Lines[j]) AND (i<>j) then memo1.Lines.Delete(j); //Dublikate löschen
end;
button5.Caption:='Scanning';
byte1:=00;
byte2:=02;
byte3:=32;
progressbar1.Max:=memo1.Lines.Count; //visuelle Anzeige zum Anzeigen des Fortschrittes
for i:=0 to memo1.Lines.Count do begin
udpsockutil1.RemoteHost:=stringreplace(memo1.Lines[i],#13+#10,'',[rfReplaceAll]); //den i-ten Host aus der Liste finden und einsetzen
if udpsockutil1.RemoteHost='255.255.255.255' then memo1.Lines.Delete(i) else //wenn der Host ungültig ist dann löschen
udpsockutil1.SendText(chr(byte2)+chr(byte1)+chr(byte1)+chr(byte3)+chr(byte1)+chr(byte1)+chr(byte1)+chr(byte1)+chr(byte1)); //9-Byte-Text zu dem Host senden
progressbar1.Position:=i;
end;
button5.Caption:='Scan for Games';
button5.Enabled:=true;
memo1.Enabled:=true;
progressbar1.Position:=0;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

procedure TForm1.UdpSockUtil1Receive(Sender: TObject);
  var
  Len: Integer;
  servername,gamemode,levelname,s,ip: String;
  vonIP: in_addr;
  i,currentlyplaying,maxplayers:integer;
  newserver:TTreenode;
begin
  Len := UdpSockUtil1.ReceiveLength;
  if Len =166 then begin //wenn die Antwort genau 166 Bytes lang ist
    servername:='';
    gamemode:='';
    levelname:='';
    s:=udpSockUtil1.ReceiveText(vonIP); //Antwort und IP in Variablen speichern
    ip:=string(inet_ntoa(vonIP));
    ips.Add(ip); //ips ist eine Stringlist, wo alle IPs dringespeichert sind
    for I:=62 to 93 do servername:=servername+s[i]; //Serverinfos rausfinden
    for I:=94 to 125 do gamemode:=gamemode+s[i];//Serverinfos rausfinden
    for I:=126 to 157 do levelname:=levelname+s[i];//Serverinfos rausfinden
    currentlyplaying:=ord(s[158]);//Serverinfos rausfinden
    maxplayers:=ord(s[162]);//Serverinfos rausfinden
    newserver:=treeview1.Items.add(nil,ip+': '+servername); //Serverinfos in ein Treeview stecken
    treeview1.items.AddChild(newserver,'Gamemode: '+gamemode); //Serverinfos in ein Treeview stecken
    treeview1.items.AddChild(newserver,'Level: '+levelname); //Serverinfos in ein Treeview stecken
    treeview1.items.AddChild(newserver,'Players: '+inttostr(currentlyplaying)+'/'+inttostr(maxplayers)); //Serverinfos in ein Treeview stecken
    ping1.Hostname:=ip; //Server anpingen (Habe ich allerdiungs in der neuen Version entfernt, da dadurch manchmal das Programm einfror
    ping1.ResetStatistics; //Server anpingen
    ping1.action; //Server anpingen
    pinging:=true; //Server anpingen
    while pinging do application.ProcessMessages; //Server anpingen
    treeview1.items.AddChild(newserver,'Ping: '+inttostr(lastping)+'ms'); //Ping hinzufügen
  end;                    

1:
2:
3:
4:
5:
6:
7:

[Fehler] UdpSockUtil.pas(262): Undefinierter Bezeichner: 'DeallocateHWnd'
[Fehler] UdpSockUtil.pas(300): Undefinierter Bezeichner: 'AllocateHWnd'
[Fehler] UdpSockUtil.pas(300): Nicht genügend wirkliche Parameter
[Warnung] UdpSockUtil.pas(372): Konstantenausdruck verletzt untere Grenzen
[Warnung] UdpSockUtil.pas(386): Der Vergleich ergibt immer Falsch
[Warnung] UdpSockUtil.pas(405): Der Vergleich ergibt immer Falsch
[Warnung] UdpSockUtil.pas(495): Konstantenausdruck verletzt untere Grenzen                    

1:
2:

uses
   ..., Forms;                    

1:
2:
3:
4:
5:

FRemoteAddr.S_addr := Integer(INADDR_BROADCAST);

if (Value.S_addr = Integer(INADDR_BROADCAST)) then

if (Value.S_addr = Integer(INADDR_BROADCAST)) then                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:

[...]

procedure TForm1.FormCreate(Sender: TObject);
begin
  myUDP := TUDPSockUtil.Create(self);
  myUDP.RemotePort := UDP_PORT; //12345
  myUDP.LocalPort := UDP_PORT;
  myUDP.OnReceive := myUDPReceive;
  myUDP.OnError := myUDPError;
  myUDP.Listen := true;

  myTCPClient.BoundIP := myIPWatch.LocalIP;
  myTCPClient.BoundPort := TCP_CLIENT_PORT; //12346
  
  myTCPServer.DefaultPort := TCP_SERVER_PORT; //12347
  myTCPServer.Active := true;

  [...]

end;

procedure TForm1.Button2Click(Sender: TObject); //Broadcast senden
begin
  Log.Lines.Add(TimeToStr(now) +': Sending Broadcast Question');
  myUDP.BroadcastText(APP_ID+#13+ // Kennung
                      Syntax[cmdBroadAsk].Text+#13); // Befehl
                      //Input.Text+#13); // Argument

  ServerList.SetFocus;
end;

procedure TForm1.ServerListClick(Sender: TObject);
var
  server: string;
begin
  if ( ServerList.Row > 0 ) and ( ServerList.Row < ServerList.RowCount )
          and not ( ServerList.Cells[1,ServerList.Row] = '' )
          then
    begin
      server := copy(ServerList.Cells[1,ServerList.Row],1,pos(' (',ServerList.Cells[1,ServerList.Row]));
      Log.Lines.Add('Trying to connect to ' + server);
      myUDP.RemoteHost := server;
      myUDP.SendText(APP_ID+#13+ // Kennung
                      Syntax[cmdStop].Text+#13); // Der Befehl um myUDP.Listen auf false zu setzen
      myTCPClient.Host := server;
      myTCPClient.Port := TCP_SERVER_PORT; //12347
      myTcpClient.Connect(); //Ohne das vorherige stoppen von myUDP.Listen kommt hier ein 'Connection refused'
    end;
end;

[...]                    

1:

[Fatal Error] dclusr.dpk(47): File not found: 'GIFCODE.dcu'                    

1:
2:
3:

[Warning] dclusr.dpk(5): File not found: '..\..\..\..\dokumente und einstellungen\sebastian & martin\desktop\icq_20040630\icq\component\ICQClient.dcr' 

[Warning] dclusr.dpk(6): File not found: '..\..\..\..\Dokumente und Einstellungen\Sebastian & Martin\Desktop\icq_20040630\ICQ\Component\ICQDb.dcr'                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:

unit Client;
{**************************************************************************************************}
interface
{**************************************************************************************************}
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, UdpSockUtil, ExtCtrls;
{**************************************************************************************************}
type
  TfrmClient = class(TForm)
    Timer1: TTimer;
    UdpSockUtil1: TUdpSockUtil;
    procedure FormCreate(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
    procedure UdpSockUtil1Receive(Sender: TObject);
    procedure UdpSockUtil1Error(Sender: TObject; Error: Integer);
  private
    bLaberSuelz: Boolean;
  public
  end;
{**************************************************************************************************}
var
  frmClient: TfrmClient;
{**************************************************************************************************}
implementation
{$R *.dfm}
{**************************************************************************************************}
uses
  WinSock;
{**************************************************************************************************}
procedure TfrmClient.FormCreate(Sender: TObject);
begin
  bLaberSuelz := false;
  UDPSockUtil1.LocalPort  := 12346;
  UDPSockUtil1.RemotePort := 12345;
  UDPSockUtil1.RemoteHost := '192.168.100.100';
  UDPSockUtil1.CloseInactiveSockets := true;
  UDPSockUtil1.Open();
  Timer1.Enabled := true;
end;
{**************************************************************************************************}
procedure TfrmClient.Timer1Timer(Sender: TObject);
var
  st: String;
begin
  if bLaberSuelz then st := 'Laber' else st := 'Sülz';
  bLaberSuelz := Not bLaberSuelz;
  UDPSockUtil1.SendText(st);
end;
{**************************************************************************************************}
procedure TfrmClient.UdpSockUtil1Error(Sender: TObject; Error: Integer);
begin
  // ShutUp exceptions
end;
{**************************************************************************************************}
procedure TfrmClient.UdpSockUtil1Receive(Sender: TObject);
var
  FromAddr: in_Addr;
  stCmd: String;
  Anzahl: Integer;
begin
  try
    Anzahl := UDPSockUtil1.ReceiveLength();
    if Anzahl > 0 then
    begin
      stCmd := UDPSockUtil1.ReceiveText(FromAddr);

      if stCmd = 'Hier spricht Dein Meister' then
        UDPSockUtil1.SendText('Ja, Chef...');
    end;

  except
    Windows.Beep(1000, 10);
  end;
end;
{**************************************************************************************************}
end.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

//original
function TUdpSockUtil.ReceiveText(var RemoteAddr: in_addr): String;
begin
  SetLength(Result,ReceiveLength);
  SetLength(Result,ReceiveBuf(Pointer(Result)^,Length(Result),RemoteAddr));
end;


//neu
function TUdpSockUtil.ReceiveText(var RemoteAddr: in_addr): String;
begin
  SetLength(Result,ReceiveLength);

  if Result<>#0 then //nur wenn was drin ist
  SetLength(Result,ReceiveBuf(Pointer(Result)^,Length(Result),RemoteAddr))
  else //ansonsten Fehlermeldung

        if Assigned(FOnError) then
        FOnError(Self,WSAECONNRESET)
        //FOnError(Self,10054) // mit diesem Fehler melden
      else
        raise EUSUError.CreateFmt('Zielhost nicht erreichbar!',[]);

end;                    

1:

UDPSockUtil1.RemoteHost := '192.168.100.100';                    

1:
2:

server:= UdpUtil1.RemoteAddress;
listbox.items.append(server);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:

42c42
<     FRemoteHost: String; // dahin senden
---
>     FRemoteHost: AnsiString; // dahin senden
60c60
<     procedure SetRemoteHost(const Value: String);
---
>     procedure SetRemoteHost(const Value: AnsiString);
90c90
<     property RemoteHost: String read FRemoteHost write SetRemoteHost;
---
>     property RemoteHost: AnsiString read FRemoteHost write SetRemoteHost;
226c226
<   FRemoteAddr.S_addr := INADDR_BROADCAST;
---
>   FRemoteAddr.S_addr := Integer(INADDR_BROADCAST);
369c369
<     FRemoteAddr.S_addr := INADDR_BROADCAST;
---
>     FRemoteAddr.S_addr := Integer(INADDR_BROADCAST);
383c383
<   if (Value.S_addr = INADDR_BROADCAST) then
---
>   if (Value.S_addr = Integer(INADDR_BROADCAST)) then
392c392
< procedure TUdpSockUtil.SetRemoteHost(const Value: String);
---
> procedure TUdpSockUtil.SetRemoteHost(const Value: AnsiString);
401,402c401,402
<       FRemoteAddr.S_addr := inet_addr(PChar(Value)); // IPdotdot?
<       if (FRemoteAddr.S_addr = INADDR_NONE) then begin // nein, DNSresolve
---
>       FRemoteAddr.S_addr := inet_addr(PAnsiChar(AnsiString((Value)))); // IPdotdot?
>       if (FRemoteAddr.S_addr = Integer(INADDR_NONE)) then begin // nein, DNSresolve
491c491
<         ToAddr.sin_addr.S_addr := INADDR_BROADCAST
---
>         ToAddr.sin_addr.S_addr := Integer(INADDR_BROADCAST)                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

  TUdpSockUtil = class(TComponent)
  private
  [...]

    FRemoteHost: AnsiString; // dahin senden
    FRemoteAddr: in_addr; // nochmal als IP-Adresse
    FRemotePort: Word; // an diesen Port senden
    FForceResolve: boolean;  //Namensauflösung erzwingen - OST, 28.02.2016
  [...]
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  [...]
    property RemoteAddr: in_addr read GetRemoteAddr write SetRemoteAddr;
    property RecvFlags: Integer read FRecvFlags write FRecvFlags;
    property SendFlags: Integer read FSendFlags write FSendFlags;
    property ForceResolve: boolean read FForceResolve write FForceResolve;  //Resolve erzwingen - OST, 28.02.2016
  [...]
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

constructor TUdpSockUtil.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  Startup;
  [...]
  FRemotePort := 0;
  FCloseInactiveSockets := FALSE;
  FForceResolve:=false;  //Erzwungenes Hostname-Resolving default abgeschaltet - OST, 28.02.2016
  [...]
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:

procedure TUdpSockUtil.SetRemoteHost(const Value: AnsiString);
var
   IP: in_addr;
   HostInfo: PHostEnt;
   ErrorCode: Integer;
begin
     //Bei not ForceResolve können wir bei unverändertem Hostnamen gleich raus - OST, 28.02.2016
     if (not FForceResolve) then
        if (FRemoteHost = Value) then
           exit;

     IP.S_addr := inet_addr(PAnsiChar(Value)); // falls der String bereits eine Adresse im IPdotdot-Format ist
     if (IP.S_addr <> Integer(INADDR_NONE)) or (Value = '255.255.255.255') then // sind wir schon fertig, übernehmen
     begin
          if (CheckAddr(IP)) then
          begin
               FRemoteHost := Value;
               FRemoteAddr := IP;
          end;
     end
     else
     begin
          if (Value <> '') then // wurde ein Host angegeben (Leerstring = localhost)
             HostInfo := WinSock.GetHostByName(PAnsiChar(Value)) // Name auflösen
          else
             HostInfo := WinSock.GetHostByName(NIL); // -> localhost abfragen
          if Assigned(HostInfo) then  // Auflösung OK?
          begin
               IP := PInAddr(HostInfo^.h_addr_list^)^;
               if (CheckAddr(IP)) then
               begin
                    FRemoteHost := Value;
                    FRemoteAddr := IP;
               end;
          end
          else
          begin
               ErrorCode := WSAGetLastError;
               if Assigned(FOnResolveError) then
                  FOnResolveError(Self, ErrorCode)
               else
                  raise EUSUError.CreateResFmt(PResStringRec(@sWindowsSocketError),
                                              [SysErrorMessage(ErrorCode), ErrorCode, 'GetHostByName']);
          end;
     end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

function TUdpSockUtil.SendBuf(var Buf; BufSize: Integer): Integer;
begin
  FSocketLock.Enter;
  try
    //ggf. Host neu auflösen, wenn wir gezwungen sind - OST, 28.02.2016
    if (FForceResolve) then
       RemoteHost:=FRemoteHost;
    CreateBinding(FMainSocket, FLocalPort, FBroadcast);
    Result := InternalSendBuf(FMainSocket, Buf, BufSize, FSendFlags);
  finally
    CleanupSocket(FMainSocket);
    FSocketLock.Leave;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:

function TUdpSockUtil.SendText(const S: AnsiString): Integer;
begin
    //ggf. Host neu auflösen, wenn wir gezwungen sind - OST, 28.02.2016
    if (FForceResolve) then
       RemoteHost:=FRemoteHost;
  Result := InternalSendText(FMainSocket, FLocalPort, FBroadcast, S);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

For SNet:= 0 To 255 Do
Begin
  For IP:= 1 To 254 Do
  Begin
    UDPSocket.RemoteHost:= '192.168.' + IntToStr(SNet) + ' .' + IntToStr(IP);
    UDPSocket.SendText(SendText);
  End;
End;
Application.ProcessMessages;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

Procedure TMainForm.UDPSocketReceive(Sender: TObject);
Var
  Data        : TStringList;
  vonIP        : in_addr;
  Current      : TCmdToken;              // empfangenes Kommando
  I          : Integer;
  S          : String;
Begin
  Data:= TStringList.Create;
  Try
    Data.Text:= String(UDPSocket.ReceiveText(vonIP));// Daten auslesen
    If (Data.Count > 1) Then              // mind. 2 Datenpakete
    Begin
      If (Data.Strings[0] = APP_ID) Then      // von unserem Client
      Begin
        Current:= GetCmdToken(Data.Strings[1]);
        If (Data.Count >= Succ(Syntax[Current].ArgCount)) Then
          Execute(Current, Data, vonIP);    // gültigen Befehl abarbeiten
      End;
    End
    Else
    Begin
      S:= '';
      For I:= 1 To Length(Data.Text) Do S:= S + IntToHex(Byte(Data.Text[I]), 2) + ' ';
      Loggen('', 'FREMDES PAKET: ' + Trim(S));
    End;
  Finally
    Data.Free;
  End;
End;                    

1:
2:

UDPSocket.RemoteHost:= '192.168.255.35';
UDPSocket.SendText:= 'Blablablubb';