private async static Task Test()
{
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource(5000);
var device = await nat.DiscoverDeviceAsync(PortMapper.Upnp, cts);
var sb = new StringBuilder();
var ip = await device.GetExternalIPAsync();
sb.AppendFormat("\nYour IP: {0}", ip);
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)"));
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+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
foreach (var mapping in await device.GetAllMappingsAsync())
{
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);
await device.DeletePortMapAsync(new Mapping(Protocol.Tcp, 1600, 1700));
sb.AppendFormat("\n[Done]");
Console.WriteLine(sb.ToString());
/*
var mappings = await device.GetAllMappingsAsync();
var deleted = mappings.All(x => x.Description != "Open.Nat Testing");
Console.WriteLine(deleted
? "[SUCCESS]: Test mapping effectively removed ;)"
: "[FAILURE]: Test mapping wan not removed!");
*/
}
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, 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());
});
}
/// <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 async Task Connect()
#endif
{
_server.WhenDiscoveryRequest = () =>
"HTTP/1.1 200 OK\r\n"
+ "Server: Custom/1.0 UPnP/1.0 Proc/Ver\r\n"
+ "EXT:\r\n"
+ "Location: http://[::1]:5431/dyndev/uuid:0000e068-20a0-00e0-20a0-48a8000808e0\r\n"
+ "Cache-Control:max-age=1800\r\n"
+ "ST:urn:schemas-upnp-org:service:WANIPConnection:1\r\n"
+ "USN:uuid:0000e068-20a0-00e0-20a0-48a802086048::urn:schemas-upnp-org:service:WANIPConnection:1";
_server.WhenGetExternalIpAddress = (ctx) =>
{
var responseXml = "<?xml version=\"1.0\"?>" +
"<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" " +
"s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">" +
"<s:Body>" +
"<m:GetExternalIPAddressResponse xmlns:m=\"urn:schemas-upnp-org:service:WANIPConnection:1\">" +
"<NewExternalIPAddress>FE80::0202:B3FF:FE1E:8329</NewExternalIPAddress>" +
"</m:GetExternalIPAddressResponse>" +
"</s:Body>" +
"</s:Envelope>";
var bytes = Encoding.UTF8.GetBytes(responseXml);
var response = ctx.Response;
response.OutputStream.Write(bytes, 0, bytes.Length);
response.OutputStream.Flush();
response.StatusCode = 200;
response.StatusDescription = "OK";
response.Close();
};
var nat = new NatDiscoverer();
#if NET35
var cts = new CancellationTokenSource();
cts.CancelAfter(5000);
NatDevice device = null;
nat.DiscoverDeviceAsync(PortMapper.Upnp, cts)
.ContinueWith(tt =>
{
device = tt.Result;
Assert.IsNotNull(device);
});
device.GetExternalIPAsync()
.ContinueWith(tt =>
{
var ip = tt.Result;
Assert.AreEqual(IPAddress.Parse("FE80::0202:B3FF:FE1E:8329"), ip);
});
#else
var cts = new CancellationTokenSource(5000);
var device = await nat.DiscoverDeviceAsync(PortMapper.Upnp, cts);
Assert.IsNotNull(device);
var ip = await device.GetExternalIPAsync();
Assert.AreEqual(IPAddress.Parse("FE80::0202:B3FF:FE1E:8329"), ip);
#endif
}
async void StartServer()
{
if (Settings.Instance.Server.TryUPnP)
{
Logger.Instance.Log($"Trying to open port {Settings.Instance.Server.Port} using UPnP...");
try
{
NatDiscoverer discoverer = new NatDiscoverer();
CancellationTokenSource cts = new CancellationTokenSource(2500);
NatDevice device = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, cts);
await device.CreatePortMapAsync(new Mapping(Protocol.Tcp, Settings.Instance.Server.Port, Settings.Instance.Server.Port, "BeatSaber Multiplayer Server"));
Logger.Instance.Log($"Port {Settings.Instance.Server.Port} is open!");
}
catch (Exception)
{
Logger.Instance.Warning($"Can't open port {Settings.Instance.Server.Port} using UPnP!");
}
}
Logger.Instance.Log("Starting server...");
_listener = new TcpListener(IPAddress.Any, Settings.Instance.Server.Port);
_listener.Start();
Logger.Instance.Log("Waiting for clients...");
ServerLoopThread = new Thread(ServerLoop)
{
IsBackground = true
};
ServerLoopThread.Start();
AcceptClientThread();
if (Settings.Instance.Server.WSEnabled)
{
if (Settings.Instance.Server.TryUPnP)
{
Logger.Instance.Log($"Trying to open port {Settings.Instance.Server.WSPort} using UPnP...");
try
{
NatDiscoverer discoverer = new NatDiscoverer();
CancellationTokenSource cts = new CancellationTokenSource(2500);
NatDevice device = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, cts);
await device.CreatePortMapAsync(new Mapping(Protocol.Tcp, Settings.Instance.Server.WSPort, Settings.Instance.Server.WSPort, "BeatSaber Multiplayer WebSocket Server"));
Logger.Instance.Log($"Port {Settings.Instance.Server.WSPort} is open!");
}
catch (Exception)
{
Logger.Instance.Warning($"Can't open port {Settings.Instance.Server.WSPort} using UPnP!");
}
}
wss = new WebSocketServer(Settings.Instance.Server.WSPort);
wss.AddWebSocketService <Broadcast>("/");
wss.Start();
Logger.Instance.Log($"WebSocket Server started @ {Settings.Instance.Server.IP}:{Settings.Instance.Server.WSPort}");
}
Dictionary <string, int> _serverHubs = new Dictionary <string, int>();
for (int i = 0; i < Settings.Instance.Server.ServerHubIPs.Length; i++)
{
if (Settings.Instance.Server.ServerHubPorts.Length <= i)
{
_serverHubs.Add(Settings.Instance.Server.ServerHubIPs[i], 3700);
}
else
{
_serverHubs.Add(Settings.Instance.Server.ServerHubIPs[i], Settings.Instance.Server.ServerHubPorts[i]);
}
}
_serverHubs.AsParallel().ForAll(x =>
{
ServerHubClient client = new ServerHubClient();
_serverHubClients.Add(client);
client.Connect(x.Key, x.Value);
}
);
}
public static async Task <int> MapPortTask(int privatePort, int publicPort)
{
var logFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "OpenNat.log");
try
{
if (!NatDiscoverer.TraceSource.Listeners.Contains(TextWriterTraceListener))
{
NatDiscoverer.TraceSource.Listeners.Remove(TextWriterTraceListener);
}
TextWriterTraceListener.Close();
if (File.Exists(logFile))
{
File.Delete(logFile);
}
}
catch
{
// ignored
}
NatDiscoverer.ReleaseAll();
NatDiscoverer.TraceSource.Switch.Level = SourceLevels.All;
if (TextWriterTraceListener == null)
{
TextWriterTraceListener = new TextWriterTraceListener(logFile, "OpenNatTxtLog");
}
if (!NatDiscoverer.TraceSource.Listeners.Contains(TextWriterTraceListener))
{
NatDiscoverer.TraceSource.Listeners.Add(TextWriterTraceListener);
}
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource(30 * 1000); //30 Sec
var device = await nat.DiscoverDeviceAsync(PortMapper.Upnp, cts);
var externalIp = await device.GetExternalIPAsync();
var allMappings = await device.GetAllMappingsAsync();
var localIp = Dns.GetHostEntry(Dns.GetHostName()).AddressList
.FirstOrDefault(key => key.AddressFamily == AddressFamily.InterNetwork);
var enumerable = allMappings as Mapping[] ?? allMappings.ToArray();
if (enumerable.Any(key => //Equals(key.PrivateIP, localIp) && key.Description == "AOEO Project Celeste"
key.PublicPort == 1000))
{
var r = enumerable.FirstOrDefault(
key => //Equals(key.PrivateIP, localIp) && key.Description == "AOEO Project Celeste"
key.PublicPort == 1000);
if (r != null)
{
await device.DeletePortMapAsync(r);
}
}
//var rnd = new Random(DateTime.UtcNow.Millisecond);
var newPublicPort = publicPort;
//while (enumerable.Any(key => key.PublicPort == newPublicPort))
// newPublicPort = rnd.Next(1000, ushort.MaxValue);
await device.CreatePortMapAsync(new Mapping(Protocol.Udp, privatePort, newPublicPort, int.MaxValue,
"AOEO Project Celeste"));
allMappings = await device.GetAllMappingsAsync();
enumerable = allMappings as Mapping[] ?? allMappings.ToArray();
var sb = new StringBuilder();
sb.AppendFormat(
"\n+------+-------------------------------+--------------------------------+------------------------------------+-------------------------+");
sb.AppendFormat(
"\n| PROT | PUBLIC (Reacheable) | PRIVATE (Your computer) | Description | |");
sb.AppendFormat(
"\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
sb.AppendFormat("\n| | IP Address | Port | IP Address | Port | | Expires |");
sb.AppendFormat(
"\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
foreach (var mapping in enumerable)
{
sb.AppendFormat("\n| {5} | {0,-20} | {1,6} | {2,-21} | {3,6} | {4,-35}|{6,25}|",
externalIp, mapping.PublicPort, mapping.PrivateIP, mapping.PrivatePort, mapping.Description,
mapping.Protocol == Protocol.Tcp ? "TCP" : "UDP", mapping.Expiration.ToLocalTime());
}
sb.AppendFormat(
"\n+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
NatDiscoverer.TraceSource.TraceInformation(sb.ToString());
if (enumerable.Any(key => Equals(key.PrivateIP, localIp) &&
key.PublicPort == newPublicPort &&
key.PrivatePort == privatePort && key.Description == "AOEO Project Celeste"))
{
return(newPublicPort);
}
throw new Exception("Port mapping fail!");
}
public static void ForwardPorts(PortMapper type = PortMapper.Upnp, bool retry = false)
{
var webServerPort = (int)Settings.Get("WebServer").WebServerPort;
var apiPort = (int)Settings.Get("TaskServer").TaskServerPort;
var webCamPort = (int)Settings.Get("Webcams").WebcamPort;
var terminalPort = (int)Settings.Get("Terminal").TerminalPort;
var screenSharePort = (int)Settings.Get("ScreenShareService").ScreenSharePort;
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource();
cts.CancelAfter(5000);
NatDevice device;
var t = nat.DiscoverDeviceAsync(type, cts);
t.ContinueWith(tt =>
{
device = tt.Result;
device.GetExternalIPAsync()
.ContinueWith(task =>
{
;
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, webServerPort, webServerPort, 0, "Ulterius Web Server")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, screenSharePort, screenSharePort, 0, "Ulterius Screen Share")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, apiPort, apiPort, 0, "Ulterius Api")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, webCamPort, webCamPort, 0, "Ulterius Webcams")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, terminalPort, terminalPort, 0, "Ulterius Terminal")));
})
.Unwrap()
.ContinueWith(task => { Console.WriteLine("Ports forwarded!"); });
}, TaskContinuationOptions.OnlyOnRanToCompletion);
try
{
t.Wait();
}
catch (AggregateException e)
{
if (e.InnerException is NatDeviceNotFoundException)
{
if (retry)
{
return;
}
ForwardPorts(PortMapper.Pmp, true);
Console.WriteLine("No NAT Device Found");
}
}
}
private static async Task <NatDevice> DiscoverDevice()
{
var nat = new NatDiscoverer();
return(await nat.DiscoverDeviceAsync(PortMapper.Upnp, new CancellationTokenSource(5000)));
}
private static async System.Threading.Tasks.Task <bool> DiscoverOpenNatAsync()
{
try
{
var discoverer = new NatDiscoverer();
// we don't want to discover forever, just 5 senconds or less
var cts = new CancellationTokenSource(5000);
// we are only interested in Upnp NATs because PMP protocol doesn't allow to list mappings
var device = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, cts);
foreach (var mapping in await device.GetAllMappingsAsync())
{
Console.WriteLine(mapping);
}
foreach (var mapping in await device.GetAllMappingsAsync())
{
// in this example we want to delete the "Skype" mappings
if (mapping.Description.Contains("OPEN"))
{
Console.WriteLine("Deleting {0}", mapping);
await device.DeletePortMapAsync(mapping);
}
}
// display the NAT's IP address
Console.WriteLine("The external IP Address is: {0} ", await device.GetExternalIPAsync());
// create a new mapping in the router [external_ip:1702 -> host_machine:1602]
await device.CreatePortMapAsync(new Mapping(Protocol.Tcp, _openTcpPort, _openTcpPort, "Discover For OPEN"));
}
catch (NatDeviceNotFoundException e)
{
Console.WriteLine("wasn't able to find an Upnp device ;(");
return(false);
}
catch (MappingException me)
{
switch (me.ErrorCode)
{
case 718:
Console.WriteLine("The external port already in use.");
StartListener_Open();
break;
case 728:
Console.WriteLine("The router's mapping table is full.");
return(true);
break;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(false);
}
return(true);
}
static async System.Threading.Tasks.Task Main(string[] args)
{
bool isOpenPort = false;
Console.WriteLine("© Mohammed Tanbir Hosssain \n");
Console.WriteLine("Discover started ");
Console.WriteLine($"N_Port:{_neoTcpPort}");
Console.WriteLine($"O_Port:{_openTcpPort}");
Console.WriteLine($"Local_Port:{_localTcpPort}");
Console.WriteLine("-----------------------------");
try
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Your Private Ip: {0}", IpHelper.PrivateIpAddress);
Console.WriteLine("Your public Ip: {0}", IpHelper.PublicIpAddress);
//----
Console.WriteLine("-----------------------------");
Console.WriteLine("Looking for N style discovering");
if (DiscoverNeo())
{
StartListener_Neo();
isOpenPort = true;
Console.WriteLine($"You _N_port: {_neoTcpPort} listing. please go to https://canyouseeme.org/ and confirm.");
}
else
{
Console.WriteLine($"Failed : Sorry _N_ port {_neoTcpPort} ");
}
Console.WriteLine("-----------------------------");
Console.WriteLine("Looking for O style discovering");
if (await DiscoverOpenNatAsync())
{
//listener
StartListener_Open();
isOpenPort = true;
Console.WriteLine($"You _O_port: { _openTcpPort} listing. please go to https://canyouseeme.org/ and confirm.");
}
else
{
Console.WriteLine($"Failed : Sorry _0_ port {_openTcpPort} ");
}
Console.WriteLine("-----------------------------");
Console.WriteLine("Looking for local discovering");
if (DiscoverLocal())
{
StartListener_Local();
Console.WriteLine($"You _L_port: { _localTcpPort} listing. please go to https://canyouseeme.org/ and confirm.");
}
else
{
Console.WriteLine($"Failed : Sorry _L_ port {_localTcpPort} ");
}
Console.WriteLine("-----------------------------");
//Delete port
if (isOpenPort)
{
Console.WriteLine("Are you want to delete your mapping? ");
Console.WriteLine("Type 'Y' OR 'N'");
var ans = Console.ReadLine();
if (ans.ToLower() == "y")
{
try { await DeleteOpenPortAsync(); } catch (Exception) { }
try { DeleteNeoPort(); } catch (Exception) { }
}
Console.WriteLine(" UPnp Mapping List");
Console.WriteLine("-----------------------------");
var discoverer = new NatDiscoverer();
// we don't want to discover forever, just 5 senconds or less
var cts = new CancellationTokenSource(5000);
// we are only interested in Upnp NATs because PMP protocol doesn't allow to list mappings
var device = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, cts);
foreach (var mapping in await device.GetAllMappingsAsync())
{
Console.WriteLine(mapping);
}
Console.WriteLine("-----------------------------");
}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Discover Error occurred.", ex.Message);
Console.WriteLine("Your router doesn't support Discover.");
Console.WriteLine("Dont't worry , one day you will find your desire solution.");
}
Console.ResetColor();
Console.WriteLine("-----------------------------");
Console.WriteLine("Discover Finished");
Console.ReadKey();
}
public static void Main(string[] args)
{
var t = Task.Run(async() =>
{
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource(5000);
var device = await nat.DiscoverDeviceAsync(PortMapper.Upnp, cts);
var sb = new StringBuilder();
var ip = await device.GetExternalIPAsync();
sb.AppendFormat("\nYour IP: {0}", ip);
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)"));
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+------+----------------------+--------+-----------------------+--------+------------------------------------+-------------------------+");
foreach (var mapping in await device.GetAllMappingsAsync())
{
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);
await device.DeletePortMapAsync(new Mapping(Protocol.Tcp, 1600, 1700));
sb.AppendFormat("\n[Done]");
Console.WriteLine(sb.ToString());
/*
* var mappings = await device.GetAllMappingsAsync();
* var deleted = mappings.All(x => x.Description != "Open.Nat Testing");
* Console.WriteLine(deleted
* ? "[SUCCESS]: Test mapping effectively removed ;)"
* : "[FAILURE]: Test mapping wan not removed!");
*/
});
try
{
t.Wait();
}
catch (AggregateException e)
{
if (e.InnerException is NatDeviceNotFoundException)
{
Console.WriteLine("Not found");
Console.WriteLine("Press any key to exit...");
}
}
Console.ReadKey();
}