La socket UDP ne peut pas envoyer le paquet à l'adresse DHCP

Question

J'ai créé une simple connexion de socket UDP pour envoyer des données entre le réseau local. La connexion est de deux types: peer to peer et diffusion groupée. Voici ma classe: Peer to peer serveur:

public class CandyCaneUdpServer 
{ 
    Socket sck; 
    EndPoint LocalEP; 
    EndPoint RemoteEP; 
    int port = 80; 
    IAsyncResult oldAsyncResult; 

    public event EventHandler<MessageObject> RaiseMessageReceivedEvent; 

    public CandyCaneUdpServer() 
    { 
     sck = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); 
     sck.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); 
     sck.ExclusiveAddressUse = false; 
     LocalEP = new IPEndPoint(IPAddress.Parse(UdpUtility.GetLocalIP()), port); 
     RemoteEP = new IPEndPoint(IPAddress.Any, port); 
    } 

    public void Serve() 
    { 
     sck.Bind(LocalEP); 
     byte[] _buffer = new byte[1500]; 
     oldAsyncResult = sck.BeginReceiveFrom(_buffer, 0, _buffer.Length, SocketFlags.None, ref RemoteEP, new AsyncCallback(MessageCallBack), _buffer); 
    } 

    private void MessageCallBack(IAsyncResult aResult) 
    { 
     int size = sck.EndReceiveFrom(aResult, ref RemoteEP); 
     if (size > 0) 
     { 
      byte[] receivedData; 
      receivedData = (byte[])aResult.AsyncState; 
      MessageObject obj; 
      IFormatter f = new BinaryFormatter(); 
      using (MemoryStream s = new MemoryStream(receivedData)) 
      { 
       obj = (MessageObject)f.Deserialize(s); 
      } 
      OnRaiseMessageReceivedEvent(obj); 
     } 

     var _buffer = new byte[1500]; 
     oldAsyncResult = sck.BeginReceiveFrom(_buffer, 0, _buffer.Length, SocketFlags.None, ref RemoteEP, new AsyncCallback(MessageCallBack), _buffer); 
    } 

    protected virtual void OnRaiseMessageReceivedEvent(MessageObject e) 
    { 
     EventHandler<MessageObject> handler = RaiseMessageReceivedEvent; 
     if (handler != null) 
     { 
      handler(this, e); 
     } 
    } 
} 

est ci-dessous peer to peer client (expéditeur):

public class CandyCaneUdpClient 
{ 
    Socket sck; 
    EndPoint RemoteEP; 

    public CandyCaneUdpClient(string RemoteIP, int RemotePort) 
    { 
     sck = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); 
     sck.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); 
     sck.ExclusiveAddressUse = false; 
     RemoteEP = new IPEndPoint(IPAddress.Parse(RemoteIP), RemotePort); 
    } 

    public void Send(int MessageId, string Message, __MessageObjectType t = __MessageObjectType.P2P) 
    { 
     byte[] msg; 
     msg = Encoding.UTF8.GetBytes(Message); 
     var obj = new MessageObject() 
     { 
      Id = MessageId, 
      Type = t, 
      SourceIP = UdpUtility.GetLocalIP(), 
      TargetIP = ((IPEndPoint)RemoteEP).Address.ToString(), 
      SentTime = DateTime.Now, 
      Message = Message 
     }; 
     IFormatter f = new BinaryFormatter(); 
     using (MemoryStream ms = new MemoryStream()) 
     { 
      f.Serialize(ms, obj); 
      var msgByte = ms.ToArray(); 
      sck.SendTo(msgByte, msgByte.Length, SocketFlags.None, RemoteEP); 
     } 
    } 
} 

Le code fonctionne bien pour toutes les machines-net éther. Lorsqu'un client wifi est connecté, le PC sans fil peut envoyer des données mais ne pas recevoir de données. Lorsque j'examine l'adresse IP, le client ether-net a l'adresse IP de 192.168.211 .---. alors que le pc sans fil a une IP de 192.168.0 .---. Je me demande si l'adresse DHCP provoque le problème. Le chat de groupe fonctionne bien.

public class CandyCaneUdpGroupChatListener 
    { 
     UdpClient listener; 

     IPAddress routerBindIP; 
     readonly int routerBindPort = UdpUtility.GroupChatDefinedPort(); 
     EndPoint routerEP, senderEP; 

     public event EventHandler<MessageObject> RaiseMessageReceivedEvent; 

     public CandyCaneUdpGroupChatListener() 
     { 
      routerBindIP = IPAddress.Parse(UdpUtility.GroupChatRouterBindAddress()); 
      routerEP = new IPEndPoint(routerBindIP, routerBindPort); 
      senderEP = new IPEndPoint(IPAddress.Parse(UdpUtility.GetLocalIP()), routerBindPort); 


      listener = new UdpClient(); 

      listener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); 

      listener.ExclusiveAddressUse = false; 
      listener.Client.Bind(senderEP); 
      listener.JoinMulticastGroup(routerBindIP); 

      var _buffer = new byte[1500]; 

      listener.Client.BeginReceiveFrom(_buffer, 0, _buffer.Length, SocketFlags.None, ref routerEP, 
       new AsyncCallback(ReceiveMessage), _buffer); 
     } 

     private void ReceiveMessage(IAsyncResult result) 
     { 
      if (listener == null) return; 
      if (listener.Client == null) return; 
      int size = listener.Client.EndReceiveFrom(result, ref routerEP); 

      if (size > 0) 
      { 
       byte[] receivedData; 
       receivedData = (byte[])result.AsyncState; 
       MessageObject obj; 
       IFormatter f = new BinaryFormatter(); 
       using (MemoryStream s = new MemoryStream(receivedData)) 
       { 
        obj = (MessageObject)f.Deserialize(s); 
        //if (obj.SourceIP == UdpUtility.GetLocalIP()) return; 
       } 
       MessageReceived(obj); 
      } 

      var _buffer = new byte[1500]; 
      listener.Client.BeginReceiveFrom(_buffer, 0, _buffer.Length, SocketFlags.None, ref routerEP, 
       new AsyncCallback(ReceiveMessage), _buffer); 
     } 

     protected virtual void MessageReceived(MessageObject e) 
     { 
      EventHandler<MessageObject> handler = this.RaiseMessageReceivedEvent; 
      if (handler != null) 
      { 
       handler(this, e); 
      } 
     } 

     public void Disconnect() 
     { 
      listener.DropMulticastGroup(routerBindIP);   
     } 

    } 

Answer 1

Découvrez comment vous avez configuré vos sous-réseaux de réseaux câblés et sans fil. Il semble que deux serveurs DHCP différents fonctionnent ici - un pour le réseau filaire et un autre pour le réseau sans fil.

Assurez-vous que vos routeurs réseau sont configurés de sorte qu'un hôte sur un sous-réseau puisse communiquer avec un hôte sur l'autre sous-réseau.

Pour déterminer si un hôte sur un sous-réseau peut communiquer avec un hôte sur l'autre sous-réseau, vous pouvez utiliser l'utilitaire de routage réseau ou l'utilitaire ping.

Sous Windows, l'itinéraire de suivi est implémenté en tant qu'application tracert.exe, que vous devriez trouver dans le répertoire C:\Windows\System32.

Supposons que vous êtes sur le client joint-Ethernet, vous pouvez l'exécuter avec la ligne de commande suivante pour tenter de tracer la route vers le PC sans fil (supposons qu'il a l'adresse 192.168.0.104):

C:> \Windows\System32\tracert.exe 192.168.0.104 

vous devriez obtenir une sortie qui ressemble à ceci:

Tracing route to 192.168.0.104 
over a maximum of 30 hops: 

1 1 ms  1 ms <1 ms 192.168.211.54 
... (possibly other entries her) 
2 1 ms  1 ms  1 ms 192.168.0.104 

Trace complete. 

Si la trace échoue, il est un indiquer que votre trafic réseau ne peut se rendre à la machine que vous essayez de tracer à. Sachez que si tracert échoue, ce n'est pas une indication de 100% d'échec de connectivité. Cela peut indiquer que le trafic ICMP est bloqué par un pare-feu ou que la machine de destination ne répond pas aux requêtes ICMP.