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.