fix network methods not shutting down

Mono.Nat/NatUtility.cs

@@ -41,26 +41,25 @@ using MediaBrowser.Model.Logging;
 
 namespace Mono.Nat
 {
-	public static class NatUtility
+    public static class NatUtility
-	{
+    {
-        private static ManualResetEvent searching;
+        public static event EventHandler<DeviceEventArgs> DeviceFound;
-		public static event EventHandler<DeviceEventArgs> DeviceFound;
+        public static event EventHandler<DeviceEventArgs> DeviceLost;
-		public static event EventHandler<DeviceEventArgs> DeviceLost;
+
-        
+        private static List<ISearcher> controllers;
-		private static List<ISearcher> controllers;
+        private static bool verbose;
-		private static bool verbose;
 
         public static List<NatProtocol> EnabledProtocols { get; set; }
 
-	    public static ILogger Logger { get; set; }
+        public static ILogger Logger { get; set; }
         public static IHttpClient HttpClient { get; set; }
 
         public static bool Verbose
-		{
+        {
-			get { return verbose; }
+            get { return verbose; }
-			set { verbose = value; }
+            set { verbose = value; }
-		}
+        }
-		
+
         static NatUtility()
         {
             EnabledProtocols = new List<NatProtocol>
@@ -68,8 +67,6 @@ namespace Mono.Nat
                 NatProtocol.Pmp
             };
 
-            searching = new ManualResetEvent(false);
-
             controllers = new List<ISearcher>();
             controllers.Add(PmpSearcher.Instance);
 
@@ -86,23 +83,19 @@ namespace Mono.Nat
                             DeviceLost(sender, args);
                     };
                 });
-
-            Task.Factory.StartNew(SearchAndListen, TaskCreationOptions.LongRunning);
         }
 
-		internal static void Log(string format, params object[] args)
+        internal static void Log(string format, params object[] args)
-		{
+        {
-			var logger = Logger;
+            var logger = Logger;
-		    if (logger != null)
+            if (logger != null)
-		        logger.Debug(format, args);
+                logger.Debug(format, args);
-		}
+        }
 
-        private static async Task SearchAndListen()
+        private static async Task SearchAndListen(CancellationToken cancellationToken)
         {
-            while (true)
+            while (!cancellationToken.IsCancellationRequested)
             {
-                searching.WaitOne();
-
                 try
                 {
                     var enabledProtocols = EnabledProtocols.ToList();
@@ -123,67 +116,99 @@ namespace Mono.Nat
                 }
                 catch (Exception e)
                 {
-                    
+
                 }
                 await Task.Delay(100).ConfigureAwait(false);
             }
-		}
+        }
-
+
-		static async Task Receive (ISearcher searcher, List<UdpClient> clients)
+        static async Task Receive(ISearcher searcher, List<UdpClient> clients)
-		{
+        {
-			foreach (UdpClient client in clients)
+            foreach (UdpClient client in clients)
-			{
+            {
-				if (client.Available > 0)
+                if (client.Available > 0)
-				{
+                {
-				    IPAddress localAddress = ((IPEndPoint)client.Client.LocalEndPoint).Address;
+                    IPAddress localAddress = ((IPEndPoint)client.Client.LocalEndPoint).Address;
-				    var result = await client.ReceiveAsync().ConfigureAwait(false);
+                    var result = await client.ReceiveAsync().ConfigureAwait(false);
-				    var data = result.Buffer;
+                    var data = result.Buffer;
-				    var received = result.RemoteEndPoint;
+                    var received = result.RemoteEndPoint;
-					searcher.Handle(localAddress, data, received);
+                    searcher.Handle(localAddress, data, received);
-				}
+                }
+            }
+        }
+
+        private static CancellationTokenSource _currentCancellationTokenSource;
+        private static object _runSyncLock = new object();
+        public static void StartDiscovery()
+        {
+            lock (_runSyncLock)
+            {
+                if (_currentCancellationTokenSource == null)
+                {
+                    return;
+                }
+
+                var tokenSource = new CancellationTokenSource();
+
+                _currentCancellationTokenSource = tokenSource;
+                //Task.Factory.StartNew(() => SearchAndListen(tokenSource.Token), tokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
             }
         }
-		
+
-		public static void StartDiscovery ()
+        public static void StopDiscovery()
-		{
+        {
-            searching.Set();
+            lock (_runSyncLock)
-		}
+            {
-
+                var tokenSource = _currentCancellationTokenSource;
-		public static void StopDiscovery ()
+
-		{
+                if (tokenSource != null)
-            searching.Reset();
+                {
-		}
+                    try
-		
+                    {
-		//checks if an IP address is a private address space as defined by RFC 1918
+                        tokenSource.Cancel();
-		public static bool IsPrivateAddressSpace (IPAddress address)
+                        tokenSource.Dispose();
-		{
+                    }
-			byte[] ba = address.GetAddressBytes ();
+                    catch
-
+                    {
-			switch ((int)ba[0]) {
+
-			case 10:
+                    }
-				return true; //10.x.x.x
+
-			case 172:
+                    _currentCancellationTokenSource = null;
-				return ((int)ba[1] & 16) != 0; //172.16-31.x.x
+                }
-			case 192:
+            }
-				return (int)ba[1] == 168; //192.168.x.x
+        }
-			default:
+
-				return false;
+        //checks if an IP address is a private address space as defined by RFC 1918
-			}
+        public static bool IsPrivateAddressSpace(IPAddress address)
-		}
+        {
-
+            byte[] ba = address.GetAddressBytes();
-	    public static void Handle(IPAddress localAddress, byte[] response, IPEndPoint endpoint, NatProtocol protocol)
+
-	    {
+            switch ((int)ba[0])
-	        switch (protocol)
+            {
-	        {
+                case 10:
+                    return true; //10.x.x.x
+                case 172:
+                    return ((int)ba[1] & 16) != 0; //172.16-31.x.x
+                case 192:
+                    return (int)ba[1] == 168; //192.168.x.x
+                default:
+                    return false;
+            }
+        }
+
+        public static void Handle(IPAddress localAddress, byte[] response, IPEndPoint endpoint, NatProtocol protocol)
+        {
+            switch (protocol)
+            {
                 case NatProtocol.Upnp:
-	                //UpnpSearcher.Instance.Handle(localAddress, response, endpoint);
+                    //UpnpSearcher.Instance.Handle(localAddress, response, endpoint);
-	                break;
+                    break;
                 case NatProtocol.Pmp:
-	                PmpSearcher.Instance.Handle(localAddress, response, endpoint);
+                    PmpSearcher.Instance.Handle(localAddress, response, endpoint);
-	                break;
+                    break;
-	            default:
+                default:
-	                throw new ArgumentException("Unexpected protocol: " + protocol);
+                    throw new ArgumentException("Unexpected protocol: " + protocol);
-	        }
+            }
         }
 
         public static void Handle(IPAddress localAddress, UpnpDeviceInfo deviceInfo, IPEndPoint endpoint, NatProtocol protocol)