264 lines
6.7 KiB
C#
264 lines
6.7 KiB
C#
#region References
|
|
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Net.Sockets;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
#endregion
|
|
|
|
namespace Server.Misc
|
|
{
|
|
public class ServerList
|
|
{
|
|
/*
|
|
* The default setting for Address, a value of 'null', will use your local IP address. If all of your local IP addresses
|
|
* are private network addresses and AutoDetect is 'true' then ServUO will attempt to discover your public IP address
|
|
* for you automatically.
|
|
*
|
|
* If you do not plan on allowing clients outside of your LAN to connect, you can set AutoDetect to 'false' and leave
|
|
* Address set to 'null'.
|
|
*
|
|
* If your public IP address cannot be determined, you must change the value of Address to your public IP address
|
|
* manually to allow clients outside of your LAN to connect to your server. Address can be either an IP address or
|
|
* a hostname that will be resolved when ServUO starts.
|
|
*
|
|
* If you want players outside your LAN to be able to connect to your server and you are behind a router, you must also
|
|
* forward TCP port 2593 to your private IP address. The procedure for doing this varies by manufacturer but generally
|
|
* involves configuration of the router through your web browser.
|
|
*
|
|
* ServerList will direct connecting clients depending on both the address they are connecting from and the address and
|
|
* port they are connecting to. If it is determined that both ends of a connection are private IP addresses, ServerList
|
|
* will direct the client to the local private IP address. If a client is connecting to a local public IP address, they
|
|
* will be directed to whichever address and port they initially connected to. This allows multihomed servers to function
|
|
* properly and fully supports listening on multiple ports. If a client with a public IP address is connecting to a
|
|
* locally private address, the server will direct the client to either the AutoDetected IP address or the manually entered
|
|
* IP address or hostname, whichever is applicable. Loopback clients will be directed to loopback.
|
|
*
|
|
* If you would like to listen on additional ports (i.e. 22, 23, 80, for clients behind highly restrictive egress
|
|
* firewalls) or specific IP adddresses you can do so by modifying the file SocketOptions.cs found in this directory.
|
|
*/
|
|
|
|
public static readonly string Address = Config.Get("Server.Address", default(string));
|
|
|
|
public static readonly bool AutoDetect = Config.Get("Server.AutoDetect", true);
|
|
|
|
public static string ServerName = Config.Get("Server.Name", "My Shard");
|
|
|
|
private static IPAddress _PublicAddress;
|
|
|
|
private static readonly Regex _AddressPattern = new Regex(@"([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})");
|
|
|
|
public static void Initialize()
|
|
{
|
|
if (Address == null)
|
|
{
|
|
if (AutoDetect)
|
|
{
|
|
AutoDetection();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Resolve(Address, out _PublicAddress);
|
|
}
|
|
|
|
EventSink.ServerList += EventSink_ServerList;
|
|
}
|
|
|
|
private static void EventSink_ServerList(ServerListEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
var ns = e.State;
|
|
var s = ns.Socket;
|
|
|
|
var ipep = (IPEndPoint)s.LocalEndPoint;
|
|
|
|
var localAddress = ipep.Address;
|
|
var localPort = ipep.Port;
|
|
|
|
if (IsPrivateNetwork(localAddress))
|
|
{
|
|
ipep = (IPEndPoint)s.RemoteEndPoint;
|
|
|
|
if (!IsPrivateNetwork(ipep.Address) && _PublicAddress != null)
|
|
{
|
|
localAddress = _PublicAddress;
|
|
}
|
|
}
|
|
|
|
e.AddServer(ServerName, new IPEndPoint(localAddress, localPort));
|
|
}
|
|
catch
|
|
{
|
|
e.Rejected = true;
|
|
}
|
|
}
|
|
|
|
public static string[] IPServices =
|
|
{
|
|
"http://services.servuo.com/ip.php", "http://api.ipify.org",
|
|
"http://checkip.dyndns.org/"
|
|
};
|
|
|
|
private static void AutoDetection()
|
|
{
|
|
if (!HasPublicIPAddress())
|
|
{
|
|
Utility.PushColor(ConsoleColor.Yellow);
|
|
Console.WriteLine("ServerList: Auto-detecting public IP address...");
|
|
|
|
_PublicAddress = FindPublicAddress(IPServices);
|
|
|
|
if (_PublicAddress != null)
|
|
{
|
|
Console.WriteLine("ServerList: Done: '{0}'", _PublicAddress);
|
|
}
|
|
else
|
|
{
|
|
_PublicAddress = IPAddress.Any;
|
|
|
|
Console.WriteLine("ServerList: Failed: reverting to private IP address...");
|
|
}
|
|
|
|
Utility.PopColor();
|
|
}
|
|
}
|
|
|
|
private static void Resolve(string addr, out IPAddress outValue)
|
|
{
|
|
if (IPAddress.TryParse(addr, out outValue))
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
var iphe = Dns.GetHostEntry(addr);
|
|
|
|
if (iphe.AddressList.Length > 0)
|
|
{
|
|
outValue = iphe.AddressList[iphe.AddressList.Length - 1];
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
private static bool HasPublicIPAddress()
|
|
{
|
|
var adapters = NetworkInterface.GetAllNetworkInterfaces();
|
|
var uips = adapters.Select(a => a.GetIPProperties())
|
|
.SelectMany(p => p.UnicastAddresses.Cast<IPAddressInformation>(), (p, u) => u.Address);
|
|
|
|
return
|
|
uips.Any(
|
|
ip => !IPAddress.IsLoopback(ip) && ip.AddressFamily != AddressFamily.InterNetworkV6 && !IsPrivateNetwork(ip));
|
|
}
|
|
|
|
private static bool IsPrivateNetwork(IPAddress ip)
|
|
{
|
|
// 10.0.0.0/8
|
|
// 172.16.0.0/12
|
|
// 192.168.0.0/16
|
|
// 169.254.0.0/16
|
|
// 100.64.0.0/10 RFC 6598
|
|
|
|
if (ip.AddressFamily == AddressFamily.InterNetworkV6)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (Utility.IPMatch("192.168.*", ip))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (Utility.IPMatch("10.*", ip))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (Utility.IPMatch("172.16-31.*", ip))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (Utility.IPMatch("169.254.*", ip))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (Utility.IPMatch("100.64-127.*", ip))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static IPAddress FindPublicAddress(params string[] services)
|
|
{
|
|
if (services == null || services.Length == 0)
|
|
{
|
|
services = IPServices;
|
|
}
|
|
|
|
if (services == null || services.Length == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
IPAddress ip = null;
|
|
|
|
Uri uri;
|
|
string data;
|
|
Match match;
|
|
|
|
foreach (var service in services.Where(s => !String.IsNullOrWhiteSpace(s)))
|
|
{
|
|
try
|
|
{
|
|
uri = new Uri(service);
|
|
|
|
Console.WriteLine("ServerList: >>> {0}", uri.Host);
|
|
|
|
using (var client = new WebClient())
|
|
{
|
|
data = client.DownloadString(uri);
|
|
}
|
|
|
|
Console.WriteLine("ServerList: <<< {0}", data);
|
|
|
|
match = _AddressPattern.Match(data);
|
|
|
|
if (!match.Success || !IPAddress.TryParse(match.Value, out ip))
|
|
{
|
|
ip = null;
|
|
}
|
|
}
|
|
catch (UriFormatException)
|
|
{
|
|
Console.WriteLine("ServerList: Invalid IP service Uri '{0}'", service);
|
|
|
|
ip = null;
|
|
}
|
|
catch
|
|
{
|
|
ip = null;
|
|
}
|
|
|
|
if (ip != null)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ip;
|
|
}
|
|
}
|
|
}
|