/// <summary> /// Send file /// </summary> /// <param name="FileName">Path File</param> public bool SendFile(string FileName) { try { mainSocket.BeginSendFile(FileName, new AsyncCallback(FileSendCallback), mainSocket); return(true); } catch (FileNotFoundException se) { if (OnError != null) { OnError(se.Message, null, 0); } return(false); } catch (ObjectDisposedException se) { if (OnError != null) { OnError(se.Message, null, 0); } return(false); } catch (SocketException se) { if (OnError != null) { OnError(se.Message, mainSocket, se.ErrorCode); } return(false); } }
public void IndividualBeginEndMethods_Disposed_ThrowsObjectDisposedException() { using Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); s.Dispose(); Assert.Throws <ObjectDisposedException>(() => s.BeginSendFile(null, null, null)); Assert.Throws <ObjectDisposedException>(() => s.BeginSendFile(null, null, null, TransmitFileOptions.UseDefaultWorkerThread, null, null)); }
public void NotConnected_ThrowsException() { using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { Assert.Throws <NotSupportedException>(() => s.SendFile(null)); Assert.Throws <NotSupportedException>(() => s.BeginSendFile(null, null, null)); Assert.Throws <NotSupportedException>(() => s.BeginSendFile(null, null, null, TransmitFileOptions.UseDefaultWorkerThread, null, null)); } }
public void Disposed_ThrowsException() { using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { s.Dispose(); Assert.Throws <ObjectDisposedException>(() => s.SendFile(null)); Assert.Throws <ObjectDisposedException>(() => s.SendFile(null, null, null, TransmitFileOptions.UseDefaultWorkerThread)); Assert.Throws <ObjectDisposedException>(() => s.SendFile(null, ReadOnlySpan <byte> .Empty, ReadOnlySpan <byte> .Empty, TransmitFileOptions.UseDefaultWorkerThread)); Assert.Throws <ObjectDisposedException>(() => s.BeginSendFile(null, null, null)); Assert.Throws <ObjectDisposedException>(() => s.BeginSendFile(null, null, null, TransmitFileOptions.UseDefaultWorkerThread, null, null)); Assert.Throws <ObjectDisposedException>(() => s.EndSendFile(null)); } }
/* * This function sends the file with the given filename to the client * on the end of the socketObj by first sending the filesize, then transfering * the data. */ private void dataTransferToClient(Object socketObj, string username, string filename) { Socket socket = (Socket)socketObj; string directoryPath = serverPath.Text + "\\" + username; string filePath = directoryPath + "\\" + filename; printLogger("Server is sending the file " + filename + " for user: "******"Exception occured during data transfer: " + exc.Message); return; } }
/// <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); }
// <snippet9> public static void AsynchronousFileSend() { // Send a file to a remote device. // Establish the remote endpoint for the socket. IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); IPAddress ipAddress = ipHostInfo.AddressList[0]; IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000); // Create a TCP/IP socket. Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // Connect to the remote endpoint. client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client); // Wait for connect. connectDone.WaitOne(); // There is a text file test.txt in the root directory. string fileName = "C:\\test.txt"; // Send file fileName to the remote device. Console.WriteLine(fileName); client.BeginSendFile(fileName, new AsyncCallback(FileSendCallback), client); // Release the socket. client.Shutdown(SocketShutdown.Both); client.Close(); }
//public static Task<ArraySegment<byte>> BeginReceiveArraySegmentFromAsync(this Socket socket, ArraySegment<byte> segment, ref EndPoint remoteEnd) //{ // return socket.ReceiveFromAsync(segment, ref remoteEnd).ContinueWith((n) => segment.Take(n.Result)); //} #endregion public static Task SendFile(this Socket socket, string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions options) { return(Task.Factory.FromAsync( socket.BeginSendFile(fileName, preBuffer, postBuffer, options, null, null), socket.EndSendFile )); }
/// <summary> /// Sends the file <paramref name="fileName"/> to a connected <see cref="Socket"/> object using the <see cref="TransmitFileOptions.UseDefaultWorkerThread"/> flag. /// </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> /// <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) { var op = new ApmResult <Socket, VoidResult>(socket); socket.BeginSendFile(fileName, OnSendFileCompleted, op); return(op); }
protected override void SendFile(string FileName, byte[] header, byte[] footer, bool Async, CompressionType Compression) { try { fileSendSize = (uint)header.Length + (uint)footer.Length + (ulong)(new System.IO.FileInfo(FileName).Length); if (Async) { sock.BeginSendFile(FileName, header, footer, TransmitFileOptions.UseSystemThread, EndSendFile, sock); } else { sock.SendFile(FileName, header, footer, TransmitFileOptions.UseDefaultWorkerThread); bytesSent = bytesSent + fileSendSize; //Console.WriteLine("Sent File: [{0}] Total:[{1}]", fileSent, _bytesSent); if (Compression != CompressionType.NoCompression) { try { System.IO.File.Delete(FileName); } catch { } } } } catch (Exception ex) { if (stopped) { // We forcefully closed this socket therefore this exception was expected and we can ignore it } else { Disconnect(ex); } } }
public static Task SendFile(this Socket socket, string fileName) { return(Task.Factory.FromAsync( socket.BeginSendFile(fileName, null, null), socket.EndSendFile )); }
public async Task SendFile(string fileName) { var lengthByte = CreateFirstMessage(new FileInfo(fileName).Length); await Task.Factory.FromAsync( socket.BeginSendFile(fileName, lengthByte, null, TransmitFileOptions.UseKernelApc, null, null), socket.EndSendFile); }
public void SendFile_APM(IPAddress listenAt, bool sendPreAndPostBuffers, int bytesToSend) { const int ListenBacklog = 1, TestTimeout = 30000; // Create file to send byte[] preBuffer, postBuffer; Fletcher32 sentChecksum; string filename = CreateFileToSend(bytesToSend, sendPreAndPostBuffers, out preBuffer, out postBuffer, out sentChecksum); // Start server using (var listener = new Socket(listenAt.AddressFamily, SocketType.Stream, ProtocolType.Tcp)) { listener.BindToAnonymousPort(listenAt); listener.Listen(ListenBacklog); int bytesReceived = 0; var receivedChecksum = new Fletcher32(); Task serverTask = Task.Run(async() => { using (var serverStream = new NetworkStream(await listener.AcceptAsync(), ownsSocket: true)) { var buffer = new byte[256]; int bytesRead; while ((bytesRead = await serverStream.ReadAsync(buffer, 0, buffer.Length)) != 0) { bytesReceived += bytesRead; receivedChecksum.Add(buffer, 0, bytesRead); } } }); Task clientTask = Task.Run(async() => { using (var client = new Socket(listener.LocalEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp)) { await client.ConnectAsync(listener.LocalEndPoint); await Task.Factory.FromAsync( (callback, state) => client.BeginSendFile(filename, preBuffer, postBuffer, TransmitFileOptions.UseDefaultWorkerThread, callback, state), iar => client.EndSendFile(iar), null); client.Shutdown(SocketShutdown.Send); } }); // Wait for the tasks to complete Task <Task> firstCompleted = Task.WhenAny(serverTask, clientTask); Assert.True(firstCompleted.Wait(TestTimeout), "Neither client nor server task completed within allowed time"); firstCompleted.Result.GetAwaiter().GetResult(); Assert.True(Task.WaitAll(new[] { serverTask, clientTask }, TestTimeout), $"Tasks didn't complete within allowed time. Server:{serverTask.Status} Client:{clientTask.Status}"); // Validate the results Assert.Equal(bytesToSend, bytesReceived); Assert.Equal(sentChecksum.Sum, receivedChecksum.Sum); } // Clean up the file we created File.Delete(filename); }
/// <summary> /// Extends BeginSendFile so that when a state object is not needed, null does not need to be passed. /// <example> /// socket.BeginSendFile(fileName, callback); /// </example> /// </summary> public static IAsyncResult BeginSendFile(this Socket socket, String fileName, AsyncCallback callback) { if (socket == null) { throw new ArgumentNullException("socket"); } return(socket.BeginSendFile(fileName, callback, 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 void SendFile(string filePath) { if (IsConnected() == false) { return; } socket.BeginSendFile(filePath, new AsyncCallback(OnFileSended), socket); }
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); }
public Task SendFile(string path, byte[] preBuffer, byte[] postBuffer, CancellationToken cancellationToken) { var options = TransmitFileOptions.UseDefaultWorkerThread; 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 SendFile(String path, Socket target) { try { target.BeginSendFile(path, new AsyncCallback(SendFileCall), target); } catch (IOException e) { Console.WriteLine(e.Message); SendText("Unable to access file", target); } }
/// <inheritdoc/> protected override void BeginSendFile(IWriteRequest request, IFileRegion file) { try { Socket.BeginSendFile(file.FullName, SendFileCallback, new SendingContext(Socket, file)); } catch (ObjectDisposedException) { // ignore } catch (Exception ex) { EndSend(ex); } }
public static void SendFileAPM(this Socket socket, string filename, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags, Action <Exception> handler) { var callback = new AsyncCallback(asyncResult => { Exception exc = null; try { ((Socket)asyncResult.AsyncState).EndSendFile(asyncResult); } catch (Exception e) { exc = e; } handler(exc); }); socket.BeginSendFile(filename, preBuffer, postBuffer, flags, callback, socket); }
private Task TransmitFileOverSocket(string path, long offset, long count, FileShareMode fileShareMode, CancellationToken cancellationToken) { var ms = GetHeaders(false); byte[] preBuffer; if (ms != null) { using (var msCopy = new MemoryStream()) { ms.CopyTo(msCopy); preBuffer = msCopy.ToArray(); } } else { return(TransmitFileManaged(path, offset, count, fileShareMode, cancellationToken)); } _stream.Flush(); _logger.Info("Socket sending file {0}", path); var taskCompletion = new TaskCompletionSource <bool>(); Action <IAsyncResult> callback = callbackResult => { try { _socket.EndSendFile(callbackResult); taskCompletion.TrySetResult(true); } catch (Exception ex) { taskCompletion.TrySetException(ex); } }; var result = _socket.BeginSendFile(path, preBuffer, _emptyBuffer, TransmitFileOptions.UseDefaultWorkerThread, new AsyncCallback(callback), null); if (result.CompletedSynchronously) { callback(result); } cancellationToken.Register(() => taskCompletion.TrySetCanceled()); return(taskCompletion.Task); }
private static void SendFile(Socket client, String fileName) { // Convert the string data to byte data using ASCII encoding. //byte[] byteData = Encoding.ASCII.GetBytes(data); if (File.Exists(fileName)) { // Begin sending the data to the remote device. client.BeginSendFile(fileName, new AsyncCallback(SendCallback), client); } else { Console.WriteLine("File is not exist : " + fileName); } }
/// <summary> /// Send file by connecting selected /// </summary> /// <param name="FileName">Path File</param> /// <param name="PreString">Message sent before the file</param> /// <param name="PosString">Message sent after the File</param> /// <param name="SocketIndex">Index of connection</param> public bool SendFile(string FileName, string PreString, string PosString, int SocketIndex) { if ((Clients.Count - 1) >= SocketIndex) { Socket workerSocket = (Socket)Clients[SocketIndex]; try { byte[] preBuf = Encoding.UTF8.GetBytes(PreString); byte[] postBuf = Encoding.UTF8.GetBytes(PosString); workerSocket.BeginSendFile(FileName, preBuf, postBuf, 0, new AsyncCallback(FileSendCallback), workerSocket); return(true); } catch (ArgumentException se) { if (OnError != null) { OnError(se.Message, null, 0); } return(false); } catch (ObjectDisposedException se) { if (OnError != null) { OnError(se.Message, null, 0); } return(false); } catch (SocketException se) { if (OnError != null) { OnError(se.Message, workerSocket, se.ErrorCode); } return(false); } } else { if (OnError != null) { OnError("Index was out of range. Must be non-negative and less than the size of the collection.", null, 0); } return(false); } }
/// <summary> /// Send file by connecting selected /// </summary> /// <param name="FileName">Path File</param> /// <param name="SocketIndex">Index of connection</param> public bool SendFile(string FileName, int SocketIndex) { if ((Clients.Count - 1) >= SocketIndex) { Socket workerSocket = (Socket)Clients[SocketIndex]; try { workerSocket.BeginSendFile(FileName, new AsyncCallback(FileSendCallback), workerSocket); return(true); } catch (FileNotFoundException se) { if (OnError != null) { OnError(se.Message, null, 0); } return(false); } catch (ObjectDisposedException se) { if (OnError != null) { OnError(se.Message, null, 0); } return(false); } catch (SocketException se) { if (OnError != null) { OnError(se.Message, workerSocket, se.ErrorCode); } return(false); } } else { if (OnError != null) { OnError("Index was out of range. Must be non-negative and less than the size of the collection.", null, 0); } return(false); } }
// </snippet9> // <snippet10> public static void AsynchronousFileSendWithBuffers() { // Send a file asynchronously to the remote device. Send a buffer before the file and a buffer afterwards. // Establish the remote endpoint for the socket. IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); IPAddress ipAddress = ipHostInfo.AddressList[0]; IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000); // Create a TCP/IP socket. Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // Connect to the remote endpoint. client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client); // Wait for connect. connectDone.WaitOne(); // Send a file fileName to the remote device with preBuffer and postBuffer data. // Create the preBuffer data. string string1 = String.Format("This is text data that precedes the file.{0}", Environment.NewLine); byte[] preBuf = Encoding.ASCII.GetBytes(string1); // Create the postBuffer data. string string2 = String.Format("This is text data that will follow the file.{0}", Environment.NewLine); byte[] postBuf = Encoding.ASCII.GetBytes(string2); // There is a file test.txt in the root directory. string fileName = "C:\\test.txt"; //Send file fileName with buffers and default flags to the remote device. Console.WriteLine(fileName); client.BeginSendFile(fileName, preBuf, postBuf, 0, new AsyncCallback(AsynchronousFileSendCallback), client); // Release the socket. client.Shutdown(SocketShutdown.Both); client.Close(); }
private void clientSend_Click(object sender, EventArgs e) { string operationCode = "UPL"; UTF8Encoding aEncoder = new UTF8Encoding(); byte[] codeInBytes = aEncoder.GetBytes(operationCode); cliSocket.Send(codeInBytes); printLogger("System is uploading the file/folder... "); long filesize = new FileInfo(clientText.Text).Length; string filename = Path.GetFileName(clientText.Text); byte[] filenameInBytes = aEncoder.GetBytes(filename); byte[] fileInfo = new byte[12 + filename.Length]; //Filling fileInfo byte array Buffer.BlockCopy(BitConverter.GetBytes(filenameInBytes.Length), 0, fileInfo, 0, 4); Buffer.BlockCopy(filenameInBytes, 0, fileInfo, 4, filenameInBytes.Length); Buffer.BlockCopy(BitConverter.GetBytes(filesize), 0, fileInfo, 4 + filenameInBytes.Length, sizeof(long)); try { cliSocket.Send(fileInfo); } catch (Exception exc) { MessageBox.Show("Exception occured during data transfer: " + exc.Message); return; } Thread.Sleep(1000); try { cliSocket.BeginSendFile(clientText.Text, new AsyncCallback(FileSendCallback), cliSocket); } catch (Exception exc) { MessageBox.Show("Exception occured during data transfer: " + exc.Message); return; } }
private void ReadCallback(IAsyncResult ar) { try { Socket handler = (Socket)ar.AsyncState; int received = handler.EndReceive(ar); if (received > 0) { sb.Append(Encoding.ASCII.GetString(buffer, 0, received)); string content = sb.ToString(); buffer = new byte[ServerConstants.BufferSize]; if (content.IndexOf(ServerConstants.EOF) > -1) { content = content.Substring(0, content.Length - 5); var deserialized = JsonConvert.DeserializeObject <PackageWrapper>(content); if (deserialized.PackageType == typeof(FileSearch)) { FileSearch fs = (FileSearch)JsonConvert.DeserializeObject(Convert.ToString(deserialized.Package), deserialized.PackageType); handler.BeginSendFile(upPath + fs.FileName, new AsyncCallback(SendCallback), handler); } } else { handler.BeginReceive(buffer, 0, ServerConstants.BufferSize, 0, new AsyncCallback(ReadCallback), handler); } } sb.Clear(); buffer = new byte[ServerConstants.BufferSize]; } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }
public async Task SendFile_NoFile_Succeeds(bool useAsync, bool usePreBuffer, bool usePostBuffer) { using var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); using var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); listener.BindToAnonymousPort(IPAddress.Loopback); listener.Listen(1); client.Connect(listener.LocalEndPoint); using Socket server = listener.Accept(); if (useAsync) { await Task.Factory.FromAsync <string>(server.BeginSendFile, server.EndSendFile, null, null); } else { server.SendFile(null); } Assert.Equal(0, client.Available); byte[] preBuffer = usePreBuffer ? new byte[1] : null; byte[] postBuffer = usePostBuffer ? new byte[1] : null; int bytesExpected = (usePreBuffer ? 1 : 0) + (usePostBuffer ? 1 : 0); if (useAsync) { await Task.Factory.FromAsync((c, s) => server.BeginSendFile(null, preBuffer, postBuffer, TransmitFileOptions.UseDefaultWorkerThread, c, s), server.EndSendFile, null); } else { server.SendFile(null, preBuffer, postBuffer, TransmitFileOptions.UseDefaultWorkerThread); } byte[] receiveBuffer = new byte[1]; for (int i = 0; i < bytesExpected; i++) { Assert.Equal(1, client.Receive(receiveBuffer)); } Assert.Equal(0, client.Available); }
public static void IniciarServidor() { try { //Colocar ip da rede System.Net.IPAddress localadrr = System.Net.IPAddress.Parse("192.168.1.5"); TcpListener escutar = new TcpListener(localadrr, 12345); escutar.Start(); Socket soc = escutar.AcceptSocket(); if (soc.Connected) { mensagemServidor += " \n Conectado com o cliente."; // Para mandar JSON string Filename = Path.GetDirectoryName(System.AppDomain.CurrentDomain.BaseDirectory.ToString()) + "UVA.JSON"; // Tentativa de enviar um arquivo //string Filename = Path.GetDirectoryName(System.AppDomain.CurrentDomain.BaseDirectory.ToString()) + "ProMEDCT0051.obj"; //soc.BeginSendFile(Filename, new AsyncCallback(FileSendCallback), soc); soc.BeginSendFile(Filename, delegate(IAsyncResult ar) { Socket client = (Socket)ar.AsyncState; // Complete sending the data to the remote device. client.EndSendFile(ar); escutar.Stop(); }, soc); } } catch (Exception ex) { mensagemServidor += "Não foi possivel estabelecer conexão." + "\n" + ex.Message; } }