public static async Task <bool> ForwardPortsAsync()
{
if (Status != UPnPStatus.Enabled)
{
throw new InvalidOperationException($"{nameof(ForwardPortsAsync)} can only be called in status {UPnPStatus.Enabled}.");
}
try
{
SkirmishHostMapping = new Mapping(Protocol.Udp, Ports.SkirmishHost, Ports.SkirmishHost, 0, "OpenSAGE Skirmish Host");
await NatDevice.CreatePortMapAsync(SkirmishHostMapping);
SkirmishGameMapping = new Mapping(Protocol.Udp, Ports.SkirmishGame, Ports.SkirmishGame, 0, "OpenSAGE Skirmish Game");
await NatDevice.CreatePortMapAsync(SkirmishGameMapping);
Status = UPnPStatus.PortsForwarded;
Logger.Info("Created port forwarding.");
return(true);
}
catch (Exception e)
{
if (SkirmishHostMapping != null)
{
await NatDevice.DeletePortMapAsync(SkirmishHostMapping);
}
if (SkirmishGameMapping != null)
{
await NatDevice.DeletePortMapAsync(SkirmishGameMapping);
}
Logger.Error(e, "Failed to forward port.");
return(false);
}
}
/// <summary>
/// Stops listening for incoming connections.
/// </summary>
public void StopListening()
{
Listening = false;
ReleaseClients();
listener?.Shutdown(SocketShutdown.Both);
listener?.Close();
listener?.Dispose();
listener = null;
nat?.DeletePortMapAsync(portMap);
}
public Task <PortResult> ClosePort(UPnPPort port)
{
return(Task.Run(async() =>
{
if (State == UPnPSupportState.NoPrepared)
{
return PortResult.EngineNotPrepared;
}
else if (State == UPnPSupportState.NotSupported)
{
return PortResult.EngineNotSupported;
}
else
{
try
{
PortResult opened = await CheckPort(port);
switch (opened)
{
case PortResult.Opened:
switch (port.Type)
{
case PortType.TCP:
await device.DeletePortMapAsync(new Mapping(Protocol.Tcp, port.InternalPort, port.ExternalPort, port.Description));
return PortResult.Closed;
case PortType.UDP:
await device.DeletePortMapAsync(new Mapping(Protocol.Udp, port.InternalPort, port.ExternalPort, port.Description));
return PortResult.Closed;
case PortType.BOTH:
await device.DeletePortMapAsync(new Mapping(Protocol.Tcp, port.InternalPort, port.ExternalPort, port.Description));
await device.DeletePortMapAsync(new Mapping(Protocol.Udp, port.InternalPort, port.ExternalPort, port.Description));
return PortResult.Closed;
default:
return PortResult.FailedUnknown;
}
case PortResult.Closed:
return PortResult.AlreadyClosed;
default:
return PortResult.FailedUnknown;
}
}
catch (Exception)
{
return PortResult.FailedUnknown;
}
}
}));
}
private static Task Test()
{
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource();
cts.CancelAfter(5000);
NatDevice device = null;
var sb = new StringBuilder();
IPAddress ip = null;
return(nat.DiscoverDeviceAsync(PortMapper.Upnp, cts)
.ContinueWith(task =>
{
device = task.Result;
return device.GetExternalIPAsync();
})
.Unwrap()
.ContinueWith(task =>
{
ip = task.Result;
sb.AppendFormat("\nYour IP: {0}", ip);
return device.CreatePortMapAsync(new Mapping(Protocol.Tcp, 7777, 7777, 0, "myGame Server (TCP)"));
})
.Unwrap()
.ContinueWith(task =>
{
return device.CreatePortMapAsync(new Mapping(Protocol.Udp, 7777, 7777, 0, "myGame Server (UDP)"));
})
.Unwrap()
.ContinueWith(task =>
{
sb.AppendFormat("\nAdded mapping: {0}:7777 -> 127.0.0.1:7777\n", ip);
sb.AppendFormat("\n+------+-------------------------------+--------------------------------+------------------------------------+-------------------------+");
sb.AppendFormat("\n| PORT | PUBLIC (Reacheable) | PRIVATE (Your computer) | Description | |");
sb.AppendFormat("\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
sb.AppendFormat("\n| | IP Address | Port | IP Address | Port | | Expires |");
sb.AppendFormat("\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
return device.GetAllMappingsAsync();
})
.Unwrap()
.ContinueWith(task =>
{
foreach (var mapping in task.Result)
{
sb.AppendFormat("\n| {5} | {0,-20} | {1,6} | {2,-21} | {3,6} | {4,-35}|{6,25}|",
ip, mapping.PublicPort, mapping.PrivateIP, mapping.PrivatePort, mapping.Description,
mapping.Protocol == Protocol.Tcp ? "TCP" : "UDP", mapping.Expiration.ToLocalTime());
}
sb.AppendFormat("\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
sb.AppendFormat("\n[Removing TCP mapping] {0}:7777 -> 127.0.0.1:7777", ip);
return device.DeletePortMapAsync(new Mapping(Protocol.Tcp, 1600, 1700));
})
.Unwrap()
.ContinueWith(task =>
{
sb.AppendFormat("\n[Done]");
Debug.Log(sb);
}));
}
public void CloseNAT()
{
try
{
_searchToken?.Cancel();
var task = _device?.DeletePortMapAsync(_tcpMapping);
var task2 = _device?.DeletePortMapAsync(_udpMapping);
task?.Wait(3000);
task2?.Wait(3000);
//Doesnt clear mappings on Shutdown - not sure why? The async deletes also dont work on application close but DO work on start / stop button press.
//Maybe background threads are terminated?
}
catch (Exception ex) { }
}
public void RemoveMapping()
{
if (routerDevice != null)
{
if (mappedLocalIP != null)
{
Logging.info(String.Format("Removing previously mapped: {0} -> {1}:{2}", mappedPublicPort, mappedLocalIP.ToString(), mappedPublicPort));
try
{
Mapping m = GetPublicPortMappingInternal(mappedPublicPort);
if (m != null)
{
Task deleteMapTask = routerDevice.DeletePortMapAsync(m);
deleteMapTask.Wait(5000);
mappedPublicPort = 0;
mappedLocalIP = null;
}
}
catch (MappingException ex)
{
Logging.error(String.Format("Unable to remove port mapping for public port {0} to {1}:{2}: {3}",
mappedPublicPort,
mappedLocalIP.ToString(), mappedPublicPort,
ex.Message));
}
}
}
}
async Task unMapPorts()
{
SystemLog.addEntry("Cleaning up UPnP mappings...");
try
{
if (device == null)
{
initUPnP();
}
externalIPFromUPnP = await device.GetExternalIPAsync();
foreach (Mapping z in await device.GetAllMappingsAsync())
{
if (z.Description == Environment.MachineName + " Dimension Mapping")
{
await device.DeletePortMapAsync(z);
SystemLog.addEntry("Successfully deleted UPnP mapping " + z.Description);
UPnPActive = true;
}
}
}
catch
{
UPnPActive = false;
SystemLog.addEntry("Failed to delete UPnP mapping.");
//UPnP probably not supported
}
}
public async Task ClosePort(NatDevice device, int port)
{
try
{
await device.DeletePortMapAsync(new Mapping(Protocol.Udp, port, port, 86400, "MonoTorrent"));
}
catch (Exception ex)
{
}
try
{
await device.DeletePortMapAsync(new Mapping(Protocol.Tcp, port, port, 86400, "MonoTorrent"));
}
catch (Exception ex)
{
}
}
/// <summary>
/// Stops listening for incoming connections.
/// </summary>
public void StopListening()
{
Listening = false;
ReleaseClients();
httpListener?.Stop();
httpListener?.Close();
httpListener = null;
nat?.DeletePortMapAsync(portMap);
}
public static async Task RemovePortForward()
{
try
{
await natDevice.DeletePortMapAsync(mapping);
}
catch (Exception exp)
{
}
}
public static async Task ClearAsync(int port)
{
try
{
await _device.DeletePortMapAsync(await _device.GetSpecificMappingAsync(Protocol.Tcp, port));
}
catch
{
// ignored
}
}
public async Task <bool> EnsureMapping()
{
NodeServerTrace.Information("EnsureMapping");
var device = await GetNatDeviceAsync();
return(device == null ? false : await device.GetSpecificMappingAsync(Protocol.Tcp, _ServerPort).ContinueWith(t =>
{
if (t.IsFaulted)
{
NodeServerTrace.Error("GetExternalIP", t.Exception);
return false;
}
var mapping = t.Result;
try
{
if (mapping != null && !mapping.PrivateIP.Equals(InternalIPAddress))
{
NodeServerTrace.Information($"existing mapping mismatch. got: {mapping.PrivateIP}, need: {InternalIPAddress}");
_NatDevice.DeletePortMapAsync(mapping).Wait();
mapping = null;
}
if (mapping == null)
{
NodeServerTrace.Information($"creaing mapping with IP: {InternalIPAddress}");
_NatDevice.CreatePortMapAsync(
new Mapping(
Protocol.Tcp,
InternalIPAddress,
_ServerPort,
_ServerPort,
0, //TODO: session lifetime?
MAPPING_DESC
)
).Wait();
}
IEnumerable <Mapping> exisingMappings = _NatDevice.GetAllMappingsAsync().Result;
return exisingMappings.Count(exisintMapping => exisintMapping.PublicPort == _ServerPort) == 1;
}
catch (Exception e)
{
NodeServerTrace.Error("Mapping", e);
return false;
}
}));
}
private void AttemptToRemovePortInternally(int port)
{
try
{
UPnPDevice.DeletePortMapAsync(UPnPDevice.GetSpecificMappingAsync(Protocol.Tcp, port).Result).Wait();
Logger.WriteInfo("Successfully removed forwarded port " + port);
}
catch (Exception e)
{
Logger.WriteWarning("Failed to remove forwarded port " + port + ".\n" + e);
}
}
public static async Task RemovePortForward()
{
try
{
await natDevice.DeletePortMapAsync(mapping);
}
catch (Exception e)
{
Console.WriteLine("Port removal failed: {0}", e.Message);
Log.Write("nat", e.StackTrace);
}
}
private async Task RemoveMapping(Mapping mapping)
{
if (!m_deviceAvailable.Value)
{
throw new NatDeviceNotFoundException();
}
try
{ await m_device.DeletePortMapAsync(mapping); }
catch (NatDeviceNotFoundException e)
{ m_deviceAvailable.Value = false; throw e; }
}
private async void numeric_Port_ValueChanged(object sender, EventArgs e)
{
if (!checkBox_UseUPnP.Checked)
{
return;
}
textBox_upnpIP.Text = @"Updating UPnP...";
#if DEBUG
label_Status.Text = @"Deleting existing UPnP...";
#endif
await _device.DeletePortMapAsync(_currentMapping);
#if DEBUG
label_Status.Text = @"Creating new UPnP...";
#endif
await _device.CreatePortMapAsync(_currentMapping = new Mapping(Protocol.Udp,
Convert.ToInt32(numeric_Port.Value), Convert.ToInt32(numeric_Port.Value), "Touhou 7"));
textBox_upnpIP.Text = _device.GetExternalIPAsync().Result.ToString();
label_Status.Text = @"UPnP updated.";
}
private bool disposedValue = false; // To detect redundant calls
/// <summary>
/// Use this method to free managed resources
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing && Listening)
{
StopListening();
}
nat?.DeletePortMapAsync(portMap);
portMap = null;
nat = null;
disposedValue = true;
}
}
private void AuthForm_FormClosing(object sender, FormClosingEventArgs e)
{
try
{
_observer.Stop();
if (chat == null || router == null || chat.IsDisposed)
{
router.DeletePortMapAsync(new Mapping(Protocol.Udp, openPort, openPort));
}
}
catch
{
}
}
/// <summary>
/// Deletes an existing port mapping.
/// </summary>
/// <param name="port">The port mapping to delete.</param>
public async void DeletePortMapAsync(int port)
{
if (_mappings.TryGetValue(port, out var mapping))
{
try
{
await _device.DeletePortMapAsync(mapping);
_mappings.Remove(mapping.PrivatePort);
}
catch (Exception ex) when(ex is MappingException || ex is NatDeviceNotFoundException)
{
}
}
}
public void Init()
{
try
{
NatDiscoverer natdisc = new NatDiscoverer();
NatDevice natdev = natdisc.DiscoverDeviceAsync().Result;
Mapping map = natdev.GetSpecificMappingAsync(Protocol.Tcp, TheServer.Port).Result;
if (map != null)
{
natdev.DeletePortMapAsync(map).Wait();
}
natdev.CreatePortMapAsync(new Mapping(Protocol.Tcp, TheServer.Port, TheServer.Port, "Voxalia")).Wait();
map = natdev.GetSpecificMappingAsync(Protocol.Tcp, TheServer.Port).Result;
IPAddress publicIP = natdev.GetExternalIPAsync().Result;
SysConsole.Output(OutputType.INIT, "Successfully opened server to public address " + map.PrivateIP + " or " + publicIP.ToString() + ", with port " + map.PrivatePort + ", as " + map.Description);
}
catch (Exception ex)
{
SysConsole.Output(OutputType.WARNING, "Trying to open port " + TheServer.Port + ": " + ex.Message);
}
if (Socket.OSSupportsIPv6)
{
try
{
ListenSocket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
ListenSocket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false);
ListenSocket.Bind(new IPEndPoint(IPAddress.IPv6Any, TheServer.Port));
}
catch (Exception ex)
{
SysConsole.Output("Opening IPv6/IPv4 combo-socket", ex);
ListenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ListenSocket.Bind(new IPEndPoint(IPAddress.Any, TheServer.Port));
}
}
else
{
ListenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ListenSocket.Bind(new IPEndPoint(IPAddress.Any, TheServer.Port));
}
ListenSocket.Listen(100);
ListenThread = new Thread(new ThreadStart(ListenLoop))
{
Name = VoxProgram.GameName + "_v" + VoxProgram.GameVersion + "_NetworkListenThread"
};
ListenThread.Start();
}
public async Task <bool> Unmap(int port)
{
try {
await GetDevice();
await device.DeletePortMapAsync(
new Mapping(
Protocol.Tcp,
port,
port
)
);
return(true);
} catch (Exception error) {
Console.WriteLine(
"PortForwarding: {0}",
error
);
return(false);
}
}
/// <summary>
/// Gestion de l'ouverture automatique des ports UDP pour le P2P
/// </summary>
/// <param name="flag"></param>
private void InitUPNP(bool flag)
{
if (flag)
{
if (m_bUPNP)
{
return;
}
var t = Task.Run(async() =>
{
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource();
try
{
Device = await nat.DiscoverDeviceAsync(PortMapper.Upnp, cts);
#if DEBUG
Log.LogMessage("P2PManager: Routeur UPNP détecté", Color.DarkBlue, 1);
#endif
await Device.CreatePortMapAsync(new Mapping(Open.Nat.Protocol.Udp, m_Port, m_Port, 0, "ffs2playP3D"));
#if DEBUG
Log.LogMessage("P2PManager: Ouverture du port UPNP ok", Color.DarkBlue, 1);
#endif
}
catch (AggregateException ae)
{
ae.Handle((x) =>
{
if (x is NatDeviceNotFoundException)
{
Log.LogMessage("P2PManager: Routeur UPNP introuvable", Color.DarkViolet);
return(true);
}
if (x is MappingException)
{
Log.LogMessage("P2PManager: Erreur lors de l'ouverture du port " + m_Port.ToString() + " : " + x.Message, Color.DarkViolet);
return(true);
}
return(false);
});
}
m_bUPNP = true;
});
}
else
{
if ((!m_bUPNP) || (Device == null))
{
return;
}
var t = Task.Run(async() =>
{
try
{
await Device.DeletePortMapAsync(new Mapping(Open.Nat.Protocol.Udp, m_Port, m_Port));
#if DEBUG
Log.LogMessage("P2PManager: Fermeture du port UPNP ok", Color.DarkBlue, 1);
#endif
}
catch (AggregateException ae)
{
ae.Handle((x) =>
{
if (x is MappingException)
{
Log.LogMessage("P2PManager: Erreur lors de la fermetur du port", Color.DarkViolet);
return(true);
}
return(false);
});
}
m_bUPNP = false;
});
}
}
public static async void ClosePort(UPnPSettings settings)
{
await _natDevice.DeletePortMapAsync(new Mapping(Protocol.Udp,
settings.PrivatePort, settings.PublicPort, settings.LifeTime, "RakNet UPnP"));
}
public static async Task <NatDevice> OpenServerPort(int port, Protocol protocol)
{
if (sDevice == null)
{
return(null);
}
try
{
var map = await sDevice.GetSpecificMappingAsync(protocol, port);
if (map != null)
{
await sDevice.DeletePortMapAsync(map);
}
await sDevice.CreatePortMapAsync(new Mapping(protocol, port, port, "Intersect Engine"));
switch (protocol)
{
case Protocol.Tcp:
Log.Pretty.Info(Strings.Upnp.forwardedtcp.ToString(port));
sLog.AppendLine(Strings.Upnp.forwardedtcp.ToString(port));
break;
case Protocol.Udp:
Log.Pretty.Info(Strings.Upnp.forwardedudp.ToString(port));
sLog.AppendLine(Strings.Upnp.forwardedudp.ToString(port));
sPortForwarded = true;
break;
default:
throw new ArgumentOutOfRangeException(nameof(protocol), protocol, null);
}
}
catch (Exception ex)
{
switch (protocol)
{
case Protocol.Tcp:
Log.Pretty.Warn(Strings.Upnp.failedforwardingtcp.ToString(port));
Log.Warn("UPnP Could Not Open TCP Port " + port + Environment.NewLine + ex.ToString());
sLog.AppendLine("UPnP Could Not Open TCP Port " + port + Environment.NewLine + ex.ToString());
break;
case Protocol.Udp:
Log.Pretty.Warn(Strings.Upnp.failedforwardingudp.ToString(port));
Log.Warn("UPnP Could Not Open UDP Port " + port + Environment.NewLine + ex.ToString());
sLog.AppendLine("UPnP Could Not Open UDP Port " + port + Environment.NewLine + ex.ToString());
break;
default:
throw new ArgumentOutOfRangeException(nameof(protocol), protocol, null);
}
}
return(null);
}
public static void Main(string[] args)
{
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource();
cts.CancelAfter(5000);
NatDevice device = null;
var sb = new StringBuilder();
IPAddress ip = null;
var t = nat.DiscoverDeviceAsync(PortMapper.Pmp, cts);
t.ContinueWith(tt =>
{
device = tt.Result;
device.GetExternalIPAsync()
.ContinueWith(task =>
{
ip = task.Result;
sb.AppendFormat("\nYour IP: {0}", ip);
return(device.CreatePortMapAsync(new Mapping(Protocol.Tcp, 1600, 1700, "Open.Nat (temporary)")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, 1601, 1701, "Open.Nat (Session lifetime)")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, 1602, 1702, 0, "Open.Nat (Permanent lifetime)")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, 1603, 1703, 20, "Open.Nat (Manual lifetime)")));
})
.Unwrap()
.ContinueWith(task =>
{
sb.AppendFormat("\nAdded mapping: {0}:1700 -> 127.0.0.1:1600\n", ip);
sb.AppendFormat(
"\n+------+-------------------------------+--------------------------------+------------------------------------+-------------------------+");
sb.AppendFormat("\n| PROT | PUBLIC (Reacheable) | PRIVATE (Your computer) | Descriptopn | |");
sb.AppendFormat(
"\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
sb.AppendFormat("\n| | IP Address | Port | IP Address | Port | | Expires |");
sb.AppendFormat(
"\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
return(device.GetAllMappingsAsync());
})
.Unwrap()
.ContinueWith(task =>
{
foreach (var mapping in task.Result)
{
sb.AppendFormat("\n| {5} | {0,-20} | {1,6} | {2,-21} | {3,6} | {4,-35}|{6,25}|",
ip, mapping.PublicPort, mapping.PrivateIP, mapping.PrivatePort, mapping.Description,
mapping.Protocol == Protocol.Tcp ? "TCP" : "UDP", mapping.Expiration.ToLocalTime());
}
sb.AppendFormat(
"\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
sb.AppendFormat("\n[Removing TCP mapping] {0}:1700 -> 127.0.0.1:1600", ip);
return(device.DeletePortMapAsync(new Mapping(Protocol.Tcp, 1600, 1700)));
})
.Unwrap()
.ContinueWith(task =>
{
sb.AppendFormat("\n[Done]");
Console.WriteLine(sb.ToString());
Console.WriteLine("");
Console.WriteLine("Socket listening on port 1602. Remember, it is mapped to external port 1702!!!");
Console.WriteLine("Test it with http://www.canyouseeme.org/ online tool");
var endPoint = new IPEndPoint(IPAddress.Any, 1602);
var socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(endPoint);
socket.Listen(4);
socket.Close();
Console.WriteLine("Press any key to exit...");
});
}, TaskContinuationOptions.OnlyOnRanToCompletion);
try
{
t.Wait();
}
catch (AggregateException e)
{
if (e.InnerException is NatDeviceNotFoundException)
{
Console.WriteLine("Not found");
Console.WriteLine("Press any key to exit...");
}
}
Console.ReadKey();
}
//var device = await nat.DiscoverDeviceAsync(PortMapper.Upnp, cts);
//await device.CreatePortMapAsync(new Mapping(Protocol.Tcp, 1600, 1700, "Open.Nat (temporary)"));
//await device.CreatePortMapAsync(new Mapping(Protocol.Tcp, 1601, 1701, "Open.Nat (Session lifetime)"));
//await device.CreatePortMapAsync(new Mapping(Protocol.Tcp, 1602, 1702, 0, "Open.Nat (Permanent lifetime)"));
//await device.CreatePortMapAsync(new Mapping(Protocol.Tcp, 1603, 1703, 20, "Open.Nat (Manual lifetime)"));
public static async Task ClosePort(ushort port)
{
await device.DeletePortMapAsync(new Mapping(Protocol.Tcp, port, port, "Minecraft Server Starter"));
}
