Файл поврежден из асинхронного tcp-сокета

Question

Создал асинхронный клиент tcp & сервер, программа отлично работает при передаче текстового файла, но не в двоичном файле. Количество отправленных и полученных байтов согласовано, но двоичный файл не может функционировать. pdf с пустым содержимым, zip не может извлечь и т. д. Любые подсказки, спасибо.

Client

using System; 
using System.Net; 
using System.Net.Sockets; 
using System.Threading; 
using System.Text; 
using System.IO; 

// State object for receiving data from remote device. 
public class StateObject 
{ 
    // Client socket. 
    public Socket workSocket = null; 
    // Size of receive buffer. 
    public const int BufferSize = 256; 
    // Receive buffer. 
    public byte[] buffer = new byte[BufferSize]; 
    // Received data string. 
    public StringBuilder sb = new StringBuilder(); 
} 

public class AsynClient 
{ 
    // The port number for the remote device. 
    private const int port = 11000; 

    // ManualResetEvent instances signal completion. 
    private static ManualResetEvent connectDone = new ManualResetEvent(false); 
    private static ManualResetEvent sendDone = new ManualResetEvent(false); 
    private static ManualResetEvent receiveDone = new ManualResetEvent(false); 

    // The response from the remote device. 
    private static String response = String.Empty; 
    private static String endofFile = "<EOF>"; 

    private static void StartClient() 
    { 
     // Connect to a remote device. 
     try 
     { 
      // Establish the remote endpoint for the socket. 
      // The name of the 
      // remote device is "host.contoso.com". 
      IPHostEntry ipHostInfo = Dns.Resolve("128.127.12.41"); 
      IPAddress ipAddress = ipHostInfo.AddressList[0];    
      IPEndPoint remoteEP = new IPEndPoint(ipAddress, port); 

      // 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); 
      connectDone.WaitOne(); 

      // Send test data to the remote device. 
      //Send(client, "This is a test<EOF>"); 
      Send(client, readFile()); 
      sendDone.WaitOne(); 

      // Receive the response from the remote device. 
      Receive(client); 
      receiveDone.WaitOne(); 

      // Write the response to the console. 
      Console.WriteLine("Response received : {0}", response); 

      // Release the socket. 
      client.Shutdown(SocketShutdown.Both); 
      client.Close(); 

     } 
     catch (Exception e) 
     { 
      Console.WriteLine(e.ToString()); 
     } 
    } 

    //private static String readFile() 
    private static byte[] readFile() 
    { 
     String filePath = "C:\\way\\interface\\"; 
     //String fileName = "DC5_2013-04-08_20130828111230.zip"; 
     String fileName = "DC5_2013-06-01_20130828183818.zip"; 

     fileName = fileName.Replace("\\", "/"); 
     while (fileName.IndexOf("/") > -1) 
     { 
      filePath += fileName.Substring(0, fileName.IndexOf("/") + 1); 
      fileName = fileName.Substring(fileName.IndexOf("/") + 1); 
     } 

     byte[] fileNameByte = Encoding.ASCII.GetBytes(fileName);   
     if (fileNameByte.Length > 850 * 1024) 
     {    
      Console.WriteLine("File size is more than 850kb, please try with small file.");    
     } 

     byte[] fileNameLen = BitConverter.GetBytes(fileNameByte.Length); 

     byte[] fileData = File.ReadAllBytes(filePath + fileName);   
     byte[] eofByte = Encoding.ASCII.GetBytes(endofFile); 

     byte[] clientData = new byte[4 + fileNameByte.Length + fileData.Length + endofFile.Length]; 

     fileNameLen.CopyTo(clientData, 0);   
     fileNameByte.CopyTo(clientData, 4); 
     fileData.CopyTo(clientData, 4 + fileNameByte.Length); 
     eofByte.CopyTo(clientData, 4 + fileNameByte.Length + fileData.Length);    

     //return System.Text.Encoding.Default.GetString(clientData); 
     return clientData; 
    } 

    private static void ConnectCallback(IAsyncResult ar) 
    { 
     try 
     { 
      // Retrieve the socket from the state object. 
      Socket client = (Socket)ar.AsyncState; 

      // Complete the connection. 
      client.EndConnect(ar); 

      Console.WriteLine("Socket connected to {0}", client.RemoteEndPoint.ToString()); 

      // Signal that the connection has been made. 
      connectDone.Set(); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine(e.ToString()); 
     } 
    } 

    private static void Receive(Socket client) 
    { 
     try 
     { 
      // Create the state object. 
      StateObject state = new StateObject(); 
      state.workSocket = client; 

      // Begin receiving the data from the remote device. 
      client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
       new AsyncCallback(ReceiveCallback), state); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine(e.ToString()); 
     } 
    } 

    private static void ReceiveCallback(IAsyncResult ar) 
    { 
     try 
     { 
      // Retrieve the state object and the client socket 
      // from the asynchronous state object. 
      StateObject state = (StateObject)ar.AsyncState; 
      Socket client = state.workSocket; 

      // Read data from the remote device. 
      int bytesRead = client.EndReceive(ar); 

      if (bytesRead > 0) 
      { 
       // There might be more data, so store the data received so far. 
       state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead)); 

       // Get the rest of the data. 
       client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
        new AsyncCallback(ReceiveCallback), state); 
      } 
      else 
      { 
       // All the data has arrived; put it in response. 
       if (state.sb.Length > 1) 
       { 
        response = state.sb.ToString(); 
       } 
       // Signal that all bytes have been received. 
       receiveDone.Set(); 
      } 
     } 
     catch (Exception e) 
     { 
      //Console.WriteLine(e.ToString()); 

      StateObject state = (StateObject)ar.AsyncState; 
      if (state.sb.Length > 1) 
      { 
       response = state.sb.ToString(); 
      } 
      // Signal that all bytes have been received. 
      receiveDone.Set();    
     } 
    } 

    private static void Send(Socket client, byte[] byteData) 
    {   
     // Begin sending the data to the remote device. 
     client.BeginSend(byteData, 0, byteData.Length, 0, 
      new AsyncCallback(SendCallback), client); 
    } 

    private static void Send(Socket client, String data) 
    { 
     // Convert the string data to byte data using ASCII encoding. 
     byte[] byteData = Encoding.ASCII.GetBytes(data); 

     // Begin sending the data to the remote device. 
     client.BeginSend(byteData, 0, byteData.Length, 0, 
      new AsyncCallback(SendCallback), client); 
    } 

    private static void SendCallback(IAsyncResult ar) 
    { 
     try 
     { 
      // Retrieve the socket from the state object. 
      Socket client = (Socket)ar.AsyncState; 

      // Complete sending the data to the remote device. 
      int bytesSent = client.EndSend(ar); 
      Console.WriteLine("Sent {0} bytes to server.", bytesSent); 

      // Signal that all bytes have been sent. 
      sendDone.Set(); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine(e.ToString()); 
     } 
    } 

    public static int Main(String[] args) 
    { 
     StartClient(); 
     return 0; 
    } 
} 

Сервер

using System; 
using System.Net; 
using System.Net.Sockets; 
using System.Text; 
using System.Threading; 
using System.IO; 

// State object for reading client data asynchronously 
public class StateObject 
{ 
    // Client socket. 
    public Socket workSocket = null; 
    // Size of receive buffer. 
    public const int BufferSize = 860 * 1024; 
    // Receive buffer. 
    public byte[] buffer = new byte[BufferSize]; 
    // Received data string. 
    public StringBuilder sb = new StringBuilder(); 
} 

public class AsynServer 
{ 
    // Thread signal. 
    public static ManualResetEvent allDone = new ManualResetEvent(false); 
    public static string receivedPath = "C:/way/dw"; 
    private static String endofFile = "<EOF>"; 

    public AsynServer() 
    { 
    } 

    public static void StartListening() 
    { 
     // Data buffer for incoming data. 
     byte[] bytes = new Byte[1024]; 

     // Establish the local endpoint for the socket. 
     // The DNS name of the computer 
     // running the listener is "host.contoso.com". 
     IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); 
     IPAddress ipAddress = ipHostInfo.AddressList[0]; 
     IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000); 

     // Create a TCP/IP socket. 
     Socket listener = new Socket(AddressFamily.InterNetwork, 
      SocketType.Stream, ProtocolType.Tcp); 

     // Bind the socket to the local endpoint and listen for incoming connections. 
     try 
     { 
      listener.Bind(localEndPoint); 
      listener.Listen(100); 

      while (true) 
      { 
       // Set the event to nonsignaled state. 
       allDone.Reset(); 

       // Start an asynchronous socket to listen for connections. 
       Console.WriteLine("Waiting for a connection..."); 
       listener.BeginAccept(
        new AsyncCallback(AcceptCallback), 
        listener); 

       // Wait until a connection is made before continuing. 
       allDone.WaitOne(); 
      } 

     } 
     catch (Exception e) 
     { 
      Console.WriteLine(e.ToString()); 
     } 

     Console.WriteLine("\nPress ENTER to continue..."); 
     Console.Read(); 

    } 

    public static void AcceptCallback(IAsyncResult ar) 
    { 
     // Signal the main thread to continue. 
     allDone.Set(); 

     // Get the socket that handles the client request. 
     Socket listener = (Socket)ar.AsyncState; 
     Socket handler = listener.EndAccept(ar); 

     // Create the state object. 
     StateObject state = new StateObject(); 
     state.workSocket = handler; 
     handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
      new AsyncCallback(ReadCallback), state); 
    } 

    public static void ReadCallback(IAsyncResult ar) 
    { 
     String content = String.Empty;   

     // Retrieve the state object and the handler socket 
     // from the asynchronous state object. 
     StateObject state = (StateObject)ar.AsyncState; 
     Socket handler = state.workSocket; 

     // Read data from the client socket. 
     int bytesRead = handler.EndReceive(ar); 

     if (bytesRead > 0) 
     {    
      // There might be more data, so store the data received so far. 
      state.sb.Append(Encoding.ASCII.GetString(
       state.buffer, 0, bytesRead));    

      // Check for end-of-file tag. If it is not there, read 
      // more data. 
      content = state.sb.ToString();    
      //Console.WriteLine(content); 
      if (content.IndexOf("<EOF>") > -1) 
      { 
       // All the data has been read from the 
       // client. Display it on the console. 
       //Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content); 
       Console.WriteLine("Read {0} bytes from socket.", content.Length); 

       byte[] byteStream = System.Text.Encoding.UTF8.GetBytes(state.sb.ToString()); 
       int fileNameLen = BitConverter.ToInt32(byteStream, 0);     
       String fileName = Encoding.ASCII.GetString(byteStream, 4, fileNameLen);     

       writeFile(fileName, fileNameLen, byteStream.Length, byteStream);     


       // Echo the data back to the client. 
       //Send(handler, content); 
       Send(handler, "OK"); 
      } 
      else 
      { 
       // Not all data received. Get more. 
       handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
       new AsyncCallback(ReadCallback), state); 
      } 
     } 
    } 

    private static void writeFile(String fileName, int fileNameLen, int receiveByte, byte[] receiveBuffer) 
    {   
     BinaryWriter bWrite = new BinaryWriter(File.Open(receivedPath + "/" + fileName, FileMode.Append));     
     bWrite.Write(receiveBuffer, 4 + fileNameLen, receiveByte - 4 - fileNameLen - endofFile.Length); 
     bWrite.Close(); 
    } 

    private static void Send(Socket handler, String data) 
    { 
     // Convert the string data to byte data using ASCII encoding. 
     byte[] byteData = Encoding.ASCII.GetBytes(data); 

     // Begin sending the data to the remote device. 
     handler.BeginSend(byteData, 0, byteData.Length, 0, 
      new AsyncCallback(SendCallback), handler); 
    } 

    private static void SendCallback(IAsyncResult ar) 
    { 
     try 
     { 
      // Retrieve the socket from the state object. 
      Socket handler = (Socket)ar.AsyncState; 

      // Complete sending the data to the remote device. 
      int bytesSent = handler.EndSend(ar); 
      Console.WriteLine("Sent {0} bytes to client.", bytesSent); 

      handler.Shutdown(SocketShutdown.Both); 
      handler.Close(); 

     } 
     catch (Exception e) 
     { 
      Console.WriteLine(e.ToString()); 
     } 
    } 


    public static int Main(String[] args) 
    { 
     StartListening(); 
     return 0; 
    } 
} 

Answer 1

Основная проблема заключается в вашем получить код на сервере. Вы преобразовываете двоичные данные в строку следующим образом:

 // There might be more data, so store the data received so far. 
     state.sb.Append(Encoding.ASCII.GetString(
      state.buffer, 0, bytesRead));    

ASCII - это 7-битное кодирование. Любой символ, который не находится в диапазоне от 0 до 127, будет преобразован в «?». Таким образом, примерно половина ваших двоичных данных преобразуется в вопросительные знаки.

Другая проблема, которая возникла бы здесь, заключается в том, что строка "<EOF>" происходит где-то в текстовом файле (или в двоичном файле). Если это произошло, ваш приемник прекратит работу до того, как будет прочитан весь файл.

Вы должны изменить свой протокол, чтобы вместо отправки строки "<EOF>" вы указали общую длину того, что вы отправляете в первых 4 байтах отправляемых данных. Ваш код приема считывает первые 4 байта и знает, сколько всего байтов он должен получить.

Лечить все как двоичный, когда вы его получите. Когда вы вытаскиваете имя файла, вы конвертируете только те байты в строку. Но все данные файла должны рассматриваться как двоичные. Просто напишите его непосредственно в выходной файл. Или вы можете буферизировать его в памяти, если вам нужно.

Я бы не рекомендовал использовать даже для имени файла. В именах файлов Windows могут быть не-ASCII-символы. Я бы рекомендовал использовать Encoding.UTF8, который будет кодировать символы ASCII в одном байте, но также позволяет использовать полный набор символов Юникода.