async Task UpdateSettingsAsync(EngineSettings oldSettings, EngineSettings newSettings)
{
DiskManager.UpdateSettings(newSettings);
ConnectionManager.Settings = newSettings;
if (oldSettings.AllowPortForwarding != newSettings.AllowPortForwarding)
{
if (newSettings.AllowPortForwarding)
{
await PortForwarder.StartAsync(CancellationToken.None);
}
else
{
await PortForwarder.StopAsync(removeExistingMappings : true, CancellationToken.None);
}
}
if (oldSettings.DhtPort != newSettings.DhtPort)
{
if (DhtListener.EndPoint != null)
{
await PortForwarder.UnregisterMappingAsync(new Mapping (Protocol.Udp, DhtListener.EndPoint.Port), CancellationToken.None);
}
else if (oldSettings.DhtPort > 0)
{
await PortForwarder.UnregisterMappingAsync(new Mapping (Protocol.Udp, oldSettings.DhtPort), CancellationToken.None);
}
DhtListener = DhtListenerFactory.CreateUdp(newSettings.DhtPort);
if (oldSettings.DhtPort == -1)
{
await RegisterDht(DhtEngineFactory.Create(DhtListener));
}
else if (newSettings.DhtPort == -1)
{
await RegisterDht(new NullDhtEngine());
}
DhtEngine.SetListener(DhtListener);
if (IsRunning)
{
DhtListener.Start();
if (Listener is ISocketListener newDhtListener)
{
await PortForwarder.RegisterMappingAsync(new Mapping (Protocol.Udp, newDhtListener.EndPoint.Port));
}
else
{
await PortForwarder.RegisterMappingAsync(new Mapping (Protocol.Udp, newSettings.DhtPort));
}
}
}
if (oldSettings.ListenPort != newSettings.ListenPort)
{
if (Listener is ISocketListener oldListener)
{
await PortForwarder.UnregisterMappingAsync(new Mapping (Protocol.Tcp, oldListener.EndPoint.Port), CancellationToken.None);
}
else if (oldSettings.ListenPort > 0)
{
await PortForwarder.UnregisterMappingAsync(new Mapping (Protocol.Tcp, oldSettings.ListenPort), CancellationToken.None);
}
Listener.Stop();
Listener = PeerListenerFactory.CreateTcp(newSettings.ListenPort);
listenManager.SetListener(Listener);
if (IsRunning)
{
Listener.Start();
// The settings could say to listen at port 0, which means 'choose one dynamically'
if (Listener is ISocketListener peerListener)
{
await PortForwarder.RegisterMappingAsync(new Mapping (Protocol.Tcp, peerListener.EndPoint.Port));
}
else
{
await PortForwarder.RegisterMappingAsync(new Mapping (Protocol.Tcp, newSettings.ListenPort));
}
}
}
// This depends on the Listener binding to it's local port.
var localPort = newSettings.ListenPort;
if (Listener is ISocketListener newListener)
{
localPort = newListener.EndPoint.Port;
}
if ((oldSettings.AllowLocalPeerDiscovery != newSettings.AllowLocalPeerDiscovery) ||
(oldSettings.ListenPort != newSettings.ListenPort))
{
RegisterLocalPeerDiscovery(newSettings.AllowLocalPeerDiscovery && localPort > 0 ? new LocalPeerDiscovery(localPort) : null);
}
}