#region References
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text.RegularExpressions;
using System.Xml;
using Server.Network;
#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.
*/
// For R&R, put the file in the Info dir, with the other settings files
private static readonly string m_AddressMapConfigPath = Path.Combine("Info", "ServerListMap.xml");
// Triple of CIDR pattern (IPAddress/Length) to server listing address
private static List<(IPAddress, int, IPAddress)> _AddressMap = new List<(IPAddress, int, IPAddress)>();
// DEFAULT: public static readonly string Address = Config.Get("Server.Address", default(string));
public static readonly string Address = null;
// DEFAULT: public static readonly bool AutoDetect = Config.Get("Server.AutoDetect", true);
public static readonly bool AutoDetect = false;
public static string ServerName = MyServerSettings.ServerName();
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()
{
LoadAddressMap(m_AddressMapConfigPath);
if (Address == null)
{
if (AutoDetect)
{
AutoDetection();
}
}
else
{
Resolve(Address, out _PublicAddress);
}
EventSink.ServerList += EventSink_ServerList;
}
private static void LoadAddressMap(string ConfigFile)
{
if (!File.Exists(ConfigFile)) {
Console.WriteLine("ServerListMap: Not present @ {0}", ConfigFile);
return;
}
XmlDocument doc = new XmlDocument();
doc.Load(ConfigFile);
foreach (XmlNode node in doc.GetElementsByTagName("serverListMap")[0].ChildNodes)
{
if (node.Name.Equals("entry") && node.Attributes["cidrmatch"] != null && node.Attributes["destination"] != null)
{
var cidrmatch = node.Attributes["cidrmatch"].Value;
// This uses the added function at the EOF.
TryParseCIDR(cidrmatch, out var cidrAddress, out var cidrLength);
IPAddress net;
try
{
IPAddress.TryParse(cidrmatch, out net);
}
catch
{
Console.WriteLine("ServerListMap: Invalid CIDR {0} - XML: {1}", cidrmatch, node.OuterXml);
continue;
}
var destination = node.Attributes["destination"].Value;
IPAddress dest;
try
{
IPAddress.TryParse(destination, out dest);
}
catch
{
Console.WriteLine("ServerListMap: Invalid Destination {0} - XML: {1}", destination, node.OuterXml);
continue;
}
_AddressMap.Add((cidrAddress, cidrLength, dest));
Console.WriteLine("ServerListMap: {0} => {1}", cidrmatch, dest);
}
else if (node.NodeType != XmlNodeType.Comment)
Console.WriteLine("ServerListMap: XML does not match required specification - {0}", node.OuterXml);
}
}
private static void EventSink_ServerList(ServerListEventArgs e)
{
try
{
NetState ns = e.State;
Socket s = ns.Socket;
IPEndPoint ipep = (IPEndPoint)s.LocalEndPoint;
IPAddress localAddress = ipep.Address;
int localPort = ipep.Port;
IPEndPoint ipepRemote = (IPEndPoint)s.RemoteEndPoint;
if (IsPrivateNetwork(localAddress))
{
if (!IsPrivateNetwork(ipepRemote.Address) && _PublicAddress != null)
{
localAddress = _PublicAddress;
}
}
// ServerListMap matches
// NOTE: original - foreach (var (address, length, destination) in _AddressMap)
// This form of tuple deconstruction does not appear to work due to Mono/.NET version used here.
foreach (var i in _AddressMap)
{
// Pull data from our Tuple due to the lack of nicer foreach deconstruction
var address = i.Item1;
var length = i.Item2;
var destination = i.Item3;
if (Utility.IPMatchCIDR(address, ipepRemote.Address, length))
{
localAddress = destination;
break;
}
}
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
{
IPHostEntry iphe = Dns.GetHostEntry(addr);
if (iphe.AddressList.Length > 0)
{
outValue = iphe.AddressList[iphe.AddressList.Length - 1];
}
}
catch(Exception e)
{
// Diagnostics.ExceptionLogging.LogException(e);
Console.WriteLine(e);
}
}
private static bool HasPublicIPAddress()
{
NetworkInterface[] adapters = NetworkInterface.GetAllNetworkInterfaces();
System.Collections.Generic.IEnumerable<IPAddress> 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 (string service in services.Where(s => !string.IsNullOrWhiteSpace(s)))
{
try
{
uri = new Uri(service);
Console.WriteLine("ServerList: >>> {0}", uri.Host);
using (WebClient 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
{
}
if (ip != null)
{
break;
}
}
return ip;
}
//Added from the Utility file included with the patch
public static bool TryParseCIDR(string cidr, out IPAddress cidrAddress, out int length)
{
var cidrParts = cidr.Split('/');
try
{
IPAddress.TryParse(cidrParts[0], out cidrAddress);
Int32.TryParse(cidrParts[1], out length);
return true;
}
catch
{
cidrAddress = null;
length = 0;
return false;
}
}
}
}