TidUDPClient thru proxy server - delphi

Question

On the below piece of code i have some related questions
var
UseProxy : Boolean = True;
....
var
IdUDPClient : TIdUDPClient;
sText : string;
begin
IdUDPClient := TIdUDPClient.Create(nil);
try
IdUDPClient.Host := '10.10.10.10';
IdUDPClient.Port := 5555;
if UseProxy then begin
IdUDPClient.TransparentProxy.Enabled := True;
IdUDPClient.TransparentProxy.Host := '20.20.20.20';
IdUDPClient.TransparentProxy.Port := 8080;
IdUDPClient.OpenProxy;
end;
try
IdUDPClient.Connect;
except
Writeln('Connect Error.');
end;
if IdUDPClient.Connected then
Writeln('Connected')
else begin
Writeln('Not Connected');
Exit;
end;
try
IdUDPClient.Send('Foo');
try
sText := IdUDPClient.ReceiveString(1000);
Writeln('Received: ', sText);
except
Writeln('Receive Error.');
end;
except
Writeln('Send Error.');
end;
if UseProxy then
IdUDPClient.CloseProxy;
finally
IdUDPClient.Free;
end;
Readln;
end.
Why the try...except block is not catching errors on the UDP
client even if the Host is not reachable nor the port is closed e.g. IdUDPClient.Connected always True?
When using the proxy i'm not sure if my implementation is correct above
because if UseProxy is True the IdUDPClient try to directly send
the request to 10.10.10.10not thru the proxy server. How i can fix this? what i'm doing wrong?
My test scenario for the proxy was as follow:
My PC IP 30.30.30.30
UDP Server 10.10.10.10
Proxy Sever (Socks 5) 20.20.20.20
30.30.30.0/24 cant reach 10.10.10.10 but 20.20.20.20 does.
if my PC can access the UDP server directly and i put fake proxy server (unused IP with random port) to the client. the client can reach the UDP server which is not supposed to be reached because the proxy is down. How i cant prevent such scenario ?

Answer 1

UDP is connection-less, so Connected cannot tell you whether the remote peer is reachable or not.
"Connecting" a UDP socket simply assigns a local association with the peer IP/Port. That way, outbound packets are sent only to that peer, and only packets received from that peer are accepted. Nothing more. There is no actual connection, like in TCP.
And unlike TCP, sending a UDP packet just dumps the packet onto the network, there is no acknowledgement that the packet ever reaches the peer. Acks have to be implemented at the application layer.
As for exceptions, they are only raised when an actual error occurs. In UDP, the only way an unreachable Host would cause socket errors is if the network sends back an ICMP packet to indicate the Host is not reachable. A "connected" UDP socket will receive such packets internally and start reporting failures on subsequent reads/sends with the same peer. So, in your example, the call to Send() will never raise an error about not being about to reach the Host, because it simply does not know. ReceiveString() has a better chance of reporting such errors, however the way it is currently implemented, it would likely just ignore them because it checks if the socket is readable (has a pending UDP packet) before actually reading it. A ICMP packet may not make the socket enter a readable state.
Since you are specifying a timeout on ReceiveString(), you will just have to assume the peer is gone if the timeout elapses without receiving an actual string.
Your code is bypassing the proxy because you are not setting up the TransparentProxy correctly.
When you access the TransparentProxy property, if no proxy component is currently assigned then the property getter creates an internal TIdSocksInfo object. TIdSocksInfo has a Version property that defaults to svNoSocks. Since you are trying to connect through a SOCKS v5 proxy, you need to set the Version to svSocks5 instead:
if UseProxy then begin
(IdUDPClient.TransparentProxy as TIdSocksInfo).Version := svSocks5; // <--
IdUDPClient.TransparentProxy.Host := '20.20.20.20';
IdUDPClient.TransparentProxy.Port := 8080;
end;
The TransparentProxy.Enabled property setter is not used with TIdSocksInfo at all, it is a no-op. However, the Enabled property getter returns True/False depending on the value of the TIdSocksInfo.Version property.
And you don't need to call OpenProxy() and CloseProxy() manually, TIdUDPClient.Connect() and TIdUDPClient.Disconnect() will handle that for you when the TransparentProxy is enabled.
Now, with all of that said, try this:
var
UseProxy : Boolean = True;
...
var
IdUDPClient : TIdUDPClient;
IdSocksInfo : TIdSocksInfo;
sText : string;
begin
IdUDPClient := TIdUDPClient.Create(nil);
try
IdUDPClient.Host := '10.10.10.10';
IdUDPClient.Port := 5555;
if UseProxy then begin
IdSocksInfo := TIdSocksInfo.Create(IdUDPClient);
IdSocksInfo.Version := svSocks5;
IdSocksInfo.Host := '20.20.20.20';
IdSocksInfo.Port := 8080;
IdUDPClient.TransparentProxy := IdSocksInfo;
end;
try
IdUDPClient.Connect;
except
on E: Exception do begin
Writeln('Connect Error: ', E.Message);
Exit;
end;
end;
try
Writeln('Connected.');
try
IdUDPClient.Send('Foo');
except
on E: Exception do begin
Writeln('Send Error: ', E.Message);
Exit;
end;
end;
try
sText := IdUDPClient.ReceiveString(1000);
if sText <> '' then
Writeln('Received: ', sText)
else
Writeln('Nothing Received after 1 second.');
except
on E: Exception do begin
Writeln('Receive Error: ', E.Message);
end;
end;
finally
IdUDPClient.Disconnect;
end;
finally
IdUDPClient.Free;
end;
end.