Merge pull request #2658 from MediaBrowser/dev

Dev

2 files changed, 38 insertions, 142 deletions

diff --git a/Emby.Common.Implementations/Net/SocketFactory.cs b/Emby.Common.Implementations/Net/SocketFactory.cs
index 39f236afa..3562a8644 100644
--- a/Emby.Common.Implementations/Net/SocketFactory.cs
+++ b/Emby.Common.Implementations/Net/SocketFactory.cs
@@ -188,16 +188,7 @@ namespace Emby.Common.Implementations.Net
 
             try
             {
-#if NET46
-				retVal.ExclusiveAddressUse = false;
-#else
-                // The ExclusiveAddressUse acceptSocket option is a Windows-specific option that, when set to "true," tells Windows not to allow another acceptSocket to use the same local address as this acceptSocket
-                // See https://github.com/dotnet/corefx/pull/11509 for more details
-                if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows))
-				{
-					retVal.ExclusiveAddressUse = false;
-				}
-#endif
+                retVal.ExclusiveAddressUse = false;
                 //retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true);
                 retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                 retVal.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, multicastTimeToLive);
diff --git a/Emby.Common.Implementations/Net/UdpSocket.cs b/Emby.Common.Implementations/Net/UdpSocket.cs
index f9181eb6a..678cf6f03 100644
--- a/Emby.Common.Implementations/Net/UdpSocket.cs
+++ b/Emby.Common.Implementations/Net/UdpSocket.cs
@@ -116,129 +116,64 @@ namespace Emby.Common.Implementations.Net
             private set;
         }
 
-        public Task<SocketReceiveResult> ReceiveAsync(CancellationToken cancellationToken)
+        private readonly AsyncCallback _defaultAsyncCallback = (i) => { };
+
+        public IAsyncResult BeginReceive(byte[] buffer, int offset, int count, AsyncCallback callback)
         {
-            ThrowIfDisposed();
-            var tcs = new TaskCompletionSource<SocketReceiveResult>();
             EndPoint receivedFromEndPoint = new IPEndPoint(IPAddress.Any, 0);
 
-            var state = new AsyncReceiveState(_Socket, receivedFromEndPoint);
-            state.TaskCompletionSource = tcs;
-
-            cancellationToken.Register(() => tcs.TrySetCanceled());
-
-            _receiveSocketAsyncEventArgs.RemoteEndPoint = receivedFromEndPoint;
-            _currentReceiveTaskCompletionSource = tcs;
-
-            try
-            {
-                var willRaiseEvent = _Socket.ReceiveFromAsync(_receiveSocketAsyncEventArgs);
-
-                if (!willRaiseEvent)
-                {
-                    _receiveSocketAsyncEventArgs_Completed(this, _receiveSocketAsyncEventArgs);
-                }
-            }
-            catch (Exception ex)
-            {
-                tcs.TrySetException(ex);
-            }
-
-            return tcs.Task;
+            return _Socket.BeginReceiveFrom(buffer, offset, count, SocketFlags.None, ref receivedFromEndPoint, callback, buffer);
         }
 
-        public Task SendAsync(byte[] buffer, int size, IpEndPointInfo endPoint, CancellationToken cancellationToken)
+        public SocketReceiveResult EndReceive(IAsyncResult result)
         {
-            ThrowIfDisposed();
-
-            if (buffer == null) throw new ArgumentNullException("messageData");
-            if (endPoint == null) throw new ArgumentNullException("endPoint");
+            IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
+            EndPoint remoteEndPoint = (EndPoint)sender;
 
-            var ipEndPoint = NetworkManager.ToIPEndPoint(endPoint);
+            var receivedBytes = _Socket.EndReceiveFrom(result, ref remoteEndPoint);
 
-#if NETSTANDARD1_6
+            var buffer = (byte[]) result.AsyncState;
 
-            if (size != buffer.Length)
+            return new SocketReceiveResult
             {
-                byte[] copy = new byte[size];
-                Buffer.BlockCopy(buffer, 0, copy, 0, size);
-                buffer = copy;
-            }
-
-            cancellationToken.ThrowIfCancellationRequested();
-
-            _Socket.SendTo(buffer, ipEndPoint);
-            return Task.FromResult(true);
-#else
-            var taskSource = new TaskCompletionSource<bool>();
-
-            try
-            {
-                _Socket.BeginSendTo(buffer, 0, size, SocketFlags.None, ipEndPoint, result =>
-                {
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        taskSource.TrySetCanceled();
-                        return;
-                    }
-                    try
-                    {
-                        _Socket.EndSend(result);
-                        taskSource.TrySetResult(true);
-                    }
-                    catch (Exception ex)
-                    {
-                        taskSource.TrySetException(ex);
-                    }
-
-                }, null);
-            }
-            catch (Exception ex)
-            {
-                taskSource.TrySetException(ex);
-            }
-
-            return taskSource.Task;
-#endif
-            //ThrowIfDisposed();
-
-            //if (buffer == null) throw new ArgumentNullException("messageData");
-            //if (endPoint == null) throw new ArgumentNullException("endPoint");
-
-            //cancellationToken.ThrowIfCancellationRequested();
+                ReceivedBytes = receivedBytes,
+                RemoteEndPoint = ToIpEndPointInfo((IPEndPoint)remoteEndPoint),
+                Buffer = buffer,
+                LocalIPAddress = LocalIPAddress
+            };
+        }
 
-            //var tcs = new TaskCompletionSource<int>();
+        public Task<SocketReceiveResult> ReceiveAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            var result = BeginReceive(buffer, offset, count, _defaultAsyncCallback);
 
-            //cancellationToken.Register(() => tcs.TrySetCanceled());
+            return Task.Factory.FromAsync(result, EndReceive);
+        }
 
-            //_sendSocketAsyncEventArgs.SetBuffer(buffer, 0, size);
-            //_sendSocketAsyncEventArgs.RemoteEndPoint = NetworkManager.ToIPEndPoint(endPoint);
-            //_currentSendTaskCompletionSource = tcs;
+        public Task<SocketReceiveResult> ReceiveAsync(CancellationToken cancellationToken)
+        {
+            var buffer = new byte[8192];
 
-            //var willRaiseEvent = _Socket.SendAsync(_sendSocketAsyncEventArgs);
+            return ReceiveAsync(buffer, 0, buffer.Length, cancellationToken);
+        }
 
-            //if (!willRaiseEvent)
-            //{
-            //    _sendSocketAsyncEventArgs_Completed(this, _sendSocketAsyncEventArgs);
-            //}
+        public Task SendToAsync(byte[] buffer, int offset, int size, IpEndPointInfo endPoint, CancellationToken cancellationToken)
+        {
+            var result = BeginSendTo(buffer, offset, size, endPoint, _defaultAsyncCallback, null);
 
-            //return tcs.Task;
+            return Task.Factory.FromAsync(result, EndSendTo);
         }
 
-        public async Task SendWithLockAsync(byte[] buffer, int size, IpEndPointInfo endPoint, CancellationToken cancellationToken)
+        public IAsyncResult BeginSendTo(byte[] buffer, int offset, int size, IpEndPointInfo endPoint, AsyncCallback callback, object state)
         {
-            ThrowIfDisposed();
+            var ipEndPoint = NetworkManager.ToIPEndPoint(endPoint);
 
-            //await _sendLock.WaitAsync(cancellationToken).ConfigureAwait(false);
+            return _Socket.BeginSendTo(buffer, offset, size, SocketFlags.None, ipEndPoint, callback, state);
+        }
 
-            try
-            {
-                await SendAsync(buffer, size, endPoint, cancellationToken).ConfigureAwait(false);
-            }
-            finally
-            {
-                //_sendLock.Release();
-            }
+        public int EndSendTo(IAsyncResult result)
+        {
+            return _Socket.EndSendTo(result);
         }
 
         protected override void Dispose(bool disposing)
@@ -274,36 +209,6 @@ namespace Emby.Common.Implementations.Net
             return NetworkManager.ToIpEndPointInfo(endpoint);
         }
 
-        private void ProcessResponse(IAsyncResult asyncResult)
-        {
-#if NET46
-            var state = asyncResult.AsyncState as AsyncReceiveState;
-            try
-            {
-                var bytesRead = state.Socket.EndReceiveFrom(asyncResult, ref state.RemoteEndPoint);
-
-                var ipEndPoint = state.RemoteEndPoint as IPEndPoint;
-                state.TaskCompletionSource.SetResult(
-                    new SocketReceiveResult
-                    {
-                        Buffer = state.Buffer,
-                        ReceivedBytes = bytesRead,
-                        RemoteEndPoint = ToIpEndPointInfo(ipEndPoint),
-                        LocalIPAddress = LocalIPAddress
-                    }
-                );
-            }
-            catch (ObjectDisposedException)
-            {
-                state.TaskCompletionSource.SetCanceled();
-            }
-            catch (Exception ex)
-            {
-                state.TaskCompletionSource.SetException(ex);
-            }
-#endif
-        }
-
         private class AsyncReceiveState
         {
             public AsyncReceiveState(Socket socket, EndPoint remoteEndPoint)