diff options
Diffstat (limited to 'Emby.Common.Implementations')
| -rw-r--r-- | Emby.Common.Implementations/IO/LnkShortcutHandler.cs | 333 | ||||
| -rw-r--r-- | Emby.Common.Implementations/IO/ManagedFileSystem.cs | 15 | ||||
| -rw-r--r-- | Emby.Common.Implementations/Net/NetAcceptSocket.cs | 43 | ||||
| -rw-r--r-- | Emby.Common.Implementations/Net/SocketFactory.cs | 40 | ||||
| -rw-r--r-- | Emby.Common.Implementations/Net/UdpSocket.cs | 206 |
5 files changed, 560 insertions, 77 deletions
diff --git a/Emby.Common.Implementations/IO/LnkShortcutHandler.cs b/Emby.Common.Implementations/IO/LnkShortcutHandler.cs new file mode 100644 index 000000000..5d5f46057 --- /dev/null +++ b/Emby.Common.Implementations/IO/LnkShortcutHandler.cs @@ -0,0 +1,333 @@ +using System; +using System.IO; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.ComTypes; +using System.Security; +using System.Text; +using MediaBrowser.Model.IO; + +namespace Emby.Common.Implementations.IO +{ + public class LnkShortcutHandler :IShortcutHandler + { + public string Extension + { + get { return ".lnk"; } + } + + public string Resolve(string shortcutPath) + { + var link = new ShellLink(); + ((IPersistFile)link).Load(shortcutPath, NativeMethods.STGM_READ); + // ((IShellLinkW)link).Resolve(hwnd, 0) + var sb = new StringBuilder(NativeMethods.MAX_PATH); + WIN32_FIND_DATA data; + ((IShellLinkW)link).GetPath(sb, sb.Capacity, out data, 0); + return sb.ToString(); + } + + public void Create(string shortcutPath, string targetPath) + { + throw new NotImplementedException(); + } + } + + /// <summary> + /// Class NativeMethods + /// </summary> + public static class NativeMethods + { + /// <summary> + /// The MA x_ PATH + /// </summary> + public const int MAX_PATH = 260; + /// <summary> + /// The MA x_ ALTERNATE + /// </summary> + public const int MAX_ALTERNATE = 14; + /// <summary> + /// The INVALI d_ HANDL e_ VALUE + /// </summary> + public static IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1); + /// <summary> + /// The STG m_ READ + /// </summary> + public const int STGM_READ = 0; + } + + /// <summary> + /// Struct FILETIME + /// </summary> + [StructLayout(LayoutKind.Sequential)] + public struct FILETIME + { + /// <summary> + /// The dw low date time + /// </summary> + public uint dwLowDateTime; + /// <summary> + /// The dw high date time + /// </summary> + public uint dwHighDateTime; + } + + /// <summary> + /// Struct WIN32_FIND_DATA + /// </summary> + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + public struct WIN32_FIND_DATA + { + /// <summary> + /// The dw file attributes + /// </summary> + public FileAttributes dwFileAttributes; + /// <summary> + /// The ft creation time + /// </summary> + public FILETIME ftCreationTime; + /// <summary> + /// The ft last access time + /// </summary> + public FILETIME ftLastAccessTime; + /// <summary> + /// The ft last write time + /// </summary> + public FILETIME ftLastWriteTime; + /// <summary> + /// The n file size high + /// </summary> + public int nFileSizeHigh; + /// <summary> + /// The n file size low + /// </summary> + public int nFileSizeLow; + /// <summary> + /// The dw reserved0 + /// </summary> + public int dwReserved0; + /// <summary> + /// The dw reserved1 + /// </summary> + public int dwReserved1; + + /// <summary> + /// The c file name + /// </summary> + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NativeMethods.MAX_PATH)] + public string cFileName; + + /// <summary> + /// This will always be null when FINDEX_INFO_LEVELS = basic + /// </summary> + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NativeMethods.MAX_ALTERNATE)] + public string cAlternate; + + /// <summary> + /// Gets or sets the path. + /// </summary> + /// <value>The path.</value> + public string Path { get; set; } + + /// <summary> + /// Returns a <see cref="System.String" /> that represents this instance. + /// </summary> + /// <returns>A <see cref="System.String" /> that represents this instance.</returns> + public override string ToString() + { + return Path ?? string.Empty; + } + } + + /// <summary> + /// Enum SLGP_FLAGS + /// </summary> + [Flags] + public enum SLGP_FLAGS + { + /// <summary> + /// Retrieves the standard short (8.3 format) file name + /// </summary> + SLGP_SHORTPATH = 0x1, + /// <summary> + /// Retrieves the Universal Naming Convention (UNC) path name of the file + /// </summary> + SLGP_UNCPRIORITY = 0x2, + /// <summary> + /// Retrieves the raw path name. A raw path is something that might not exist and may include environment variables that need to be expanded + /// </summary> + SLGP_RAWPATH = 0x4 + } + /// <summary> + /// Enum SLR_FLAGS + /// </summary> + [Flags] + public enum SLR_FLAGS + { + /// <summary> + /// Do not display a dialog box if the link cannot be resolved. When SLR_NO_UI is set, + /// the high-order word of fFlags can be set to a time-out value that specifies the + /// maximum amount of time to be spent resolving the link. The function returns if the + /// link cannot be resolved within the time-out duration. If the high-order word is set + /// to zero, the time-out duration will be set to the default value of 3,000 milliseconds + /// (3 seconds). To specify a value, set the high word of fFlags to the desired time-out + /// duration, in milliseconds. + /// </summary> + SLR_NO_UI = 0x1, + /// <summary> + /// Obsolete and no longer used + /// </summary> + SLR_ANY_MATCH = 0x2, + /// <summary> + /// If the link object has changed, update its path and list of identifiers. + /// If SLR_UPDATE is set, you do not need to call IPersistFile::IsDirty to determine + /// whether or not the link object has changed. + /// </summary> + SLR_UPDATE = 0x4, + /// <summary> + /// Do not update the link information + /// </summary> + SLR_NOUPDATE = 0x8, + /// <summary> + /// Do not execute the search heuristics + /// </summary> + SLR_NOSEARCH = 0x10, + /// <summary> + /// Do not use distributed link tracking + /// </summary> + SLR_NOTRACK = 0x20, + /// <summary> + /// Disable distributed link tracking. By default, distributed link tracking tracks + /// removable media across multiple devices based on the volume name. It also uses the + /// Universal Naming Convention (UNC) path to track remote file systems whose drive letter + /// has changed. Setting SLR_NOLINKINFO disables both types of tracking. + /// </summary> + SLR_NOLINKINFO = 0x40, + /// <summary> + /// Call the Microsoft Windows Installer + /// </summary> + SLR_INVOKE_MSI = 0x80 + } + + /// <summary> + /// The IShellLink interface allows Shell links to be created, modified, and resolved + /// </summary> + [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("000214F9-0000-0000-C000-000000000046")] + public interface IShellLinkW + { + /// <summary> + /// Retrieves the path and file name of a Shell link object + /// </summary> + /// <param name="pszFile">The PSZ file.</param> + /// <param name="cchMaxPath">The CCH max path.</param> + /// <param name="pfd">The PFD.</param> + /// <param name="fFlags">The f flags.</param> + void GetPath([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszFile, int cchMaxPath, out WIN32_FIND_DATA pfd, SLGP_FLAGS fFlags); + /// <summary> + /// Retrieves the list of item identifiers for a Shell link object + /// </summary> + /// <param name="ppidl">The ppidl.</param> + void GetIDList(out IntPtr ppidl); + /// <summary> + /// Sets the pointer to an item identifier list (PIDL) for a Shell link object. + /// </summary> + /// <param name="pidl">The pidl.</param> + void SetIDList(IntPtr pidl); + /// <summary> + /// Retrieves the description string for a Shell link object + /// </summary> + /// <param name="pszName">Name of the PSZ.</param> + /// <param name="cchMaxName">Name of the CCH max.</param> + void GetDescription([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszName, int cchMaxName); + /// <summary> + /// Sets the description for a Shell link object. The description can be any application-defined string + /// </summary> + /// <param name="pszName">Name of the PSZ.</param> + void SetDescription([MarshalAs(UnmanagedType.LPWStr)] string pszName); + /// <summary> + /// Retrieves the name of the working directory for a Shell link object + /// </summary> + /// <param name="pszDir">The PSZ dir.</param> + /// <param name="cchMaxPath">The CCH max path.</param> + void GetWorkingDirectory([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszDir, int cchMaxPath); + /// <summary> + /// Sets the name of the working directory for a Shell link object + /// </summary> + /// <param name="pszDir">The PSZ dir.</param> + void SetWorkingDirectory([MarshalAs(UnmanagedType.LPWStr)] string pszDir); + /// <summary> + /// Retrieves the command-line arguments associated with a Shell link object + /// </summary> + /// <param name="pszArgs">The PSZ args.</param> + /// <param name="cchMaxPath">The CCH max path.</param> + void GetArguments([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszArgs, int cchMaxPath); + /// <summary> + /// Sets the command-line arguments for a Shell link object + /// </summary> + /// <param name="pszArgs">The PSZ args.</param> + void SetArguments([MarshalAs(UnmanagedType.LPWStr)] string pszArgs); + /// <summary> + /// Retrieves the hot key for a Shell link object + /// </summary> + /// <param name="pwHotkey">The pw hotkey.</param> + void GetHotkey(out short pwHotkey); + /// <summary> + /// Sets a hot key for a Shell link object + /// </summary> + /// <param name="wHotkey">The w hotkey.</param> + void SetHotkey(short wHotkey); + /// <summary> + /// Retrieves the show command for a Shell link object + /// </summary> + /// <param name="piShowCmd">The pi show CMD.</param> + void GetShowCmd(out int piShowCmd); + /// <summary> + /// Sets the show command for a Shell link object. The show command sets the initial show state of the window. + /// </summary> + /// <param name="iShowCmd">The i show CMD.</param> + void SetShowCmd(int iShowCmd); + /// <summary> + /// Retrieves the location (path and index) of the icon for a Shell link object + /// </summary> + /// <param name="pszIconPath">The PSZ icon path.</param> + /// <param name="cchIconPath">The CCH icon path.</param> + /// <param name="piIcon">The pi icon.</param> + void GetIconLocation([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszIconPath, + int cchIconPath, out int piIcon); + /// <summary> + /// Sets the location (path and index) of the icon for a Shell link object + /// </summary> + /// <param name="pszIconPath">The PSZ icon path.</param> + /// <param name="iIcon">The i icon.</param> + void SetIconLocation([MarshalAs(UnmanagedType.LPWStr)] string pszIconPath, int iIcon); + /// <summary> + /// Sets the relative path to the Shell link object + /// </summary> + /// <param name="pszPathRel">The PSZ path rel.</param> + /// <param name="dwReserved">The dw reserved.</param> + void SetRelativePath([MarshalAs(UnmanagedType.LPWStr)] string pszPathRel, int dwReserved); + /// <summary> + /// Attempts to find the target of a Shell link, even if it has been moved or renamed + /// </summary> + /// <param name="hwnd">The HWND.</param> + /// <param name="fFlags">The f flags.</param> + void Resolve(IntPtr hwnd, SLR_FLAGS fFlags); + /// <summary> + /// Sets the path and file name of a Shell link object + /// </summary> + /// <param name="pszFile">The PSZ file.</param> + void SetPath([MarshalAs(UnmanagedType.LPWStr)] string pszFile); + + } + + // CLSID_ShellLink from ShlGuid.h + /// <summary> + /// Class ShellLink + /// </summary> + [ + ComImport, + Guid("00021401-0000-0000-C000-000000000046") + ] + public class ShellLink + { + } +} diff --git a/Emby.Common.Implementations/IO/ManagedFileSystem.cs b/Emby.Common.Implementations/IO/ManagedFileSystem.cs index 3fe20f659..0c1c02cd5 100644 --- a/Emby.Common.Implementations/IO/ManagedFileSystem.cs +++ b/Emby.Common.Implementations/IO/ManagedFileSystem.cs @@ -5,6 +5,7 @@ using System.Linq; using System.Text; using MediaBrowser.Model.IO; using MediaBrowser.Model.Logging; +using MediaBrowser.Model.System; namespace Emby.Common.Implementations.IO { @@ -18,17 +19,21 @@ namespace Emby.Common.Implementations.IO private readonly bool _supportsAsyncFileStreams; private char[] _invalidFileNameChars; private readonly List<IShortcutHandler> _shortcutHandlers = new List<IShortcutHandler>(); - private bool EnableFileSystemRequestConcat = true; + private bool EnableFileSystemRequestConcat; private string _tempPath; - public ManagedFileSystem(ILogger logger, bool supportsAsyncFileStreams, bool enableManagedInvalidFileNameChars, bool enableFileSystemRequestConcat, string tempPath) + public ManagedFileSystem(ILogger logger, IEnvironmentInfo environmentInfo, string tempPath) { Logger = logger; - _supportsAsyncFileStreams = supportsAsyncFileStreams; + _supportsAsyncFileStreams = true; _tempPath = tempPath; - EnableFileSystemRequestConcat = enableFileSystemRequestConcat; - SetInvalidFileNameChars(enableManagedInvalidFileNameChars); + + // On Linux, this needs to be true or symbolic links are ignored + EnableFileSystemRequestConcat = environmentInfo.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.Windows && + environmentInfo.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.OSX; + + SetInvalidFileNameChars(environmentInfo.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.Windows); } public void AddShortcutHandler(IShortcutHandler handler) diff --git a/Emby.Common.Implementations/Net/NetAcceptSocket.cs b/Emby.Common.Implementations/Net/NetAcceptSocket.cs index 731ad1b74..3721709e6 100644 --- a/Emby.Common.Implementations/Net/NetAcceptSocket.cs +++ b/Emby.Common.Implementations/Net/NetAcceptSocket.cs @@ -2,6 +2,7 @@ using System.Net; using System.Net.Sockets; using System.Threading; +using System.Threading.Tasks; using Emby.Common.Implementations.Networking; using MediaBrowser.Model.Net; using MediaBrowser.Model.Logging; @@ -59,7 +60,7 @@ namespace Emby.Common.Implementations.Net #if NET46 Socket.Close(); #else - Socket.Dispose(); + Socket.Dispose(); #endif } @@ -96,6 +97,46 @@ namespace Emby.Common.Implementations.Net _acceptor.StartAccept(); } +#if NET46 + public Task SendFile(string path, byte[] preBuffer, byte[] postBuffer, CancellationToken cancellationToken) + { + var options = TransmitFileOptions.UseKernelApc; + + var completionSource = new TaskCompletionSource<bool>(); + + var result = Socket.BeginSendFile(path, preBuffer, postBuffer, options, new AsyncCallback(FileSendCallback), new Tuple<Socket, string, TaskCompletionSource<bool>>(Socket, path, completionSource)); + + return completionSource.Task; + } + + private void FileSendCallback(IAsyncResult ar) + { + // Retrieve the socket from the state object. + Tuple<Socket, string, TaskCompletionSource<bool>> data = (Tuple<Socket, string, TaskCompletionSource<bool>>)ar.AsyncState; + + var client = data.Item1; + var path = data.Item2; + var taskCompletion = data.Item3; + + // Complete sending the data to the remote device. + try { + client.EndSendFile(ar); + taskCompletion.TrySetResult(true); +} + catch(SocketException ex){ + _logger.Info("Socket.SendFile failed for {0}. error code {1}", path, ex.SocketErrorCode); + taskCompletion.TrySetException(ex); +}catch(Exception ex){ + taskCompletion.TrySetException(ex); +} + } +#else + public Task SendFile(string path, byte[] preBuffer, byte[] postBuffer, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } +#endif + public void Dispose() { Socket.Dispose(); diff --git a/Emby.Common.Implementations/Net/SocketFactory.cs b/Emby.Common.Implementations/Net/SocketFactory.cs index 523f4da85..1fd367afb 100644 --- a/Emby.Common.Implementations/Net/SocketFactory.cs +++ b/Emby.Common.Implementations/Net/SocketFactory.cs @@ -52,6 +52,18 @@ namespace Emby.Common.Implementations.Net { throw new SocketCreateException(ex.SocketErrorCode.ToString(), ex); } + catch (ArgumentException ex) + { + if (dualMode) + { + // Mono for BSD incorrectly throws ArgumentException instead of SocketException + throw new SocketCreateException("AddressFamilyNotSupported", ex); + } + else + { + throw; + } + } } public ISocket CreateTcpSocket(IpAddressInfo remoteAddress, int remotePort) @@ -59,6 +71,7 @@ namespace Emby.Common.Implementations.Net if (remotePort < 0) throw new ArgumentException("remotePort cannot be less than zero.", "remotePort"); var retVal = new Socket(AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp); + try { retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); @@ -96,10 +109,31 @@ namespace Emby.Common.Implementations.Net } } + public ISocket CreateUdpBroadcastSocket(int localPort) + { + if (localPort < 0) throw new ArgumentException("localPort cannot be less than zero.", "localPort"); + + var retVal = new Socket(AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp); + try + { + retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); + retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1); + + return new UdpSocket(retVal, localPort, IPAddress.Any); + } + catch + { + if (retVal != null) + retVal.Dispose(); + + throw; + } + } + /// <summary> - /// Creates a new UDP acceptSocket that is a member of the SSDP multicast local admin group and binds it to the specified local port. - /// </summary> - /// <returns>An implementation of the <see cref="ISocket"/> interface used by RSSDP components to perform acceptSocket operations.</returns> + /// Creates a new UDP acceptSocket that is a member of the SSDP multicast local admin group and binds it to the specified local port. + /// </summary> + /// <returns>An implementation of the <see cref="ISocket"/> interface used by RSSDP components to perform acceptSocket operations.</returns> public ISocket CreateSsdpUdpSocket(IpAddressInfo localIpAddress, int localPort) { if (localPort < 0) throw new ArgumentException("localPort cannot be less than zero.", "localPort"); diff --git a/Emby.Common.Implementations/Net/UdpSocket.cs b/Emby.Common.Implementations/Net/UdpSocket.cs index 8e2a1da6f..f9181eb6a 100644 --- a/Emby.Common.Implementations/Net/UdpSocket.cs +++ b/Emby.Common.Implementations/Net/UdpSocket.cs @@ -16,12 +16,23 @@ namespace Emby.Common.Implementations.Net internal sealed class UdpSocket : DisposableManagedObjectBase, ISocket { - - #region Fields - private Socket _Socket; private int _LocalPort; - #endregion + + private readonly SocketAsyncEventArgs _receiveSocketAsyncEventArgs = new SocketAsyncEventArgs() + { + SocketFlags = SocketFlags.None + }; + + private readonly SocketAsyncEventArgs _sendSocketAsyncEventArgs = new SocketAsyncEventArgs() + { + SocketFlags = SocketFlags.None + }; + + private TaskCompletionSource<SocketReceiveResult> _currentReceiveTaskCompletionSource; + private TaskCompletionSource<int> _currentSendTaskCompletionSource; + + private readonly SemaphoreSlim _sendLock = new SemaphoreSlim(1, 1); public UdpSocket(Socket socket, int localPort, IPAddress ip) { @@ -32,6 +43,61 @@ namespace Emby.Common.Implementations.Net LocalIPAddress = NetworkManager.ToIpAddressInfo(ip); _Socket.Bind(new IPEndPoint(ip, _LocalPort)); + + InitReceiveSocketAsyncEventArgs(); + } + + private void InitReceiveSocketAsyncEventArgs() + { + var receiveBuffer = new byte[8192]; + _receiveSocketAsyncEventArgs.SetBuffer(receiveBuffer, 0, receiveBuffer.Length); + _receiveSocketAsyncEventArgs.Completed += _receiveSocketAsyncEventArgs_Completed; + + var sendBuffer = new byte[8192]; + _sendSocketAsyncEventArgs.SetBuffer(sendBuffer, 0, sendBuffer.Length); + _sendSocketAsyncEventArgs.Completed += _sendSocketAsyncEventArgs_Completed; + } + + private void _receiveSocketAsyncEventArgs_Completed(object sender, SocketAsyncEventArgs e) + { + var tcs = _currentReceiveTaskCompletionSource; + if (tcs != null) + { + _currentReceiveTaskCompletionSource = null; + + if (e.SocketError == SocketError.Success) + { + tcs.TrySetResult(new SocketReceiveResult + { + Buffer = e.Buffer, + ReceivedBytes = e.BytesTransferred, + RemoteEndPoint = ToIpEndPointInfo(e.RemoteEndPoint as IPEndPoint), + LocalIPAddress = LocalIPAddress + }); + } + else + { + tcs.TrySetException(new Exception("SocketError: " + e.SocketError)); + } + } + } + + private void _sendSocketAsyncEventArgs_Completed(object sender, SocketAsyncEventArgs e) + { + var tcs = _currentSendTaskCompletionSource; + if (tcs != null) + { + _currentSendTaskCompletionSource = null; + + if (e.SocketError == SocketError.Success) + { + tcs.TrySetResult(e.BytesTransferred); + } + else + { + tcs.TrySetException(new Exception("SocketError: " + e.SocketError)); + } + } } public UdpSocket(Socket socket, IpEndPointInfo endPoint) @@ -40,6 +106,8 @@ namespace Emby.Common.Implementations.Net _Socket = socket; _Socket.Connect(NetworkManager.ToIPEndPoint(endPoint)); + + InitReceiveSocketAsyncEventArgs(); } public IpAddressInfo LocalIPAddress @@ -48,32 +116,33 @@ namespace Emby.Common.Implementations.Net private set; } - #region ISocket Members - public Task<SocketReceiveResult> ReceiveAsync(CancellationToken cancellationToken) { ThrowIfDisposed(); - var tcs = new TaskCompletionSource<SocketReceiveResult>(); - EndPoint receivedFromEndPoint = new IPEndPoint(IPAddress.Any, 0); + var state = new AsyncReceiveState(_Socket, receivedFromEndPoint); state.TaskCompletionSource = tcs; -#if NETSTANDARD1_6 - _Socket.ReceiveFromAsync(new ArraySegment<Byte>(state.Buffer), SocketFlags.None, state.RemoteEndPoint) - .ContinueWith((task, asyncState) => + cancellationToken.Register(() => tcs.TrySetCanceled()); + + _receiveSocketAsyncEventArgs.RemoteEndPoint = receivedFromEndPoint; + _currentReceiveTaskCompletionSource = tcs; + + try + { + var willRaiseEvent = _Socket.ReceiveFromAsync(_receiveSocketAsyncEventArgs); + + if (!willRaiseEvent) { - if (task.Status != TaskStatus.Faulted) - { - var receiveState = asyncState as AsyncReceiveState; - receiveState.RemoteEndPoint = task.Result.RemoteEndPoint; - ProcessResponse(receiveState, () => task.Result.ReceivedBytes, LocalIPAddress); - } - }, state); -#else - _Socket.BeginReceiveFrom(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, ref state.RemoteEndPoint, ProcessResponse, state); -#endif + _receiveSocketAsyncEventArgs_Completed(this, _receiveSocketAsyncEventArgs); + } + } + catch (Exception ex) + { + tcs.TrySetException(ex); + } return tcs.Task; } @@ -129,61 +198,69 @@ namespace Emby.Common.Implementations.Net taskSource.TrySetException(ex); } - //_Socket.SendTo(messageData, new System.Net.IPEndPoint(IPAddress.Parse(RemoteEndPoint.IPAddress), RemoteEndPoint.Port)); - return taskSource.Task; #endif - } + //ThrowIfDisposed(); - #endregion + //if (buffer == null) throw new ArgumentNullException("messageData"); + //if (endPoint == null) throw new ArgumentNullException("endPoint"); - #region Overrides + //cancellationToken.ThrowIfCancellationRequested(); - protected override void Dispose(bool disposing) - { - if (disposing) - { - var socket = _Socket; - if (socket != null) - socket.Dispose(); - } - } + //var tcs = new TaskCompletionSource<int>(); + + //cancellationToken.Register(() => tcs.TrySetCanceled()); + + //_sendSocketAsyncEventArgs.SetBuffer(buffer, 0, size); + //_sendSocketAsyncEventArgs.RemoteEndPoint = NetworkManager.ToIPEndPoint(endPoint); + //_currentSendTaskCompletionSource = tcs; - #endregion + //var willRaiseEvent = _Socket.SendAsync(_sendSocketAsyncEventArgs); - #region Private Methods + //if (!willRaiseEvent) + //{ + // _sendSocketAsyncEventArgs_Completed(this, _sendSocketAsyncEventArgs); + //} - private static void ProcessResponse(AsyncReceiveState state, Func<int> receiveData, IpAddressInfo localIpAddress) + //return tcs.Task; + } + + public async Task SendWithLockAsync(byte[] buffer, int size, IpEndPointInfo endPoint, CancellationToken cancellationToken) { - try - { - var bytesRead = receiveData(); + ThrowIfDisposed(); - var ipEndPoint = state.RemoteEndPoint as IPEndPoint; - state.TaskCompletionSource.SetResult( - new SocketReceiveResult - { - Buffer = state.Buffer, - ReceivedBytes = bytesRead, - RemoteEndPoint = ToIpEndPointInfo(ipEndPoint), - LocalIPAddress = localIpAddress - } - ); - } - catch (ObjectDisposedException) + //await _sendLock.WaitAsync(cancellationToken).ConfigureAwait(false); + + try { - state.TaskCompletionSource.SetCanceled(); + await SendAsync(buffer, size, endPoint, cancellationToken).ConfigureAwait(false); } - catch (SocketException se) + finally { - if (se.SocketErrorCode != SocketError.Interrupted && se.SocketErrorCode != SocketError.OperationAborted && se.SocketErrorCode != SocketError.Shutdown) - state.TaskCompletionSource.SetException(se); - else - state.TaskCompletionSource.SetCanceled(); + //_sendLock.Release(); } - catch (Exception ex) + } + + protected override void Dispose(bool disposing) + { + if (disposing) { - state.TaskCompletionSource.SetException(ex); + var socket = _Socket; + if (socket != null) + socket.Dispose(); + + _sendLock.Dispose(); + + var tcs = _currentReceiveTaskCompletionSource; + if (tcs != null) + { + tcs.TrySetCanceled(); + } + var sendTcs = _currentSendTaskCompletionSource; + if (sendTcs != null) + { + sendTcs.TrySetCanceled(); + } } } @@ -227,10 +304,6 @@ namespace Emby.Common.Implementations.Net #endif } - #endregion - - #region Private Classes - private class AsyncReceiveState { public AsyncReceiveState(Socket socket, EndPoint remoteEndPoint) @@ -247,8 +320,5 @@ namespace Emby.Common.Implementations.Net public TaskCompletionSource<SocketReceiveResult> TaskCompletionSource { get; set; } } - - #endregion - } } |