// This assumes preBuffer/postBuffer are pinned already private static unsafe bool TransmitFileHelper( SafeHandle socket, SafeHandle fileHandle, SafeHandle overlapped, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { bool needTransmitFileBuffers = false; Interop.Mswsock.TransmitFileBuffers transmitFileBuffers = default(Interop.Mswsock.TransmitFileBuffers); if (preBuffer != null && preBuffer.Length > 0) { needTransmitFileBuffers = true; transmitFileBuffers.Head = Marshal.UnsafeAddrOfPinnedArrayElement(preBuffer, 0); transmitFileBuffers.HeadLength = preBuffer.Length; } if (postBuffer != null && postBuffer.Length > 0) { needTransmitFileBuffers = true; transmitFileBuffers.Tail = Marshal.UnsafeAddrOfPinnedArrayElement(postBuffer, 0); transmitFileBuffers.TailLength = postBuffer.Length; } bool success = Interop.Mswsock.TransmitFile(socket, fileHandle, 0, 0, overlapped, needTransmitFileBuffers ? &transmitFileBuffers : null, flags); return(success); }
public SendFileInfo(string fileName, CrestronSocket socket, TransmitFileOptions flags, SendFileAsyncResult iar, AsyncCallback callback) { FileName = fileName; Socket = socket; Flags = flags; Iar = iar; Callback = callback; }
internal static extern unsafe bool TransmitFile( SafeHandle socket, SafeHandle fileHandle, int numberOfBytesToWrite, int numberOfBytesPerSend, SafeHandle overlapped, TransmitFileBuffers* buffers, TransmitFileOptions flags);
internal static extern unsafe bool TransmitFile( SafeHandle socket, SafeHandle fileHandle, int numberOfBytesToWrite, int numberOfBytesPerSend, NativeOverlapped *overlapped, TransmitFileBuffers *buffers, TransmitFileOptions flags);
private static void CheckTransmitFileOptions(TransmitFileOptions flags) { // Note, UseDefaultWorkerThread is the default and is == 0. // Unfortunately there is no TransmitFileOptions.None. if (flags != TransmitFileOptions.UseDefaultWorkerThread) { throw new PlatformNotSupportedException(SR.net_sockets_transmitfileoptions_notsupported); } }
public static void SendFileAPM(this Socket socket, string filename, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, Action handler) { var callback = new AsyncCallback(asyncResult => { ((Socket)asyncResult.AsyncState).EndSendFile(asyncResult); handler(); }); socket.BeginSendFile(filename, preBuffer, postBuffer, flags, callback, socket); }
/// <inheritdoc /> public IAsyncResult BeginSendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, object state) { return(_socket.BeginSendFile(fileName, preBuffer, postBuffer, flags, callback, state)); }
internal void SetUnmanagedStructures(byte[] preBuffer, byte[] postBuffer, FileStream fileStream, TransmitFileOptions flags, bool sync) { this.m_fileStream = fileStream; this.m_flags = flags; this.m_buffers = null; int num = 0; if ((preBuffer != null) && (preBuffer.Length > 0)) { num++; } if ((postBuffer != null) && (postBuffer.Length > 0)) { num++; } object[] objectsToPin = null; if (num != 0) { num++; objectsToPin = new object[num]; this.m_buffers = new System.Net.TransmitFileBuffers(); objectsToPin[--num] = this.m_buffers; if ((preBuffer != null) && (preBuffer.Length > 0)) { this.m_buffers.preBufferLength = preBuffer.Length; objectsToPin[--num] = preBuffer; } if ((postBuffer != null) && (postBuffer.Length > 0)) { this.m_buffers.postBufferLength = postBuffer.Length; objectsToPin[--num] = postBuffer; } if (sync) { base.PinUnmanagedObjects(objectsToPin); } else { base.SetUnmanagedStructures(objectsToPin); } if ((preBuffer != null) && (preBuffer.Length > 0)) { this.m_buffers.preBuffer = Marshal.UnsafeAddrOfPinnedArrayElement(preBuffer, 0); } if ((postBuffer != null) && (postBuffer.Length > 0)) { this.m_buffers.postBuffer = Marshal.UnsafeAddrOfPinnedArrayElement(postBuffer, 0); } } else if (!sync) { base.SetUnmanagedStructures(null); } }
private void SendFileInternal(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { CheckTransmitFileOptions(flags); // Open the file, if any // Open it before we send the preBuffer so that any exception happens first FileStream fileStream = OpenFile(fileName); SocketError errorCode = SocketError.Success; using (fileStream) { // Send the preBuffer, if any // This will throw on error if (preBuffer != null && preBuffer.Length > 0) { Send(preBuffer); } // Send the file, if any if (fileStream != null) { // This can throw ObjectDisposedException. errorCode = SocketPal.SendFile(_handle, fileStream); } } if (errorCode != SocketError.Success) { SocketException socketException = new SocketException((int)errorCode); UpdateStatusAfterSocketError(socketException); if (NetEventSource.IsEnabled) NetEventSource.Error(this, socketException); throw socketException; } // Send the postBuffer, if any // This will throw on error if (postBuffer != null && postBuffer.Length > 0) { Send(postBuffer); } }
public void SendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { if (fileName == null) { throw new ArgumentNullException("fileName"); } if (!File.Exists(fileName)) { throw new FileNotFoundException("file not found"); } CheckDisposed(); if (!Connected) { throw new NotSupportedException("not connected to remote host"); } using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read)) using (var ns = GetStream()) { if (preBuffer != null) { ns.Write(preBuffer, 0, preBuffer.Length); } fs.CopyTo(ns); if (postBuffer != null) { ns.Write(postBuffer, 0, postBuffer.Length); } } if (flags.HasFlag(TransmitFileOptions.Disconnect)) { Close(); } }
private void DoBeginSendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, TransmitFileOverlappedAsyncResult asyncResult) { if (Socket.s_LoggingEnabled) Logging.Enter(Logging.Sockets, (object) this, "BeginSendFile", ""); if (this.CleanedUp) throw new ObjectDisposedException(this.GetType().FullName); if (this.CleanedUp) throw new ObjectDisposedException(this.GetType().FullName); if (!this.Connected) throw new NotSupportedException(SR.GetString("net_notconnected")); FileStream fileStream = (FileStream) null; if (fileName != null && fileName.Length > 0) fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); SafeHandle fileHandle = (SafeHandle) null; if (fileStream != null) { ExceptionHelper.UnmanagedPermission.Assert(); try { fileHandle = (SafeHandle) fileStream.SafeFileHandle; } finally { CodeAccessPermission.RevertAssert(); } } SocketError socketError = SocketError.SocketError; try { asyncResult.SetUnmanagedStructures(preBuffer, postBuffer, fileStream, flags, ref this.Caches.SendOverlappedCache); socketError = (fileHandle == null ? UnsafeNclNativeMethods.OSSOCK.TransmitFile2(this.m_Handle, IntPtr.Zero, 0, 0, asyncResult.OverlappedHandle, asyncResult.TransmitFileBuffers, flags) : UnsafeNclNativeMethods.OSSOCK.TransmitFile(this.m_Handle, fileHandle, 0, 0, asyncResult.OverlappedHandle, asyncResult.TransmitFileBuffers, flags)) ? SocketError.Success : (SocketError) Marshal.GetLastWin32Error(); } finally { socketError = asyncResult.CheckAsyncCallOverlappedResult(socketError); } if (socketError != SocketError.Success) { asyncResult.ExtractCache(ref this.Caches.SendOverlappedCache); SocketException socketException = new SocketException(socketError); this.UpdateStatusAfterSocketError(socketException); if (Socket.s_LoggingEnabled) Logging.Exception(Logging.Sockets, (object) this, "BeginSendFile", (Exception) socketException); throw socketException; } else { if (!Socket.s_LoggingEnabled) return; Logging.Exit(Logging.Sockets, (object) this, "BeginSendFile", (object) socketError); } }
public abstract Task SendFileAsync(Socket s, string fileName, ArraySegment <byte> preBuffer, ArraySegment <byte> postBuffer, TransmitFileOptions flags);
public override Task SendFileAsync(Socket s, string fileName, ArraySegment <byte> preBuffer, ArraySegment <byte> postBuffer, TransmitFileOptions flags) => Task.Factory.FromAsync( (callback, state) => s.BeginSendFile(fileName, preBuffer.Array, postBuffer.Array, flags, callback, state), s.EndSendFile, null);
/// <summary> /// Extends BeginSendFile so that when a state object is not needed, null does not need to be passed. /// <example> /// socket.BeginSendFile(fileName, preBuffer, postBuffer, flags, callback); /// </example> /// </summary> public static IAsyncResult BeginSendFile(this Socket socket, String fileName, Byte[] preBuffer, Byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback) { if(socket == null) throw new ArgumentNullException("socket"); return socket.BeginSendFile(fileName, preBuffer, postBuffer, flags, callback, null); }
public static unsafe SocketError SendFile(SafeSocketHandle handle, SafeFileHandle?fileHandle, ReadOnlySpan <byte> preBuffer, ReadOnlySpan <byte> postBuffer, TransmitFileOptions flags) { fixed(byte *prePinnedBuffer = preBuffer) fixed(byte *postPinnedBuffer = postBuffer) { bool success = TransmitFileHelper(handle, fileHandle, null, (IntPtr)prePinnedBuffer, preBuffer.Length, (IntPtr)postPinnedBuffer, postBuffer.Length, flags); return(success ? SocketError.Success : GetLastSocketError()); } }
private void SendFileInternal(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { // Open the file, if any FileStream fileStream = OpenFile(fileName); SocketError errorCode; using (fileStream) { SafeFileHandle fileHandle = fileStream?.SafeFileHandle; // This can throw ObjectDisposedException. errorCode = SocketPal.SendFile(_handle, fileHandle, preBuffer, postBuffer, flags); } if (errorCode != SocketError.Success) { SocketException socketException = new SocketException((int)errorCode); UpdateStatusAfterSocketError(socketException); if (NetEventSource.IsEnabled) NetEventSource.Error(this, socketException); throw socketException; } // If the user passed the Disconnect and/or ReuseSocket flags, then TransmitFile disconnected the socket. // Update our state to reflect this. if ((flags & (TransmitFileOptions.Disconnect | TransmitFileOptions.ReuseSocket)) != 0) { SetToDisconnected(); _remoteEndPoint = null; } }
public void SendFile (string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { ThrowIfDisposedAndClosed (); if (!is_connected) throw new NotSupportedException (); if (!is_blocking) throw new InvalidOperationException (); if (!SendFile_internal (safe_handle, fileName, preBuffer, postBuffer, flags)) { SocketException exc = new SocketException (); if (exc.ErrorCode == 2 || exc.ErrorCode == 3) throw new FileNotFoundException (); throw exc; } }
} // SetUnmanagedStructures() internal void SetUnmanagedStructures(byte[] preBuffer, byte[] postBuffer, FileStream fileStream, TransmitFileOptions flags, ref OverlappedCache overlappedCache) { SetupCache(ref overlappedCache); SetUnmanagedStructures(preBuffer, postBuffer, fileStream, flags, false); }
/// <summary> /// Sends the file <paramref name="fileName"/> and buffers of data to a connected <see cref="T:System.Net.Sockets.Socket"/> object using the specified <see cref="T:System.Net.Sockets.TransmitFileOptions"/> value. /// </summary> /// <param name="fileName">A <see cref="T:System.String"/> that contains the path and name of the file to be sent. This parameter can be null. </param><param name="preBuffer">A <see cref="T:System.Byte"/> array that contains data to be sent before the file is sent. This parameter can be null. </param><param name="postBuffer">A <see cref="T:System.Byte"/> array that contains data to be sent after the file is sent. This parameter can be null. </param><param name="flags">One or more of <see cref="T:System.Net.Sockets.TransmitFileOptions"/> values. </param><exception cref="T:System.NotSupportedException">The operating system is not Windows NT or later.- or - The socket is not connected to a remote host. </exception><exception cref="T:System.ObjectDisposedException">The <see cref="T:System.Net.Sockets.Socket"/> object has been closed. </exception><exception cref="T:System.InvalidOperationException">The <see cref="T:System.Net.Sockets.Socket"/> object is not in blocking mode and cannot accept this synchronous call. </exception><exception cref="T:System.IO.FileNotFoundException">The file <paramref name="fileName"/> was not found. </exception><exception cref="T:System.Net.Sockets.SocketException">An error occurred when attempting to access the socket. See the Remarks section for more information. </exception> public void SendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { if (Socket.s_LoggingEnabled) Logging.Enter(Logging.Sockets, (object) this, "SendFile", ""); if (this.CleanedUp) throw new ObjectDisposedException(this.GetType().FullName); if (!this.Connected) throw new NotSupportedException(SR.GetString("net_notconnected")); this.ValidateBlockingMode(); TransmitFileOverlappedAsyncResult overlappedAsyncResult = new TransmitFileOverlappedAsyncResult(this); FileStream fileStream = (FileStream) null; if (fileName != null && fileName.Length > 0) fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); SafeHandle fileHandle = (SafeHandle) null; if (fileStream != null) { ExceptionHelper.UnmanagedPermission.Assert(); try { fileHandle = (SafeHandle) fileStream.SafeFileHandle; } finally { CodeAccessPermission.RevertAssert(); } } SocketError socketError = SocketError.Success; try { overlappedAsyncResult.SetUnmanagedStructures(preBuffer, postBuffer, fileStream, TransmitFileOptions.UseDefaultWorkerThread, true); if ((fileHandle != null ? (!UnsafeNclNativeMethods.OSSOCK.TransmitFile_Blocking(this.m_Handle.DangerousGetHandle(), fileHandle, 0, 0, (SafeHandle) SafeNativeOverlapped.Zero, overlappedAsyncResult.TransmitFileBuffers, flags) ? 1 : 0) : (!UnsafeNclNativeMethods.OSSOCK.TransmitFile_Blocking2(this.m_Handle.DangerousGetHandle(), IntPtr.Zero, 0, 0, (SafeHandle) SafeNativeOverlapped.Zero, overlappedAsyncResult.TransmitFileBuffers, flags) ? 1 : 0)) != 0) socketError = (SocketError) Marshal.GetLastWin32Error(); } finally { overlappedAsyncResult.SyncReleaseUnmanagedStructures(); } if (socketError != SocketError.Success) { SocketException socketException = new SocketException(socketError); this.UpdateStatusAfterSocketError(socketException); if (Socket.s_LoggingEnabled) Logging.Exception(Logging.Sockets, (object) this, "SendFile", (Exception) socketException); throw socketException; } else { if ((overlappedAsyncResult.Flags & (TransmitFileOptions.Disconnect | TransmitFileOptions.ReuseSocket)) != TransmitFileOptions.UseDefaultWorkerThread) { this.SetToDisconnected(); this.m_RemoteEndPoint = (EndPoint) null; } if (!Socket.s_LoggingEnabled) return; Logging.Exit(Logging.Sockets, (object) this, "SendFile", (object) socketError); } }
public IAsyncResult BeginSendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, object state) { TransmitFileOverlappedAsyncResult asyncResult = new TransmitFileOverlappedAsyncResult(this, state, callback); asyncResult.StartPostingAsyncOp(false); this.DoBeginSendFile(fileName, preBuffer, postBuffer, flags, asyncResult); asyncResult.FinishPostingAsyncOp(ref this.Caches.SendClosureCache); return (IAsyncResult) asyncResult; }
private static bool SendFile (IntPtr sock, string filename, byte [] pre_buffer, byte [] post_buffer, TransmitFileOptions flags) { throw new System.NotImplementedException(); }
public static IObservable<Unit> SendFileObservable(this Socket socket, string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { Contract.Requires(socket != null); Contract.Ensures(Contract.Result<IObservable<Unit>>() != null); return Task.Factory.FromAsync<string, Tuple<byte[], byte[]>, TransmitFileOptions>( (fn, buffers, fg, callback, state) => socket.BeginSendFile(fn, buffers.Item1, buffers.Item2, fg, callback, state), socket.EndSendFile, fileName, Tuple.Create(preBuffer, postBuffer), flags, state: null) .ToObservable(); }
public IAsyncResult BeginSendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, object state) { throw null; }
public void SendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { UnderlyingObject.SendFile(fileName, preBuffer,postBuffer,flags); }
public IAsyncResult BeginSendFile (string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, object state) { if (disposed && closed) throw new ObjectDisposedException (GetType ().ToString ()); if (!connected) throw new NotSupportedException (); if (!File.Exists (fileName)) throw new FileNotFoundException (); SendFileHandler d = new SendFileHandler (SendFile); return new SendFileAsyncResult (d, d.BeginInvoke (fileName, preBuffer, postBuffer, flags, ar => { SendFileAsyncResult sfar = new SendFileAsyncResult (d, ar); callback (sfar); }, state)); }
private void SendFileInternal(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { CheckTransmitFileOptions(flags); // Open the file, if any // Open it before we send the preBuffer so that any exception happens first FileStream fileStream = OpenFile(fileName); SocketError errorCode = SocketError.Success; using (fileStream) { // Send the preBuffer, if any // This will throw on error if (preBuffer != null && preBuffer.Length > 0) { Send(preBuffer); } // Send the file, if any if (fileStream != null) { // This can throw ObjectDisposedException. errorCode = SocketPal.SendFile(_handle, fileStream); } } if (errorCode != SocketError.Success) { SocketException socketException = new SocketException((int)errorCode); UpdateStatusAfterSocketError(socketException); if (NetEventSource.IsEnabled) { NetEventSource.Error(this, socketException); } throw socketException; } // Send the postBuffer, if any // This will throw on error if (postBuffer != null && postBuffer.Length > 0) { Send(postBuffer); } }
static bool SendFile_internal (SafeSocketHandle safeHandle, string filename, byte [] pre_buffer, byte [] post_buffer, TransmitFileOptions flags) { try { safeHandle.RegisterForBlockingSyscall (); return SendFile_internal (safeHandle.DangerousGetHandle (), filename, pre_buffer, post_buffer, flags); } finally { safeHandle.UnRegisterForBlockingSyscall (); } }
/// <summary> /// Sends the file fileName to a connected Socket object using the UseDefaultWorkerThread flag. /// </summary> /// <param name="fileName"> /// A string that contains the path and name of the file to send. This parameter can be null. /// </param> /// <param name="preBuffer"> /// A Byte array that contains data to be sent before the file is sent. This parameter can be null. /// </param> /// <param name="postBuffer"> /// A Byte array that contains data to be sent after the file is sent. This parameter can be null. /// </param> /// <param name="flags">A bitwise combination of TransmitFileOptions values.</param> /// <returns>Task</returns> public static Task SendFileAsync(this Socket value, string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { return(Task.Factory.FromAsync(value.BeginSendFile(fileName, preBuffer, postBuffer, flags, null, null), value.EndSendFile)); }
public IAsyncResult BeginSendFile( string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, object state) { // Start the context flowing. No lock necessary. TransmitFileOverlappedAsyncResult asyncResult = new TransmitFileOverlappedAsyncResult(this,state,callback); asyncResult.StartPostingAsyncOp(false); // Start the operation. DoBeginSendFile(fileName, preBuffer, postBuffer, flags, asyncResult); // Finish the op, collect the context or maybe call the callback. asyncResult.FinishPostingAsyncOp(ref Caches.SendClosureCache); return asyncResult; }
private bool TransmitPackets(SafeCloseSocket socketHandle, IntPtr packetArray, int elementCount, int sendSize, SafeNativeOverlapped overlapped, TransmitFileOptions flags) { EnsureDynamicWinsockMethods(); TransmitPacketsDelegate transmitPackets = m_DynamicWinsockMethods.GetDelegate<TransmitPacketsDelegate>(socketHandle); return transmitPackets(socketHandle, packetArray, elementCount, sendSize, overlapped, flags); }
public static unsafe SocketError SendFileAsync(SafeCloseSocket handle, FileStream fileStream, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, TransmitFileAsyncResult asyncResult) { asyncResult.SetUnmanagedStructures(fileStream, preBuffer, postBuffer, (flags & (TransmitFileOptions.Disconnect | TransmitFileOptions.ReuseSocket)) != 0); SocketError errorCode = TransmitFileHelper(handle, fileStream?.SafeFileHandle, asyncResult.OverlappedHandle, preBuffer, postBuffer, flags); // This will release resources if necessary errorCode = asyncResult.CheckAsyncCallOverlappedResult(errorCode); return(errorCode); }
private IAsyncResult BeginSendFileInternal(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, object state) { FileStream fileStream = OpenFile(fileName); TransmitFileAsyncResult asyncResult = new TransmitFileAsyncResult(this, state, callback); asyncResult.StartPostingAsyncOp(false); SocketError errorCode = SocketPal.SendFileAsync(_handle, fileStream, preBuffer, postBuffer, flags, asyncResult); // Check for synchronous exception if (errorCode != SocketError.Success) { SocketException socketException = new SocketException((int)errorCode); UpdateStatusAfterSocketError(socketException); if (NetEventSource.IsEnabled) NetEventSource.Error(this, socketException); throw socketException; } asyncResult.FinishPostingAsyncOp(ref Caches.SendClosureCache); return asyncResult; }
private IAsyncResult BeginSendFileInternal(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, object state) { CheckTransmitFileOptions(flags); // Open the file, if any // Open it before we send the preBuffer so that any exception happens first FileStream fileStream = OpenFile(fileName); return(TaskToApm.Begin(SendFileInternalAsync(fileStream, preBuffer, postBuffer), callback, state)); }
/// <summary> /// Extends BeginSendFile so that when a state object is not needed, null does not need to be passed. /// <example> /// socket.BeginSendFile(fileName, preBuffer, postBuffer, flags, callback); /// </example> /// </summary> public static IAsyncResult BeginSendFile(this Socket socket, String fileName, Byte[] preBuffer, Byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback) { if (socket == null) { throw new ArgumentNullException("socket"); } return(socket.BeginSendFile(fileName, preBuffer, postBuffer, flags, callback, null)); }
public void SendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { if(s_LoggingEnabled)Logging.Enter(Logging.Sockets, this, "SendFile", ""); if (CleanedUp) { throw new ObjectDisposedException(this.GetType().FullName); } if (!Connected) { throw new NotSupportedException(SR.GetString(SR.net_notconnected)); } ValidateBlockingMode(); GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::SendFile() SRC:" + ValidationHelper.ToString(LocalEndPoint) + " DST:" + ValidationHelper.ToString(RemoteEndPoint) + " fileName:" + fileName); TransmitFileOverlappedAsyncResult asyncResult = new TransmitFileOverlappedAsyncResult(this); FileStream fileStream = null; if (fileName != null && fileName.Length>0) { fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read,FileShare.Read); } SafeHandle fileHandle = null; if (fileStream != null) { ExceptionHelper.UnmanagedPermission.Assert(); try { fileHandle = fileStream.SafeFileHandle; } finally { SecurityPermission.RevertAssert(); } } SocketError errorCode = SocketError.Success; try { asyncResult.SetUnmanagedStructures(preBuffer, postBuffer, fileStream, 0, true); // This can throw ObjectDisposedException. if (fileHandle != null ? !UnsafeNclNativeMethods.OSSOCK.TransmitFile_Blocking(m_Handle.DangerousGetHandle(), fileHandle, 0, 0, SafeNativeOverlapped.Zero, asyncResult.TransmitFileBuffers, flags) : !UnsafeNclNativeMethods.OSSOCK.TransmitFile_Blocking2(m_Handle.DangerousGetHandle(), IntPtr.Zero, 0, 0, SafeNativeOverlapped.Zero, asyncResult.TransmitFileBuffers, flags)) { errorCode = (SocketError) Marshal.GetLastWin32Error(); } } finally { asyncResult.SyncReleaseUnmanagedStructures(); } #if TRAVE try { GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::SendFile() SRC:" + ValidationHelper.ToString(LocalEndPoint) + " DST:" + ValidationHelper.ToString(RemoteEndPoint) + " UnsafeNclNativeMethods.OSSOCK.TransmitFile returns errorCode:" + errorCode); } catch (ObjectDisposedException) { } #endif // // if the native call fails we'll throw a SocketException // if (errorCode!=SocketError.Success) { // // update our internal state after this socket error and throw // SocketException socketException = new SocketException(errorCode); UpdateStatusAfterSocketError(socketException); if(s_LoggingEnabled)Logging.Exception(Logging.Sockets, this, "SendFile", socketException); throw socketException; } if ((asyncResult.Flags & (TransmitFileOptions.Disconnect | TransmitFileOptions.ReuseSocket) )!=0) { SetToDisconnected(); m_RemoteEndPoint = null; } if(s_LoggingEnabled)Logging.Exit(Logging.Sockets, this, "SendFile", errorCode); return; }
public static unsafe SocketError SendFile(SafeCloseSocket handle, SafeFileHandle fileHandle, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { fixed (byte* prePinnedBuffer = preBuffer) fixed (byte* postPinnedBuffer = postBuffer) { return TransmitFileHelper(handle, fileHandle, SafeNativeOverlapped.Zero, preBuffer, postBuffer, flags); } }
private void DoBeginSendFile( string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, TransmitFileOverlappedAsyncResult asyncResult) { if(s_LoggingEnabled)Logging.Enter(Logging.Sockets, this, "BeginSendFile", ""); if (CleanedUp) { throw new ObjectDisposedException(this.GetType().FullName); } if (CleanedUp) { throw new ObjectDisposedException(this.GetType().FullName); } #if FEATURE_PAL throw new PlatformNotSupportedException(SR.GetString(SR.WinNTRequired)); #endif // FEATURE_PAL if (!Connected) { throw new NotSupportedException(SR.GetString(SR.net_notconnected)); } GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::DoBeginSendFile() SRC:" + ValidationHelper.ToString(LocalEndPoint) + " DST:" + ValidationHelper.ToString(RemoteEndPoint) + " fileName:" + fileName); FileStream fileStream = null; if (fileName != null && fileName.Length>0) { fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read,FileShare.Read); } SafeHandle fileHandle = null; if (fileStream != null) { ExceptionHelper.UnmanagedPermission.Assert(); try { fileHandle = fileStream.SafeFileHandle; } finally { SecurityPermission.RevertAssert(); } } // Guarantee to call CheckAsyncCallOverlappedResult if we call SetUnamangedStructures with a cache in order to // avoid a Socket leak in case of error. SocketError errorCode = SocketError.SocketError; try { asyncResult.SetUnmanagedStructures(preBuffer, postBuffer, fileStream, flags, ref Caches.SendOverlappedCache); bool result = false; // This can throw ObjectDisposedException. if (fileHandle != null){ result = UnsafeNclNativeMethods.OSSOCK.TransmitFile(m_Handle,fileHandle,0,0,asyncResult.OverlappedHandle,asyncResult.TransmitFileBuffers,flags); } else{ result = UnsafeNclNativeMethods.OSSOCK.TransmitFile2(m_Handle,IntPtr.Zero,0,0,asyncResult.OverlappedHandle,asyncResult.TransmitFileBuffers,flags); } if(!result) { errorCode = (SocketError)Marshal.GetLastWin32Error(); } else { errorCode = SocketError.Success; } } finally { errorCode = asyncResult.CheckAsyncCallOverlappedResult(errorCode); } // // if the native call fails we'll throw a SocketException // if (errorCode!=SocketError.Success) { // // update our internal state after this socket error and throw // asyncResult.ExtractCache(ref Caches.SendOverlappedCache); SocketException socketException = new SocketException(errorCode); UpdateStatusAfterSocketError(socketException); if(s_LoggingEnabled)Logging.Exception(Logging.Sockets, this, "BeginSendFile", socketException); throw socketException; } GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::DoBeginSendFile() UnsafeNclNativeMethods.OSSOCK.send returns:" + errorCode.ToString()); if(s_LoggingEnabled)Logging.Exit(Logging.Sockets, this, "BeginSendFile", errorCode); }
// This assumes preBuffer/postBuffer are pinned already private static unsafe SocketError TransmitFileHelper( SafeHandle socket, SafeHandle fileHandle, SafeHandle overlapped, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { bool needTransmitFileBuffers = false; Interop.Mswsock.TransmitFileBuffers transmitFileBuffers = default(Interop.Mswsock.TransmitFileBuffers); if (preBuffer != null && preBuffer.Length > 0) { needTransmitFileBuffers = true; transmitFileBuffers.Head = Marshal.UnsafeAddrOfPinnedArrayElement(preBuffer, 0); transmitFileBuffers.HeadLength = preBuffer.Length; } if (postBuffer != null && postBuffer.Length > 0) { needTransmitFileBuffers = true; transmitFileBuffers.Tail = Marshal.UnsafeAddrOfPinnedArrayElement(postBuffer, 0); transmitFileBuffers.TailLength = postBuffer.Length; } bool success = Interop.Mswsock.TransmitFile(socket, fileHandle, 0, 0, overlapped, needTransmitFileBuffers ? &transmitFileBuffers : null, flags); return success ? SocketError.Success : GetLastSocketError(); }
public override Task SendFileAsync(Socket s, string fileName, ArraySegment <byte> preBuffer, ArraySegment <byte> postBuffer, TransmitFileOptions flags) => Task.Run(() => s.SendFile(fileName, preBuffer.Array, postBuffer.Array, flags));
public static unsafe SocketError SendFileAsync(SafeCloseSocket handle, FileStream fileStream, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, TransmitFileAsyncResult asyncResult) { asyncResult.SetUnmanagedStructures(fileStream, preBuffer, postBuffer, (flags & (TransmitFileOptions.Disconnect | TransmitFileOptions.ReuseSocket)) != 0); SocketError errorCode = TransmitFileHelper(handle, fileStream?.SafeFileHandle, asyncResult.OverlappedHandle, preBuffer, postBuffer, flags); // This will release resources if necessary errorCode = asyncResult.CheckAsyncCallOverlappedResult(errorCode); return errorCode; }
public override Task SendFileAsync(Socket s, string fileName, ArraySegment <byte> preBuffer, ArraySegment <byte> postBuffer, TransmitFileOptions flags) => s.SendFileAsync(fileName, preBuffer, postBuffer, flags, _cts.Token).AsTask();
private void SendFileInternal(string?fileName, byte[]?preBuffer, byte[]?postBuffer, TransmitFileOptions flags) { CheckTransmitFileOptions(flags); // Open the file, if any // Open it before we send the preBuffer so that any exception happens first FileStream?fileStream = OpenFile(fileName); SocketError errorCode = SocketError.Success; using (fileStream) { // Send the preBuffer, if any // This will throw on error if (preBuffer != null && preBuffer.Length > 0) { Send(preBuffer); } // Send the file, if any if (fileStream != null) { // This can throw ObjectDisposedException. errorCode = SocketPal.SendFile(_handle, fileStream); } } if (errorCode != SocketError.Success) { UpdateSendSocketErrorForDisposed(ref errorCode); UpdateStatusAfterSocketErrorAndThrowException(errorCode); } // Send the postBuffer, if any // This will throw on error if (postBuffer != null && postBuffer.Length > 0) { Send(postBuffer); } }
public static unsafe SocketError SendFile(SafeCloseSocket handle, SafeFileHandle fileHandle, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { fixed(byte *prePinnedBuffer = preBuffer) fixed(byte *postPinnedBuffer = postBuffer) { bool success = TransmitFileHelper(handle, fileHandle, SafeNativeOverlapped.Zero, preBuffer, postBuffer, flags); return(success ? SocketError.Success : SocketPal.GetLastSocketError()); } }
public System.IAsyncResult BeginSendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, System.AsyncCallback callback, object state) { }
public static unsafe SocketError SendFileAsync(SafeCloseSocket handle, FileStream fileStream, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, TransmitFileAsyncResult asyncResult) { asyncResult.SetUnmanagedStructures(fileStream, preBuffer, postBuffer, (flags & (TransmitFileOptions.Disconnect | TransmitFileOptions.ReuseSocket)) != 0); try { bool success = TransmitFileHelper( handle, fileStream?.SafeFileHandle, asyncResult.OverlappedHandle, preBuffer, postBuffer, flags); return(asyncResult.ProcessOverlappedResult(success, 0)); } catch { asyncResult.ReleaseUnmanagedStructures(); throw; } }
internal bool TransmitPackets(SafeCloseSocket socketHandle, IntPtr packetArray, int elementCount, int sendSize, SafeNativeOverlapped overlapped, TransmitFileOptions flags) { EnsureDynamicWinsockMethods(); TransmitPacketsDelegate transmitPackets = _dynamicWinsockMethods.GetDelegate <TransmitPacketsDelegate>(socketHandle); return(transmitPackets(socketHandle, packetArray, elementCount, sendSize, overlapped, flags)); }
// // SetUnmanagedStructures - // Fills in Overlapped Structures used in an Async Overlapped Winsock call // these calls are outside the runtime and are unmanaged code, so we need // to prepare specific structures and ints that lie in unmanaged memory // since the Overlapped calls can be Async // internal void SetUnmanagedStructures(byte[] preBuffer, byte[] postBuffer, FileStream fileStream, TransmitFileOptions flags, bool sync) { // // fill in flags if we use it. // m_fileStream = fileStream; m_flags = flags; // // Fill in Buffer Array structure that will be used for our send/recv Buffer // m_buffers = null; int buffsNumber = 0; if (preBuffer != null && preBuffer.Length>0) ++buffsNumber; if (postBuffer != null && postBuffer.Length>0) ++buffsNumber; object[] objectsToPin = null; if (buffsNumber != 0) { ++buffsNumber; objectsToPin = new object[buffsNumber]; m_buffers = new TransmitFileBuffers(); objectsToPin[--buffsNumber] = m_buffers; if (preBuffer != null && preBuffer.Length>0) { m_buffers.preBufferLength = preBuffer.Length; objectsToPin[--buffsNumber] = preBuffer; } if (postBuffer != null && postBuffer.Length>0) { m_buffers.postBufferLength = postBuffer.Length; objectsToPin[--buffsNumber] = postBuffer; } if (sync) { base.PinUnmanagedObjects(objectsToPin); } else { base.SetUnmanagedStructures(objectsToPin); } if (preBuffer != null && preBuffer.Length > 0) { m_buffers.preBuffer = Marshal.UnsafeAddrOfPinnedArrayElement(preBuffer, 0); } if (postBuffer != null && postBuffer.Length > 0) { m_buffers.postBuffer = Marshal.UnsafeAddrOfPinnedArrayElement(postBuffer, 0); } } else if (!sync) { base.SetUnmanagedStructures(null); } } // SetUnmanagedStructures()
private void SendPackets(SocketImplementationType type, SendPacketsElement element, TransmitFileOptions flags, int bytesExpected) { Assert.True(Capability.IPv6Support()); EventWaitHandle completed = new ManualResetEvent(false); int port; using (SocketTestServer.SocketTestServerFactory(type, _serverAddress, out port)) { using (Socket sock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp)) { sock.Connect(new IPEndPoint(_serverAddress, port)); using (SocketAsyncEventArgs args = new SocketAsyncEventArgs()) { args.Completed += OnCompleted; args.UserToken = completed; args.SendPacketsElements = new[] { element }; args.SendPacketsFlags = flags; if (sock.SendPacketsAsync(args)) { Assert.True(completed.WaitOne(TestSettings.PassingTestTimeout), "Timed out"); } Assert.Equal(SocketError.Success, args.SocketError); Assert.Equal(bytesExpected, args.BytesTransferred); } switch (flags) { case TransmitFileOptions.Disconnect: // Sending data again throws with socket shut down error. Assert.Throws<SocketException>(() => { sock.Send(new byte[1] { 01 }); }); break; case TransmitFileOptions.ReuseSocket & TransmitFileOptions.Disconnect: // Able to send data again with reuse socket flag set. Assert.Equal(1, sock.Send(new byte[1] { 01 })); break; } } } }
public void SendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { }
private extern static bool SendFile(IntPtr sock, string filename, byte [] pre_buffer, byte [] post_buffer, TransmitFileOptions flags);
/// <inheritdoc /> public void SendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { _socket.SendFile(fileName, preBuffer, postBuffer, flags); }
/// <summary> /// Sends the file <paramref name="fileName"/> to a connected <see cref="Socket"/> object. /// </summary> /// <param name="socket">The target socket.</param> /// <param name="fileName">A string that contains the path and name of the file to send. This parameter can be <see langword="null"/>.</param> /// <param name="preBuffer">A byte array that contains data to be sent before the file is sent. This parameter can be <see langword="null"/>.</param> /// <param name="postBuffer">A byte array that contains data to be sent after the file is sent. This parameter can be <see langword="null"/>.</param> /// <param name="flags">A bitwise combination of <see cref="TransmitFileOptions"/> values.</param> /// <exception cref="FileNotFoundException">The file <paramref name="fileName"/> was not found.</exception> /// <exception cref="SocketException">An error occurred when attempting to access the <paramref name="socket"/>.</exception> /// <exception cref="NotSupportedException">The operating system is not Windows NT or later or rhe <paramref name="socket"/> is not connected to a remote host.</exception> /// <exception cref="ObjectDisposedException">Thrown if the <paramref name="socket"/> has been closed.</exception> /// <returns>Returns <see cref="IAsyncOperation"/> representing the asynchronous operation.</returns> public static IAsyncOperation SendFileAsync(this Socket socket, string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { var op = new ApmResult <Socket, VoidResult>(socket); socket.BeginSendFile(fileName, preBuffer, postBuffer, flags, OnSendFileCompleted, op); return(op); }
public void SendFile (string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { if (disposed && closed) throw new ObjectDisposedException (GetType ().ToString ()); if (!connected) throw new NotSupportedException (); if (!blocking) throw new InvalidOperationException (); if (!SendFile (socket, fileName, preBuffer, postBuffer, flags)) { SocketException exc = new SocketException (); if (exc.ErrorCode == 2 || exc.ErrorCode == 3) throw new FileNotFoundException (); throw exc; } }
public static IObservable <Unit> SendFileObservable(this Socket socket, string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { Contract.Requires(socket != null); Contract.Ensures(Contract.Result <IObservable <Unit> >() != null); return(Task.Factory.FromAsync <string, Tuple <byte[], byte[]>, TransmitFileOptions>( (fn, buffers, fg, callback, state) => socket.BeginSendFile(fn, buffers.Item1, buffers.Item2, fg, callback, state), socket.EndSendFile, fileName, Tuple.Create(preBuffer, postBuffer), flags, state: null) .ToObservable()); }
public IAsyncResult BeginSendFile (string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, AsyncCallback callback, object state) { ThrowIfDisposedAndClosed (); if (!is_connected) throw new NotSupportedException (); if (!File.Exists (fileName)) throw new FileNotFoundException (); SendFileHandler handler = new SendFileHandler (SendFile); return new SendFileAsyncResult (handler, handler.BeginInvoke (fileName, preBuffer, postBuffer, flags, ar => callback (new SendFileAsyncResult (handler, ar)), state)); }
private void SendPackets(SocketImplementationType type, SendPacketsElement element, TransmitFileOptions flags, int bytesExpected) { Assert.True(Capability.IPv6Support()); EventWaitHandle completed = new ManualResetEvent(false); int port; using (SocketTestServer.SocketTestServerFactory(type, _serverAddress, out port)) { using (Socket sock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp)) { sock.Connect(new IPEndPoint(_serverAddress, port)); using (SocketAsyncEventArgs args = new SocketAsyncEventArgs()) { args.Completed += OnCompleted; args.UserToken = completed; args.SendPacketsElements = new[] { element }; args.SendPacketsFlags = flags; if (sock.SendPacketsAsync(args)) { Assert.True(completed.WaitOne(TestSettings.PassingTestTimeout), "Timed out"); } Assert.Equal(SocketError.Success, args.SocketError); Assert.Equal(bytesExpected, args.BytesTransferred); } switch (flags) { case TransmitFileOptions.Disconnect: // Sending data again throws with socket shut down error. Assert.Throws <SocketException>(() => { sock.Send(new byte[1] { 01 }); }); break; case TransmitFileOptions.ReuseSocket & TransmitFileOptions.Disconnect: // Able to send data again with reuse socket flag set. Assert.Equal(1, sock.Send(new byte[1] { 01 })); break; } } } }
extern static bool SendFile_internal (IntPtr sock, string filename, byte [] pre_buffer, byte [] post_buffer, TransmitFileOptions flags);
public void SendFile(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { UnderlyingObject.SendFile(fileName, preBuffer, postBuffer, flags); }