/// <summary>
/// Opens a RADIUS client port using the <see cref="RadiusClientSettings" /> passed.
/// </summary>
/// <param name="settings">The client settings.</param>
/// <remarks>
/// <note>
/// All successful calls to <see cref="Open" /> must eventually be matched
/// with a call to <see cref="Close" /> so that system resources will be
/// released promptly.
/// </note>
/// </remarks>
public void Open(RadiusClientSettings settings)
{
using (TimedLock.Lock(this))
{
if (isOpen)
{
throw new RadiusException("RADIUS client port is already open.");
}
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
sock.Bind(settings.NetworkBinding);
this.sock.SendBufferSize = settings.SocketBuffer;
this.sock.ReceiveBufferSize = settings.SocketBuffer;
isOpen = true;
networkBinding = settings.NetworkBinding;
servers = settings.Servers;
secret = settings.Secret;
retryInterval = settings.RetryInterval;
maxTransmissions = settings.MaxTransmissions;
realmFormat = settings.RealmFormat;
nextID = 0;
serverPos = 0;
transactions = new AuthTransaction[256];
recvBuf = new byte[TcpConst.MTU];
sourceEP = new IPEndPoint(IPAddress.Any, 0);
onReceive = new AsyncCallback(OnReceive);
if (networkBinding.Address.Equals(IPAddress.Any))
{
nasIPAddress = NetHelper.GetActiveAdapter();
}
else
{
nasIPAddress = networkBinding.Address;
}
// Initiate reception of the first RADIUS packet.
sock.BeginReceiveFrom(recvBuf, 0, recvBuf.Length, SocketFlags.None, ref sourceEP, onReceive, null);
}
}
/// <summary>
/// Starts the DNS server using the settings passed.
/// </summary>
/// <param name="settings">The <see cref="DnsServerSettings" /> to be used to initialize the server.</param>
/// <exception cref="InvalidOperationException">Thrown if the server has already started.</exception>
public void Start(DnsServerSettings settings)
{
lock (syncLock)
{
if (sock != null)
{
throw new InvalidOperationException("DNS server has already started.");
}
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
sock.IgnoreUdpConnectionReset = true;
sock.ReceiveBufferSize =
sock.ReceiveBufferSize = 1024 * 1024; // $todo(jeff.lill): Hardcoded
sock.Bind(settings.NetworkBinding);
remoteEP = new IPEndPoint(IPAddress.Any, 0);
sock.BeginReceiveFrom(recvBuf, 0, recvBuf.Length, SocketFlags.None, ref remoteEP, onReceive, sock);
}
}
/// <summary>
/// Attempts to start a listener on the endpoint specified. Check for
/// SocketExceptions.
/// </summary>
/// <param name="localEP">The TCP endpoint to listen on.</param>
/// <param name="maxBackLog">
/// The maximum number of socket connection attempts to queue.
/// </param>
/// <remarks>
/// This method is not threadsafe. The intention is that this method will be called
/// one or more times on the application's startup thread and then not be called
/// again.
/// </remarks>
public void Start(IPEndPoint localEP, int maxBackLog)
{
Listener listener;
EnhancedSocket sock;
if (localEP.Port == 0)
{
throw new ArgumentException("Endpoint port cannot be 0.", "localEP");
}
if (listeners[localEP] != null)
{
throw new InvalidOperationException("Already listening on this port.");
}
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.DisableHangTest = true;
sock.Blocking = true;
sock.Bind(localEP);
sock.Listen(maxBackLog);
listener = new Listener(new Thread(new ThreadStart(ListenLoop)), localEP, sock);
listeners.Add(localEP, listener);
// Start the listening thread, passing in the socket. Note that this
// is the code that prevents the method from being threadsafe.
sockParam = sock;
threadStart = new ManualResetEvent(false);
listener.Thread.Start();
threadStart.WaitOne();
threadStart.Close();
threadStart = null;
sockParam = null;
}
/// <summary>
/// Creates and starts a UDP broadcast server using the settings passed.
/// </summary>
/// <param name="settings">The server settings.</param>
/// <param name="perfCounters">The application's performance counters (or <c>null</c>).</param>
/// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param>
/// <remarks>
/// <note>
/// The <paramref name="perfCounters" /> parameter is type as <see cref="object" /> so that
/// applications using this class will not be required to reference the <b>LillTel.Advanced</b>
/// assembly.
/// </note>
/// </remarks>
/// <exception cref="ArgumentException">Thrown if the settings passed are not valid.</exception>
public UdpBroadcastServer(UdpBroadcastServerSettings settings, object perfCounters, string perfPrefix)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (settings.Servers == null || settings.Servers.Length == 0)
{
throw new ArgumentException("Invalid UDP broadcast server settings: At least one broadcast server endpoint is required.");
}
if (perfCounters != null && !(perfCounters is PerfCounterSet))
{
throw new ArgumentException("Only instances of type [PerfCounterSet] may be passed in the [perfCounters] parameter.", "perfCounters");
}
this.startTime = DateTime.UtcNow;
this.closePending = false;
this.settings = settings;
this.perf = new Perf(perfCounters as PerfCounterSet, perfPrefix);
bool found = false;
for (int i = 0; i < settings.Servers.Length; i++)
{
var binding = settings.Servers[i];
if (binding == settings.NetworkBinding)
{
found = true;
// I'm going to special case the situation where the network binding address is ANY.
// In this case, one of the server endpoints must also include an ANY entry and I'll
// fill out with the loop back addres (127.1.0.1).
if (binding.IsAnyAddress)
{
settings.Servers[i] = new NetworkBinding(IPAddress.Loopback, settings.Servers[i].Port);
}
break;
}
}
if (!found)
{
if (!settings.NetworkBinding.IsAnyAddress)
{
throw new ArgumentException("Invalid UDP broadcast server settings: The current server's network binding must also be present in the Servers[] bindings.");
}
}
// Initialize the clients and servers state.
clients = new Dictionary <IPEndPoint, ClientState>();
servers = new Dictionary <IPEndPoint, ServerState>();
// Open the socket and start receiving packets.
socket = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socket.IgnoreUdpConnectionReset = true;
socket.ReceiveBufferSize = settings.SocketBufferSize;
socket.SendBufferSize = settings.SocketBufferSize;
socket.Bind(settings.NetworkBinding);
onReceive = new AsyncCallback(OnReceive);
recvBuf = new byte[TcpConst.MTU];
rawRecvEP = new IPEndPoint(IPAddress.Any, 0);
socket.BeginReceiveFrom(recvBuf, 0, recvBuf.Length, SocketFlags.None, ref rawRecvEP, onReceive, null);
// Crank up a timer to send the ClientRegister messages to the server cluster.
registerTimer = new PolledTimer(settings.ClusterKeepAliveInterval, true);
registerTimer.FireNow(); // Make sure that we send registration messages immediately
bkTimer = new GatedTimer(new TimerCallback(OnBkTask), null, TimeSpan.Zero, settings.BkTaskInterval);
}
public void ListenOn(IPEndPoint localEP)
{
sock.Bind(localEP);
sock.Listen(100);
}
public void HttpConnection_Receive_Fail()
{
EnhancedSocket sockListen = null;
EnhancedSocket sockAccept = null;
HttpConnection con;
HttpRequest request;
HttpResponse response;
TimeSpan orgTimeout;
IAsyncResult ar;
orgTimeout = HttpStack.TimeoutSweepInterval;
HttpStack.TimeoutSweepInterval = TimeSpan.FromMilliseconds(250);
sockListen = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sockListen.Bind(new IPEndPoint(IPAddress.Any, ServerPort));
sockListen.Listen(10);
try
{
ar = sockListen.BeginAccept(null, null);
con = new HttpConnection(HttpOption.None);
con.Connect("http://localhost:" + ServerPort.ToString());
sockAccept = sockListen.EndAccept(ar);
request = new HttpRequest("GET", "/foo.htm", null);
request["Content-Length"] = request.Content.Size.ToString();
ar = con.BeginQuery(request, DateTime.MaxValue, null, null);
Thread.Sleep(100);
sockAccept.Close();
sockAccept = null;
try
{
response = con.EndQuery(ar);
Assert.Fail();
}
catch
{
}
Assert.IsTrue(con.IsClosed);
con.Close();
}
finally
{
HttpStack.TimeoutSweepInterval = orgTimeout;
if (sockListen != null)
{
sockListen.Close();
}
if (sockAccept != null)
{
sockAccept.Close();
}
}
}
/// <summary>
/// Creates and starts a UDP broadcast client using the settings passed.
/// </summary>
/// <param name="settings">The client settings.</param>
/// <exception cref="ArgumentException">Thrown if the settings passed are not valid.</exception>
public UdpBroadcastClient(UdpBroadcastClientSettings settings)
{
this.settings = settings;
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (settings.Servers == null || settings.Servers.Length == 0)
{
throw new ArgumentException("Invalid UDP broadcast client settings: At least one broadcast server endpoint is required.");
}
this.servers = new List <IPEndPoint>();
// $hack(jeff.lill)
//
// This is a bit of a hack to discover the source IP address to use for this instance.
// If the configured NetworkBinding specifies a specific interface, then we'll use
// this, otherwise we'll use the IPv4 address for the first active network adaptor we find.
// In a perfect world, I'd send a packet to the broadcast servers and have it respond with
// the UDP source address it sees that would discover the actual IP address. This hack
// should work 99% of the time though.
if (!settings.NetworkBinding.Address.Equals(IPAddress.Any))
{
this.sourceAddress = settings.NetworkBinding.Address;
}
else
{
this.sourceAddress = NetHelper.GetActiveAdapter();
}
// Open the socket and start receiving packets.
socket = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socket.IgnoreUdpConnectionReset = true;
socket.ReceiveBufferSize = settings.SocketBufferSize;
socket.SendBufferSize = settings.SocketBufferSize;
socket.Bind(settings.NetworkBinding);
onReceive = new AsyncCallback(OnReceive);
recvBuf = new byte[8192];
rawRecvEP = new IPEndPoint(IPAddress.Any, 0);
socket.BeginReceiveFrom(recvBuf, 0, recvBuf.Length, SocketFlags.None, ref rawRecvEP, onReceive, null);
// Crank up the timers.
keepAliveTimer = new PolledTimer(settings.KeepAliveInterval, false);
keepAliveTimer.FireNow();
serverResolveTimer = new PolledTimer(settings.ServerResolveInterval, false);
serverResolveTimer.FireNow();
bkTimer = new GatedTimer(new TimerCallback(OnBkTask), null, TimeSpan.Zero, settings.BkTaskInterval);
// Sleep for a couple seconds to allow the server DNS lookups to complete.
Thread.Sleep(2000);
}
private static int Reflector(string portArg)
{
try
{
NetReflector reflector;
int port;
if (!int.TryParse(portArg, out port))
{
Program.Error("Invalid network port.");
return(1);
}
Console.WriteLine();
Console.WriteLine("Starting network reflector on port [{0}]", port);
Console.WriteLine("Press [C] to close all connections and [X] to exit the test.");
Console.WriteLine();
reflector = new NetReflector(port);
while (true)
{
var ch = Console.ReadKey(true);
switch (ch.KeyChar)
{
case 'c':
case 'C':
reflector.CloseConnections();
break;
case 'x':
case 'X':
reflector.Stop();
return(0);
#if TEST
// UDP test code
case 'u':
case 'U':
{
var sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
var buf = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var ep = (EndPoint) new IPEndPoint(IPAddress.Any, 0);
sock.Bind();
sock.SendTo(buf, 0, buf.Length, SocketFlags.None, new IPEndPoint(IPAddress.Loopback, port));
for (int i = 0; i < buf.Length; i++)
{
buf[i] = 0;
}
sock.ReceiveFrom(buf, ref ep);
sock.Close();
}
break;
// TCP test code
case 't':
case 'T':
{
var sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.NoDelay = true;
sock.Connect(new IPEndPoint(IPAddress.Loopback, port));
for (int i = 0; i < 10; i++)
{
var buf = new byte[i + 1];
for (int j = 0; j < i + 1; j++)
{
buf[j] = (byte)j;
}
sock.Send(buf);
for (int j = 0; j < i + 1; j++)
{
buf[j] = 0;
}
var cbRecv = sock.Receive(buf);
}
sock.Close();
}
break;
#endif
}
}
}
catch (Exception e)
{
Program.Error("Error ({0}): {1}", e.GetType().Name, e.Message);
return(1);
}
}
