envoyer et recevoir des fichiers socket programmation

Question

Je développe deux application une application serveur et l'autre est pour l'appareil portatif application à la fois communiquer à l'aide de connexion sans fil.le client est portatif et le serveur est mon ordinateur où l'application serveur en cours d'exécution. quand j'envoie des fichiers du client au serveur il envoie parfaitement sans aucune erreur mais quand la demande du client pour les fichiers le serveur produit l'erreur quelque chose comme "Aucune connexion n'a pu être faite parce que la machine cible l'a activement refusée 192.168.1.5:9050"

code côté serveur:

private bool SendData(string StrIP) 
    { 

     try 
     { 
      string strmyFile = Directory.GetCurrentDirectory() + "\\" + "XML" + @"\Login.xml"; 
      char[] delimiter = splitter.ToCharArray(); 
      split = strmyFile.Split(delimiter); 
      int limit = split.Length; 
      fName = split[limit - 1].ToString(); 

      byte[] fileName = Encoding.UTF8.GetBytes(fName); //file name 
      byte[] fileData = File.ReadAllBytes(strmyFile); //file 
      using (FileStream stream = File.OpenRead(strmyFile)) 
      { 
       fileData = new byte[stream.Length]; 
       stream.Read(fileData, 0, fileData.Length); 
      } 

      byte[] fileNameLen = BitConverter.GetBytes(fileName.Length); //lenght of file name 
      clientData = new byte[4 + fileName.Length + fileData.Length]; 

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

      System.Net.IPAddress ipAdd = System.Net.IPAddress.Parse(StrIP); 

      try 
      { 
       Socket clientSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
       IPEndPoint ipEnd = new IPEndPoint(ipAdd, 9050); 
       clientSock.Connect(ipEnd); //target machine's ip address and the port number 
       clientSock.Send(clientData); 
       clientSock.Close(); 
       ind = 1; 

       //Socket Sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
       //IPEndPoint ipEnd = new IPEndPoint(ipAdd, 9050); 
       //Sock.Bind(ipEnd);//target machine's ip address and the port number 
       //Sock.Listen(100); 

       //Socket clientSock = Sock.Accept(); 

       //clientSock.Send(clientData); 
       //clientSock.Close(); 
       //ind = 1; 
      } 
      catch (Exception ex) 
      { 

       req = false; 
       return false; 

      } 
      req = true; 
     } 
     catch (Exception ex) 
     { 

     } 
     return true; 
    } 


    public class StateObject 
    { 
     // Client socket. 
     public Socket workSocket = null; 

     public const int BufferSize = 1024 * 5000; 
     // Receive buffer. 
     public byte[] buffer = new byte[BufferSize]; 
    } 

    public static ManualResetEvent allDone = new ManualResetEvent(false); 

    public void StartListening() 
    { 


     byte[] bytes = new Byte[1024 * 5000]; 
     IPEndPoint ipEnd = new IPEndPoint(IPAddress.Any, 9050); 
     Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
     try 
     { 
      listener.Bind(ipEnd); 
      listener.Listen(100); 

      while (true) 
      { 
       allDone.Reset(); 
       // string ip = listener.RemoteEndPoint.ToString(); 
       listener.BeginAccept(new AsyncCallback(AcceptCallback), listener); 
       allDone.WaitOne(); 

      } 
     } 
     catch (Exception ex) 
     { 

     } 

    } 


    public void AcceptCallback(IAsyncResult ar) 
    { 

     allDone.Set(); 


     Socket listener = (Socket)ar.AsyncState; 
     Socket handler = listener.EndAccept(ar); 

     StateObject state = new StateObject(); 
     state.workSocket = handler; 
     handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
     new AsyncCallback(ReadCallback), state); 

     flag = 0; 

    } 

    private bool req = false; 
    public void ReadCallback(IAsyncResult ar) 
    { 
     try 
     { 

      int fileNameLen = 1; 
      String content = String.Empty; 
      StateObject state = (StateObject)ar.AsyncState; 
      Socket handler = state.workSocket; 
      string[] str = new string[2]; 
      str = handler.RemoteEndPoint.ToString().Split(':'); 
      string path = Directory.GetCurrentDirectory() + "\\TEST\\" + str[0].ToString(); 
      if (!Directory.Exists(path)) 
      { 
       Directory.CreateDirectory(path); 
      } 
      if (req == false) 
      { 
       Sender snddata = new Sender(); 
       snddata.sendme(str[0].ToString()); 
       SendData(str[0].ToString()); 
      } 

      int bytesRead = handler.EndReceive(ar); 

      if (bytesRead > 0) 
      { 
        if (flag == 0) 
        { 
         fileNameLen = BitConverter.ToInt32(state.buffer, 0); 
         string fileName = Encoding.UTF8.GetString(state.buffer, 4, fileNameLen); 
         receivedPath = Directory.GetCurrentDirectory() + "\\TEST\\" + str[0].ToString() + @"\" + fileName; 
         flag++; 
        } 
        if (flag >= 1) 
        { 
         BinaryWriter writer = new BinaryWriter(File.Open(receivedPath, FileMode.Append)); 
         if (flag == 1) 
         { 
          writer.Write(state.buffer, 4 + fileNameLen, bytesRead - (4 + fileNameLen)); 
          flag++; 
         } 
         else 
          writer.Write(state.buffer, 0, bytesRead); 
         writer.Close(); 
         handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
         new AsyncCallback(ReadCallback), state); 
        } 
      } 
      else 
      { 

       Invoke(new MyDelegate(LabelWriter)); 
      } 
     } 
     catch (Exception ex) 
     { 
      MessageBox.Show(ex.Message); 

     } 
    } 
public class Sender 
{ 
    public void sendme(string strIP) 
    { 
     try 
     { 
      // MessageBox.Show("That program can transfer small file. I've test up to 850kb file"); 
      IPEndPoint ipEnd = new IPEndPoint(IPAddress.Any, 9050); 
      Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); 
      sock.Bind(ipEnd); 
      sock.Listen(100); 

      while (true) 
      { 
       //clientSock is the socket object of client, so we can use it now to transfer data to client 
       Socket clientSock = sock.Accept(); 


       string fileName = "Login.xml";// "Your File Name"; 
       string filePath = Directory.GetCurrentDirectory() + "\\" + "XML" + @"\" ;//Your File Path; 
       byte[] fileNameByte = Encoding.ASCII.GetBytes(fileName); 

       byte[] fileData = File.ReadAllBytes(filePath + fileName); 
       byte[] clientData = new byte[4 + fileNameByte.Length + fileData.Length]; 
       byte[] fileNameLen = BitConverter.GetBytes(fileNameByte.Length); 

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


       clientSock.Send(clientData); 
       //MessageBox.Show("File:{0} has been sent." + fileName); 
      } 
      //sock.Shutdown(SocketShutdown.Both); 
      //sock.Close(); 


      // Console.ReadLine(); 
      //sendme(); 
     } 
     catch (Exception ex) 
     { 
      MessageBox.Show("File Receiving fail." + ex.Message); 
     } 
    } 
} 

code côté client:

public class StateObject 
    { 
     // Client socket. 
     public Socket workSocket = null; 

     public const int BufferSize = 1024; 
     // Receive buffer. 
     public byte[] buffer = new byte[BufferSize]; 
    } 

    public static ManualResetEvent allDone = new ManualResetEvent(false); 

    public void StartListening() 
    { 
     byte[] bytes = new Byte[1024]; 
     IPAddress address = IPAddress.Parse(ServerIP); 
     IPEndPoint ipEnd = new IPEndPoint(address, 9050); 
     Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
     try 
     { 
      listener.Bind(ipEnd); 
      listener.Listen(100); 

      while (true) 
      { 
       allDone.Reset(); 
       // string ip = listener.RemoteEndPoint.ToString(); 
       listener.BeginAccept(new AsyncCallback(AcceptCallback), listener); 
       allDone.WaitOne(); 

      } 
     } 
     catch (Exception ex) 
     { 
      throw ex; 
     } 


    } 


    public void AcceptCallback(IAsyncResult ar) 
    { 

     allDone.Set(); 


     Socket listener = (Socket)ar.AsyncState; 
     Socket handler = listener.EndAccept(ar); 


     StateObject state = new StateObject(); 
     state.workSocket = handler; 
     handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
     new AsyncCallback(ReadCallback), state); 
     flag = 0; 
    } 

    public void ReadCallback(IAsyncResult ar) 
    { 

     try 
     { 

      int fileNameLen = 1; 
      String content = String.Empty; 
      StateObject state = (StateObject)ar.AsyncState; 
      Socket handler = state.workSocket; 
      //string[] str = new string[2]; 
      //str = handler.RemoteEndPoint.ToString().Split(':'); 
      string path = mypath + "@Login.XML"; 
      if (!Directory.Exists(path)) 
      { 
       Directory.CreateDirectory(path); 
      } 

      int bytesRead = handler.EndReceive(ar); 

      if (bytesRead > 0) 
      { 

       if (flag == 0) 
       { 
        fileNameLen = BitConverter.ToInt32(state.buffer, 0); 
        string fileName = Encoding.UTF8.GetString(state.buffer, 4, fileNameLen); 
        receivedPath = mypath + "@Login.XML"; 
        flag++; 
       } 
       if (flag >= 1) 
       { 
        BinaryWriter writer = new BinaryWriter(File.Open(receivedPath, FileMode.Append)); 
        if (flag == 1) 
        { 
         writer.Write(state.buffer, 4 + fileNameLen, bytesRead - (4 + fileNameLen)); 
         flag++; 
        } 
        else 
         writer.Write(state.buffer, 0, bytesRead); 
        writer.Close(); 
        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
        new AsyncCallback(ReadCallback), state); 
       } 

      } 
      else 
      { 

       Invoke(new MyDelegate(LabelWriter)); 
      } 
     } 
     catch (Exception ex) 
     { 
      MessageBox.Show(ex.Message); 

     } 
    } 
    public void LabelWriter() 
    { 
     MessageBox.Show("Data has been received"); 
     Programs p = new Programs(); 
     p.GetFile(serverIP); 
    } 

ce code est utilisé pour obtenir le fichier du serveur.

private void GetLoginTemp() 
    { 
     Socket clientSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
     try 
     { 
      char[] delimiter = splitter.ToCharArray(); 
      byte[] fileName = Encoding.UTF8.GetBytes("empty"); //file name 
      byte[] fileData; 
      fileData = Encoding.UTF8.GetBytes("empty"); 
      //byte[] fileData = reads.ReadToEnd().to; //file 
      byte[] fileNameLen = BitConverter.GetBytes(fileName.Length); //lenght of file name 
      clientData = new byte[4 + fileName.Length + fileData.Length]; 

      fileNameLen.CopyTo(clientData, 0); 
      fileName.CopyTo(clientData, 4); 
      fileData.CopyTo(clientData, 4 + fileName.Length); 
      System.Net.IPAddress ipAdd = System.Net.IPAddress.Parse(serverIP); 

      IPEndPoint ipEnd = new IPEndPoint(ipAdd, 9050); 
      clientSock.Connect(ipEnd); //target machine's ip address and the port number 
      clientSock.Send(clientData); 

      byte[] clientData1 = new byte[1024 * 5000]; 
      string receivedPath = mypath + @"\XML" + @"\Login.xml"; 

      int receivedBytesLen = clientSock.Receive(clientData1); 

      int fileNameLen1 = BitConverter.ToInt32(clientData1, 0); 
      string fileName1 = Encoding.ASCII.GetString(clientData1, 4, fileNameLen1); 

      BinaryWriter bWrite = new BinaryWriter(File.Open(receivedPath + fileName, FileMode.Append)); ; 
      bWrite.Write(clientData, 4 + fileNameLen1, receivedBytesLen - 4 - fileNameLen1); 
      //clientSock.Shutdown(SocketShutdown.Send); 

      clientSock.Close(); 
     } 
     catch (Exception ex) 
     { 
      clientSock.Close(); 
      MessageBox.Show(ex.Message); 
     } 
    } 

Answer 1

Vous semblez penser que vous avez besoin d'une deuxième connexion TCP dans la direction du fichier. Cela n'est pas nécessaire car la connexion TCP est un flux full-duplex . De plus, ce n'est jamais une bonne conception de se connecter du serveur au client, qui pourrait être derrière une passerelle NAT/pare-feu. C'est le problème avec FTP (voir active vs passive ftp).

Utilisez la même connexion que le client a déjà établie. Vous avez besoin d'une sorte de protocole au-dessus de TCP de base pour laisser savoir à l'autre côté quand s'attendre à des données et combien attendre. Cela a été discuté ici plusieurs fois, voir par exemple this SO question.

Answer 2

Juste de l'erreur que vous obtenez (j'ai obtenu la même erreur beaucoup de fois) Vérifiez que le flux sous-jacent que vous utilisez pour votre communication n'est pas fermée, ou que vous n'êtes pas essayer de ré utiliser un flux fermé.

Avez-vous une ligne spécifique où l'erreur se produit?

Answer 3

Vous pouvez vérifier les pare-feu du système pour vous assurer que la connexion est autorisée. L'utilisation de ping et telnet est excellente pour le débogage.

Answer 4

Si ce n'est pas le pare-feu, je pense qu'il est aussi simple que de mettre le serveur à écouter (pour démarrer le serveur)

Je suggère ce morceau de code permettrait de résoudre votre problème:

var prg = StateObject(); 
prg.StartListening; 

Une fois que vous gérerez cela, s'il vous plaît me dire si le fichier est envoyé sur 8KB complet