UDP打孔实现

5 回答

• 14

  如果我理解正确，你试图在两个客户端之间进行点对点通信，每个客户端位于不同的NAT后面，使用中介服务器进行打孔？

  几年前我在c＃中做了完全相同的事情，我还没有找到代码，但是如果你喜欢的话会给你一些指示：

  首先，我不会在udpclient上使用Connect（）函数，因为UDP是一个无连接协议，所有这个功能实际上都隐藏了UDP套接字的功能 .

  您应该执行以下步骤：

  • 在服务器上打开UDP套接字，其端口未被防火墙阻止，位于特定端口（例如 Bind 此套接字到所选端口，例如23000）

  • 在第一个客户端上创建UDP套接字，并以23000向服务器发送内容. Do not bind this socket . 当使用udp发送数据包时，windows会自动为插槽分配一个空闲端口

  • 从其他客户端执行相同操作

  • 服务器现在从2个不同地址的2个客户端收到2个数据包，有2个不同的端口 . 测试服务器是否可以在同一地址和端口上发回数据包 . （如果这不起作用 . 如果你可以在不打开端口的情况下玩游戏，你知道它的工作原理：D）

  • 服务器现在应该将其他客户端的地址和端口发送到每个连接的客户端 .

  • 客户端现在应该能够使用UDP将数据包发送到从服务器接收的地址 .

  您应该注意nat上使用的端口可能与客户端PC上的端口不同!!服务器应将此外部端口分发给客户端 . You must use the external adresses and the external ports to send to!

  另请注意，您的NAT可能不支持此类端口转发 . 一些NAT将指定端口上的所有传入流量转发给您的客户端，这就是您想要的 . 但是有些nat会对传入的数据包进行过滤，因此它可能会阻止其他客户端数据包 . 这在使用标准个人用户路由器时不太可能 .

  回复于 2024-04-20T04:44:41+08:00
• 3

  您是否尝试过使用Async函数，以下是如何使其工作的示例，可能需要一些工作才能使其100％正常运行：

  public void HolePunch(String ServerIp, Int32 Port)
      {
          IPEndPoint LocalPt = new IPEndPoint(Dns.GetHostEntry(Dns.GetHostName()).AddressList[0], Port);
          UdpClient Client = new UdpClient();
          Client.ExclusiveAddressUse = false;
          Client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
          Client.Client.Bind(LocalPt);
  
          IPEndPoint RemotePt = new IPEndPoint(IPAddress.Parse(ServerIp), Port);
  
          // This Part Sends your local endpoint to the server so if the two peers are on the same nat they can bypass it, you can omit this if you wish to just use the remote endpoint.
          byte[] IPBuffer = System.Text.Encoding.UTF8.GetBytes(Dns.GetHostEntry(Dns.GetHostName()).AddressList[0].ToString());
          byte[] LengthBuffer = BitConverter.GetBytes(IPBuffer.Length);
          byte[] PortBuffer = BitConverter.GetBytes(Port);
          byte[] Buffer = new byte[IPBuffer.Length + LengthBuffer.Length + PortBuffer.Length];
          LengthBuffer.CopyTo(Buffer,0);
          IPBuffer.CopyTo(Buffer, LengthBuffer.Length);
          PortBuffer.CopyTo(Buffer, IPBuffer.Length + LengthBuffer.Length);
          Client.BeginSend(Buffer, Buffer.Length, RemotePt, new AsyncCallback(SendCallback), Client);
  
          // Wait to receve something
          BeginReceive(Client, Port);
  
          // you may want to use a auto or manual ResetEvent here and have the server send back a confirmation, the server should have now stored your local (you sent it) and remote endpoint.
  
          // you now need to work out who you need to connect to then ask the server for there remote and local end point then need to try to connect to the local first then the remote.
          // if the server knows who you need to connect to you could just have it send you the endpoints as the confirmation.
  
          // you may also need to keep this open with a keepalive packet untill it is time to connect to the peer or peers.
  
          // once you have the endpoints of the peer you can close this connection unless you need to keep asking the server for other endpoints
  
          Client.Close();
      }
  
      public void ConnectToPeer(String PeerIp, Int32 Port)
      {
          IPEndPoint LocalPt = new IPEndPoint(Dns.GetHostEntry(Dns.GetHostName()).AddressList[0], Port);
          UdpClient Client = new UdpClient();
          Client.ExclusiveAddressUse = false;
          Client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
          Client.Client.Bind(LocalPt);
          IPEndPoint RemotePt = new IPEndPoint(IPAddress.Parse(PeerIp), Port);
          Client.Connect(RemotePt);
          //you may want to keep the peer client connections in a list.
  
          BeginReceive(Client, Port);
      }
  
      public void SendCallback(IAsyncResult ar)
      {
          UdpClient Client = (UdpClient)ar.AsyncState;
          Client.EndSend(ar);
      }
  
      public void BeginReceive(UdpClient Client, Int32 Port)
      {
          IPEndPoint ListenPt = new IPEndPoint(IPAddress.Any, Port);
  
          Object[] State = new Object[] { Client, ListenPt };
  
          Client.BeginReceive(new AsyncCallback(ReceiveCallback), State);
      }
  
      public void ReceiveCallback(IAsyncResult ar)
      {
          UdpClient Client = (UdpClient)((Object[])ar.AsyncState)[0];
          IPEndPoint ListenPt = (IPEndPoint)((Object[])ar.AsyncState)[0];
  
          Byte[] receiveBytes = Client.EndReceive(ar, ref ListenPt);
      }
  

  我希望这有帮助 .

  回复于 2024-04-20T04:44:41+08:00
• 1

  编辑：经过更多测试后，除非我启用UPnP，否则这对我来说似乎根本不起作用 . 所以我在这里写的很多东西你可能觉得很有用但是许多人没有启用UPnP（因为它存在安全风险）所以它不适用于他们 .

  这是一些使用PubNub作为中继服务器的代码:) . 我不建议在没有测试的情况下使用此代码，因为它不完美（我不确定它是否是安全的或正确的做事方式？idk我不是网络专家）但它应该给你一个想法该怎么做到目前为止，它至少对我来说是一个爱好项目 . 它缺少的是：

  • 测试客户端是否在您的LAN上 . 我只发送两个适用于您的LAN和另一个网络上的设备，但这是非常低效的 .

  • 例如，当客户端关闭程序时，测试客户端何时停止监听 . 因为这是UDP，所以它是无状态的，所以如果没有人得到它，它就不会这样做

  • 我使用Open.NAT以编程方式进行端口转发，但这可能不适用于某些设备 . 具体来说，它使用UPnP，它有点不安全，需要手动端口转发UDP端口1900 . 一旦他们这样做，它在大多数路由器上都受支持，但许多人还没有这样做 .

  首先，您需要一种方法来获取外部和本地IP . 以下是获取本地IP的代码：

  // From http://stackoverflow.com/questions/6803073/get-local-ip-address
  public string GetLocalIp()
  {
      var host = Dns.GetHostEntry(Dns.GetHostName());
      foreach (var ip in host.AddressList)
      {
          if (ip.AddressFamily == AddressFamily.InterNetwork)
          {
              return ip.ToString();
          }
      }
      throw new Exception("Failed to get local IP");
  }
  

  以下是一些代码，用于通过尝试一些旨在返回外部IP的网站来获取外部IP

  public string GetExternalIp()
  {
      for (int i = 0; i < 2; i++)
      {
          string res = GetExternalIpWithTimeout(400);
          if (res != "")
          {
              return res;
          }
      }
      throw new Exception("Failed to get external IP");
  }
  private static string GetExternalIpWithTimeout(int timeoutMillis)
  {
      string[] sites = new string[] {
        "http://ipinfo.io/ip",
        "http://icanhazip.com/",
        "http://ipof.in/txt",
        "http://ifconfig.me/ip",
        "http://ipecho.net/plain"
      };
      foreach (string site in sites)
      {
          try
          {
              HttpWebRequest request = (HttpWebRequest)WebRequest.Create(site);
              request.Timeout = timeoutMillis;
              using (var webResponse = (HttpWebResponse)request.GetResponse())
              {
                  using (Stream responseStream = webResponse.GetResponseStream())
                  {
                      using (StreamReader responseReader = new System.IO.StreamReader(responseStream, Encoding.UTF8))
                      {
                          return responseReader.ReadToEnd().Trim();
                      }
                  }
              }
          }
          catch
          {
              continue;
          }
      }
  
      return "";
  
  }
  

  现在我们需要找到一个开放端口并将其转发到外部端口 . 如上所述，我使用Open.NAT . 首先，在查看registered UDP ports之后，将您认为合适的端口列表放在一起 . 以下是一些例子：

  public static int[] ports = new int[]
  {
    5283,
    5284,
    5285,
    5286,
    5287,
    5288,
    5289,
    5290,
    5291,
    5292,
    5293,
    5294,
    5295,
    5296,
    5297
  };
  

  现在我们可以循环遍历它们，并希望找到一个未使用的端口转发：

  public UdpClient GetUDPClientFromPorts(out Socket portHolder, out string localIp, out int localPort, out string externalIp, out int externalPort)
  {
    localIp = GetLocalIp();
    externalIp = GetExternalIp();
  
    var discoverer = new Open.Nat.NatDiscoverer();
    var device = discoverer.DiscoverDeviceAsync().Result;
  
    IPAddress localAddr = IPAddress.Parse(localIp);
    int workingPort = -1;
    for (int i = 0; i < ports.Length; i++)
    {
        try
        {
            // You can alternatively test tcp with  nc -vz externalip 5293 in linux and
            // udp with  nc -vz -u externalip 5293 in linux
            Socket tempServer = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            tempServer.Bind(new IPEndPoint(localAddr, ports[i]));
            tempServer.Close();
            workingPort = ports[i];
            break;
        }
        catch
        {
          // Binding failed, port is in use, try next one
        }
    }
  
  
    if (workingPort == -1)
    {
        throw new Exception("Failed to connect to a port");
    }
  
  
    int localPort = workingPort;
  
    // You could try a different external port if the below code doesn't work
    externalPort = workingPort;
  
    // Mapping ports
    device.CreatePortMapAsync(new Open.Nat.Mapping(Open.Nat.Protocol.Udp, localPort, externalPort));
  
    // Bind a socket to our port to "claim" it or cry if someone else is now using it
    try
    {
        portHolder = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        portHolder.Bind(new IPEndPoint(localAddr, localPort));
    }
    catch
    {
        throw new Exception("Failed, someone is now using local port: " + localPort);
    }
  
  
    // Make a UDP Client that will use that port
    UdpClient udpClient = new UdpClient(localPort);
    return udpClient;
  }
  

  现在为PubNub中继服务器代码（P2PPeer将在下面定义） . 这里有很多，所以我不会真的解释它，但希望代码足够清楚，以帮助您了解正在发生的事情

  public delegate void NewPeerCallback(P2PPeer newPeer);
  public event NewPeerCallback OnNewPeerConnection;
  
  public Pubnub pubnub;
  public string pubnubChannelName;
  public string localIp;
  public string externalIp;
  public int localPort;
  public int externalPort;
  public UdpClient udpClient;
  HashSet<string> uniqueIdsPubNubSeen;
  object peerLock = new object();
  Dictionary<string, P2PPeer> connectedPeers;
  string myPeerDataString;
  
  public void InitPubnub(string pubnubPublishKey, string pubnubSubscribeKey, string pubnubChannelName)
  {
      uniqueIdsPubNubSeen = new HashSet<string>();
      connectedPeers = new Dictionary<string, P2PPeer>;
      pubnub = new Pubnub(pubnubPublishKey, pubnubSubscribeKey);
      myPeerDataString = localIp + " " + externalIp + " " + localPort + " " + externalPort + " " + pubnub.SessionUUID;
      this.pubnubChannelName = pubnubChannelName;
      pubnub.Subscribe<string>(
          pubnubChannelName,
          OnPubNubMessage,
          OnPubNubConnect,
          OnPubNubError);
      return pubnub;
  }
  
  //// Subscribe callbacks
  void OnPubNubConnect(string res)
  {
      pubnub.Publish<string>(pubnubChannelName, connectionDataString, OnPubNubTheyGotMessage, OnPubNubMessageFailed);
  }
  
  void OnPubNubError(PubnubClientError clientError)
  {
      throw new Exception("PubNub error on subscribe: " + clientError.Message);
  }
  
  void OnPubNubMessage(string message)
  {
      // The message will be the string ["localIp externalIp localPort externalPort","messageId","channelName"]
      string[] splitMessage = message.Trim().Substring(1, message.Length - 2).Split(new char[] { ',' });
      string peerDataString = splitMessage[0].Trim().Substring(1, splitMessage[0].Trim().Length - 2);
  
      // If you want these, I don't need them
      //string peerMessageId = splitMessage[1].Trim().Substring(1, splitMessage[1].Trim().Length - 2);
      //string channelName = splitMessage[2].Trim().Substring(1, splitMessage[2].Trim().Length - 2);
  
  
      string[] pieces = peerDataString.Split(new char[] { ' ', '\t' });
      string peerLocalIp = pieces[0].Trim();
      string peerExternalIp = pieces[1].Trim();
      string peerLocalPort = int.Parse(pieces[2].Trim());
      string peerExternalPort = int.Parse(pieces[3].Trim());
      string peerPubnubUniqueId = pieces[4].Trim();
  
      pubNubUniqueId = pieces[4].Trim();
  
      // If you are on the same device then you have to do this for it to work idk why
      if (peerLocalIp == localIp && peerExternalIp == externalIp)
      {
          peerLocalIp = "127.0.0.1";
      }
  
  
      // From me, ignore
      if (peerPubnubUniqueId == pubnub.SessionUUID)
      {
          return;
      }
  
      // We haven't set up our connection yet, what are we doing
      if (udpClient == null)
      {
          return;
      }
  
  
      // From someone else
  
  
      IPEndPoint peerEndPoint = new IPEndPoint(IPAddress.Parse(peerExternalIp), peerExternalPort);
      IPEndPoint peerEndPointLocal = new IPEndPoint(IPAddress.Parse(peerLocalIp), peerLocalPort);
  
      // First time we have heard from them
      if (!uniqueIdsPubNubSeen.Contains(peerPubnubUniqueId))
      {
          uniqueIdsPubNubSeen.Add(peerPubnubUniqueId);
  
          // Dummy messages to do UDP hole punching, these may or may not go through and that is fine
          udpClient.Send(new byte[10], 10, peerEndPoint);
          udpClient.Send(new byte[10], 10, peerEndPointLocal); // This is if they are on a LAN, we will try both
          pubnub.Publish<string>(pubnubChannelName, myPeerDataString, OnPubNubTheyGotMessage, OnPubNubMessageFailed);
      }
      // Second time we have heard from them, after then we don't care because we are connected
      else if (!connectedPeers.ContainsKey(peerPubnubUniqueId))
      {
          //bool isOnLan = IsOnLan(IPAddress.Parse(peerExternalIp)); TODO, this would be nice to test for
          bool isOnLan = false; // For now we will just do things for both
          P2PPeer peer = new P2PPeer(peerLocalIp, peerExternalIp, peerLocalPort, peerExternalPort, this, isOnLan);
          lock (peerLock)
          {
              connectedPeers.Add(peerPubnubUniqueId, peer);
          }
  
          // More dummy messages because why not
          udpClient.Send(new byte[10], 10, peerEndPoint);
          udpClient.Send(new byte[10], 10, peerEndPointLocal);
  
  
          pubnub.Publish<string>(pubnubChannelName, connectionDataString, OnPubNubTheyGotMessage, OnPubNubMessageFailed);
          if (OnNewPeerConnection != null)
          {
              OnNewPeerConnection(peer);
          }
      }
  }
  
  //// Publish callbacks
  void OnPubNubTheyGotMessage(object result)
  {
  
  }
  
  void OnPubNubMessageFailed(PubnubClientError clientError)
  {
      throw new Exception("PubNub error on publish: " + clientError.Message);
  }
  

  这是一个P2PPeer

  public class P2PPeer
  {
      public string localIp;
      public string externalIp;
      public int localPort;
      public int externalPort;
      public bool isOnLan;
  
      P2PClient client;
  
      public delegate void ReceivedBytesFromPeerCallback(byte[] bytes);
  
      public event ReceivedBytesFromPeerCallback OnReceivedBytesFromPeer;
  
  
      public P2PPeer(string localIp, string externalIp, int localPort, int externalPort, P2PClient client, bool isOnLan)
      {
          this.localIp = localIp;
          this.externalIp = externalIp;
          this.localPort = localPort;
          this.externalPort = externalPort;
          this.client = client;
          this.isOnLan = isOnLan;
  
  
  
          if (isOnLan)
          {
              IPEndPoint endPointLocal = new IPEndPoint(IPAddress.Parse(localIp), localPort);
              Thread localListener = new Thread(() => ReceiveMessage(endPointLocal));
              localListener.IsBackground = true;
              localListener.Start();
          }
  
          else
          {
              IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(externalIp), externalPort);
              Thread externalListener = new Thread(() => ReceiveMessage(endPoint));
              externalListener.IsBackground = true;
              externalListener.Start();
          }
      }
  
      public void SendBytes(byte[] data)
      {
          if (client.udpClient == null)
          {
              throw new Exception("P2PClient doesn't have a udpSocket open anymore");
          }
          //if (isOnLan) // This would work but I'm not sure how to test if they are on LAN so I'll just use both for now
          {
              client.udpClient.Send(data, data.Length, new IPEndPoint(IPAddress.Parse(localIp), localPort));
          }
          //else
          {
              client.udpClient.Send(data, data.Length, new IPEndPoint(IPAddress.Parse(externalIp), externalPort));
          }
      }
  
      // Encoded in UTF8
      public void SendString(string str)
      {
          SendBytes(System.Text.Encoding.UTF8.GetBytes(str));
      }
  
  
      void ReceiveMessage(IPEndPoint endPoint)
      {
          while (client.udpClient != null)
          {
              byte[] message = client.udpClient.Receive(ref endPoint);
              if (OnReceivedBytesFromPeer != null)
              {
                  OnReceivedBytesFromPeer(message);
              }
              //string receiveString = Encoding.UTF8.GetString(message);
              //Console.Log("got: " + receiveString);
          }
      }
  }
  

  最后，这是我的所有用途：

  using PubNubMessaging.Core; // Get from PubNub GitHub for C#, I used the Unity3D library
  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Net;
  using System.Net.Sockets;
  using System.Text;
  using System.Threading;
  

  我愿意接受评论和提问，如果这里的内容不好或不起作用，请随时提供反馈 . 我的代码在翻译中引入了一些错误，我最终将在这里修复，但这至少应该让你知道该怎么做 .

  回复于 2024-04-20T04:44:41+08:00
• 4

  Update:

  无论哪个UdpClients首先绑定是由Windows发送传入数据包 . 在您的示例中，尝试将设置侦听线程的代码块移动到顶部 .

  您确定问题不仅仅是接收线程只是为了处理单个接收而编写的吗？尝试使用如下替换接收线程 .

  ThreadPool.QueueUserWorkItem(delegate
  {
      UdpClient udpServer = new UdpClient();
      udpServer.ExclusiveAddressUse = false;
      udpServer.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
      udpServer.Client.Bind(localpt);
  
      IPEndPoint inEndPoint = new IPEndPoint(IPAddress.Any, 0);
      Console.WriteLine("Listening on " + localpt + ".");
  
      while (inEndPoint != null)
      {
          byte[] buffer = udpServer.Receive(ref inEndPoint);
          Console.WriteLine("Bytes received from " + inEndPoint + " " + Encoding.ASCII.GetString(buffer) + ".");
      }
  });
  

  回复于 2024-04-20T04:44:41+08:00
• 0

  很抱歉上传了如此巨大的代码，但我想这很清楚地解释了事情是如何运作的，并且可能非常有用 . 如果您对此代码有疑问，请告诉我们 .

  Note:

  • 这只是一个草案

  • （重要）您必须通过本地 endpoints 通知服务器 . 如果你不这样做，即使服务器不在NAT，你也无法在一个NAT后面的两个对等体之间进行通信（例如，在一台本地机器上）

  • 你必须关闭"puncher"客户端（至少，我没有设法收到任何数据包，直到我这样做） . 稍后您将能够使用其他 UdpClient 与服务器通信

  • 的cource它不适用于对称NAT

  • 如果您发现此代码中的内容是"terrible practice"，请告诉我，我不是网络专家:)

  ---

  Server.cs

  using System;
  using System.Collections.Generic;
  using System.Net;
  using System.Net.Sockets;
  using HolePunching.Common;
  
  namespace HolePunching.Server
  {
      class Server
      {
          private static bool _isRunning;
          private static UdpClient _udpClient;
          private static readonly Dictionary<byte, PeerContext> Contexts = new Dictionary<byte, PeerContext>();
  
          private static readonly Dictionary<byte, byte> Mappings = new Dictionary<byte, byte>
          {
              {1, 2},
              {2, 1},
          };
  
          static void Main()
          {
              _udpClient = new UdpClient( Consts.UdpPort );
              ListenUdp();
  
              Console.ReadLine();
              _isRunning = false;
          }
  
          private static async void ListenUdp()
          {
              _isRunning = true;
  
              while ( _isRunning )
              {
                  try
                  {
                      var receivedResults = await _udpClient.ReceiveAsync();
  
                      if ( !_isRunning )
                      {
                          break;
                      }
  
                      ProcessUdpMessage( receivedResults.Buffer, receivedResults.RemoteEndPoint );
                  }
                  catch ( Exception ex )
                  {
                      Console.WriteLine( $"Error: {ex.Message}" );
                  }
              }
          }
  
          private static void ProcessUdpMessage( byte[] buffer, IPEndPoint remoteEndPoint )
          {
              if ( !UdpProtocol.UdpInfoMessage.TryParse( buffer, out UdpProtocol.UdpInfoMessage message ) )
              {
                  Console.WriteLine( $" >>> Got shitty UDP [ {remoteEndPoint.Address} : {remoteEndPoint.Port} ]" );
                  _udpClient.Send( new byte[] { 1 }, 1, remoteEndPoint );
                  return;
              }
  
              Console.WriteLine( $" >>> Got UDP from {message.Id}. [ {remoteEndPoint.Address} : {remoteEndPoint.Port} ]" );
  
              if ( !Contexts.TryGetValue( message.Id, out PeerContext context ) )
              {
                  context = new PeerContext
                  {
                      PeerId = message.Id,
                      PublicUdpEndPoint = remoteEndPoint,
                      LocalUdpEndPoint = new IPEndPoint( message.LocalIp, message.LocalPort ),
                  };
  
                  Contexts.Add( context.PeerId, context );
              }
  
              byte partnerId = Mappings[context.PeerId];
              if ( !Contexts.TryGetValue( partnerId, out context ) )
              {
                  _udpClient.Send( new byte[] { 1 }, 1, remoteEndPoint );
                  return;
              }
  
              var response = UdpProtocol.PeerAddressMessage.GetMessage(
                  partnerId,
                  context.PublicUdpEndPoint.Address,
                  context.PublicUdpEndPoint.Port,
                  context.LocalUdpEndPoint.Address,
                  context.LocalUdpEndPoint.Port );
  
              _udpClient.Send( response.Data, response.Data.Length, remoteEndPoint );
  
              Console.WriteLine( $" <<< Responsed to {message.Id}" );
          }
      }
  
      public class PeerContext
      {
          public byte PeerId { get; set; }
          public IPEndPoint PublicUdpEndPoint { get; set; }
          public IPEndPoint LocalUdpEndPoint { get; set; }
      }
  }
  

  Client.cs

  using System;
  
  namespace HolePunching.Client
  {
      class Client
      {
          public const string ServerIp = "your.server.public.address";
  
          static void Main()
          {
              byte id = ReadIdFromConsole();
  
              // you need some smarter :)
              int localPort = id == 1 ? 61043 : 59912;
              var x = new Demo( ServerIp, id, localPort );
              x.Start();
          }
  
          private static byte ReadIdFromConsole()
          {
              Console.Write( "Peer id (1 or 2): " );
  
              var id = byte.Parse( Console.ReadLine() );
  
              Console.Title = $"Peer {id}";
  
              return id;
          }
      }
  }
  

  Demo.cs

  using HolePunching.Common;
  using System;
  using System.Collections.Generic;
  using System.Net;
  using System.Net.Sockets;
  using System.Threading;
  using System.Threading.Tasks;
  
  namespace HolePunching.Client
  {
      public class Demo
      {
          private static bool _isRunning;
  
          private static UdpClient _udpPuncher;
          private static UdpClient _udpClient;
          private static UdpClient _extraUdpClient;
          private static bool _extraUdpClientConnected;
  
          private static byte _id;
  
          private static IPEndPoint _localEndPoint;
          private static IPEndPoint _serverUdpEndPoint;
          private static IPEndPoint _partnerPublicUdpEndPoint;
          private static IPEndPoint _partnerLocalUdpEndPoint;
  
          private static string GetLocalIp()
          {
              var host = Dns.GetHostEntry( Dns.GetHostName() );
              foreach ( var ip in host.AddressList )
              {
                  if ( ip.AddressFamily == AddressFamily.InterNetwork )
                  {
                      return ip.ToString();
                  }
              }
              throw new Exception( "Failed to get local IP" );
          }
  
          public Demo( string serverIp, byte id, int localPort )
          {
              _serverUdpEndPoint = new IPEndPoint( IPAddress.Parse( serverIp ), Consts.UdpPort );
              _id = id;
  
              // we have to bind all our UdpClients to this endpoint
              _localEndPoint = new IPEndPoint( IPAddress.Parse( GetLocalIp() ), localPort );
          }
  
          public void Start(  )
          {
              _udpPuncher = new UdpClient(); // this guy is just for punching
              _udpClient = new UdpClient(); // this will keep hole alive, and also can send data
              _extraUdpClient = new UdpClient(); // i think, this guy is the best option for sending data (explained below)
  
              InitUdpClients( new[] { _udpPuncher, _udpClient, _extraUdpClient }, _localEndPoint );
  
              Task.Run( (Action) SendUdpMessages );
              Task.Run( (Action) ListenUdp );
  
              Console.ReadLine();
              _isRunning = false;
          }
  
          private void InitUdpClients(IEnumerable<UdpClient> clients, EndPoint localEndPoint)
          {
              // if you don't want to use explicit localPort, you should create here one more UdpClient (X) and send something to server (it will automatically bind X to free port). then bind all clients to this port and close X
  
              foreach ( var udpClient in clients )
              {
                  udpClient.ExclusiveAddressUse = false;
                  udpClient.Client.SetSocketOption( SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true );
                  udpClient.Client.Bind( localEndPoint );
              }
          }
  
          private void SendUdpMessages()
          {
              _isRunning = true;
  
              var messageToServer = UdpProtocol.UdpInfoMessage.GetMessage( _id, _localEndPoint.Address, _localEndPoint.Port );
              var messageToPeer = UdpProtocol.P2PKeepAliveMessage.GetMessage();
  
              while ( _isRunning )
              {
                  // while we dont have partner's address, we will send messages to server
                  if ( _partnerPublicUdpEndPoint == null && _partnerLocalUdpEndPoint == null )
                  {
                      _udpPuncher.Send( messageToServer.Data, messageToServer.Data.Length, _serverUdpEndPoint );
                      Console.WriteLine( $" >>> Sent UDP to server [ {_serverUdpEndPoint.Address} : {_serverUdpEndPoint.Port} ]" );
                  }
                  else
                  {
                      // you can skip it. just demonstration, that you still can send messages to server
                      _udpClient.Send( messageToServer.Data, messageToServer.Data.Length, _serverUdpEndPoint );
                      Console.WriteLine( $" >>> Sent UDP to server [ {_serverUdpEndPoint.Address} : {_serverUdpEndPoint.Port} ]" );
  
                      // THIS is how we punching hole! very first this message should be dropped by partner's NAT, but it's ok.
                      // i suppose that this is good idea to send this "keep-alive" messages to peer even if you are connected already,
                      // because AFAIK "hole" for UDP lives ~2 minutes on NAT. so "we will let it die? NEVER!" (c)
                      _udpClient.Send( messageToPeer.Data, messageToPeer.Data.Length, _partnerPublicUdpEndPoint );
                      _udpClient.Send( messageToPeer.Data, messageToPeer.Data.Length, _partnerLocalUdpEndPoint );
                      Console.WriteLine( $" >>> Sent UDP to peer.public [ {_partnerPublicUdpEndPoint.Address} : {_partnerPublicUdpEndPoint.Port} ]" );
                      Console.WriteLine( $" >>> Sent UDP to peer.local [ {_partnerLocalUdpEndPoint.Address} : {_partnerLocalUdpEndPoint.Port} ]" );
  
                      // "connected" UdpClient sends data much faster, 
                      // so if you have something that your partner cant wait for (voice, for example), send it this way
                      if ( _extraUdpClientConnected )
                      {
                          _extraUdpClient.Send( messageToPeer.Data, messageToPeer.Data.Length );
                          Console.WriteLine( $" >>> Sent UDP to peer.received EP" );
                      }
                  }
  
                  Thread.Sleep( 3000 );
              }
          }
  
          private async void ListenUdp()
          {
              _isRunning = true;
  
              while ( _isRunning )
              {
                  try
                  {
                      // also important thing!
                      // when you did not punched hole yet, you must listen incoming packets using "puncher" (later we will close it).
                      // where you already have p2p connection (and "puncher" closed), use "non-puncher"
                      UdpClient udpClient = _partnerPublicUdpEndPoint == null ? _udpPuncher : _udpClient;
  
                      var receivedResults = await udpClient.ReceiveAsync();
  
                      if ( !_isRunning )
                      {
                          break;
                      }
  
                      ProcessUdpMessage( receivedResults.Buffer, receivedResults.RemoteEndPoint );
                  }
                  catch ( SocketException ex )
                  {
                      // do something here...
                  }
                  catch ( Exception ex )
                  {
                      Console.WriteLine( $"Error: {ex.Message}" );
                  }
              }
          }
  
          private static void ProcessUdpMessage( byte[] buffer, IPEndPoint remoteEndPoint )
          {
              // if server sent partner's endpoinps, we will store it and (IMPORTANT) close "puncher"
              if ( UdpProtocol.PeerAddressMessage.TryParse( buffer, out UdpProtocol.PeerAddressMessage peerAddressMessage ) )
              {
                  Console.WriteLine( " <<< Got response from server" );
                  _partnerPublicUdpEndPoint = new IPEndPoint( peerAddressMessage.PublicIp, peerAddressMessage.PublicPort );
                  _partnerLocalUdpEndPoint = new IPEndPoint( peerAddressMessage.LocalIp, peerAddressMessage.LocalPort );
  
                  _udpPuncher.Close();
              }
              // since we got this message we know partner's endpoint for sure, 
              // and we can "connect" UdpClient to it, so it will work faster
              else if ( UdpProtocol.P2PKeepAliveMessage.TryParse( buffer ) )
              {
                  Console.WriteLine( $"           IT WORKS!!! WOW!!!  [ {remoteEndPoint.Address} : {remoteEndPoint.Port} ]" );
  
                  _extraUdpClientConnected = true;
                  _extraUdpClient.Connect( remoteEndPoint );
              }
              else
              {
                  Console.WriteLine( "???" );
              }
          }
      }
  }
  

  Protocol.cs

  我不确定这种方法有多好，也许protobuf可以做得更好

  using System;
  using System.Linq;
  using System.Net;
  using System.Text;
  
  namespace HolePunching.Common
  {
      public static class UdpProtocol
      {
          public static readonly int GuidLength = 16;
          public static readonly int PeerIdLength = 1;
          public static readonly int IpLength = 4;
          public static readonly int IntLength = 4;
  
          public static readonly byte[] Prefix = { 12, 23, 34, 45 };
  
          private static byte[] JoinBytes( params byte[][] bytes )
          {
              var result = new byte[bytes.Sum( x => x.Length )];
              int pos = 0;
  
              for ( int i = 0; i < bytes.Length; i++ )
              {
                  for ( int j = 0; j < bytes[i].Length; j++, pos++ )
                  {
                      result[pos] = bytes[i][j];
                  }
              }
  
              return result;
          }
  
          #region Helper extensions
  
          private static bool StartsWith( this byte[] @this, byte[] value, int offset = 0 )
          {
              if ( @this == null || value == null || @this.Length < offset + value.Length )
              {
                  return false;
              }
  
              for ( int i = 0; i < value.Length; i++ )
              {
                  if ( @this[i + offset] < value[i] )
                  {
                      return false;
                  }
              }
  
              return true;
          }
  
          private static byte[] ToUnicodeBytes( this string @this )
          {
              return Encoding.Unicode.GetBytes( @this );
          }
  
          private static byte[] Take( this byte[] @this, int offset, int length )
          {
              return @this.Skip( offset ).Take( length ).ToArray();
          }
  
          public static bool IsSuitableUdpMessage( this byte[] @this )
          {
              return @this.StartsWith( Prefix );
          }
  
          public static int GetInt( this byte[] @this )
          {
              if ( @this.Length != 4 )
                  throw new ArgumentException( "Byte array must be exactly 4 bytes to be convertible to uint." );
  
              return ( ( ( @this[0] << 8 ) + @this[1] << 8 ) + @this[2] << 8 ) + @this[3];
          }
  
          public static byte[] ToByteArray( this int value )
          {
              return new[]
              {
                  (byte)(value >> 24),
                  (byte)(value >> 16),
                  (byte)(value >> 8),
                  (byte)value
              };
          }
  
          #endregion
  
          #region Messages
  
          public abstract class UdpMessage
          {
              public byte[] Data { get; }
  
              protected UdpMessage( byte[] data )
              {
                  Data = data;
              }
          }
  
          public class UdpInfoMessage : UdpMessage
          {
              private static readonly byte[] MessagePrefix = { 41, 57 };
              private static readonly int MessageLength = Prefix.Length + MessagePrefix.Length + PeerIdLength + IpLength + IntLength;
  
              public byte Id { get; }
              public IPAddress LocalIp { get; }
              public int LocalPort { get; }
  
              private UdpInfoMessage( byte[] data, byte id, IPAddress localIp, int localPort )
                  : base( data )
              {
                  Id = id;
                  LocalIp = localIp;
                  LocalPort = localPort;
              }
  
              public static UdpInfoMessage GetMessage( byte id, IPAddress localIp, int localPort )
              {
                  var data = JoinBytes( Prefix, MessagePrefix, new[] { id }, localIp.GetAddressBytes(), localPort.ToByteArray() );
  
                  return new UdpInfoMessage( data, id, localIp, localPort );
              }
  
              public static bool TryParse( byte[] data, out UdpInfoMessage message )
              {
                  message = null;
  
                  if ( !data.StartsWith( Prefix ) )
                      return false;
                  if ( !data.StartsWith( MessagePrefix, Prefix.Length ) )
                      return false;
                  if ( data.Length != MessageLength )
                      return false;
  
                  int index = Prefix.Length + MessagePrefix.Length;
                  byte id = data[index];
  
                  index += PeerIdLength;
                  byte[] localIpBytes = data.Take( index, IpLength );
                  var localIp = new IPAddress( localIpBytes );
  
                  index += IpLength;
                  byte[] localPortBytes = data.Take( index, IntLength );
                  int localPort = localPortBytes.GetInt();
  
                  message = new UdpInfoMessage( data, id, localIp, localPort );
  
                  return true;
              }
          }
  
          public class PeerAddressMessage : UdpMessage
          {
              private static readonly byte[] MessagePrefix = { 36, 49 };
              private static readonly int MessageLength = Prefix.Length + MessagePrefix.Length + PeerIdLength + ( IpLength + IntLength ) * 2;
  
              public byte Id { get; }
              public IPAddress PublicIp { get; }
              public int PublicPort { get; }
              public IPAddress LocalIp { get; }
              public int LocalPort { get; }
  
              private PeerAddressMessage( byte[] data, byte id, IPAddress publicIp, int publicPort, IPAddress localIp, int localPort )
                  : base( data )
              {
                  Id = id;
                  PublicIp = publicIp;
                  PublicPort = publicPort;
                  LocalIp = localIp;
                  LocalPort = localPort;
              }
  
              public static PeerAddressMessage GetMessage( byte id, IPAddress publicIp, int publicPort, IPAddress localIp, int localPort )
              {
                  var data = JoinBytes( Prefix, MessagePrefix, new[] { id }, 
                      publicIp.GetAddressBytes(), publicPort.ToByteArray(),
                      localIp.GetAddressBytes(), localPort.ToByteArray() );
  
                  return new PeerAddressMessage( data, id, publicIp, publicPort, localIp, localPort );
              }
  
              public static bool TryParse( byte[] data, out PeerAddressMessage message )
              {
                  message = null;
  
                  if ( !data.StartsWith( Prefix ) )
                      return false;
                  if ( !data.StartsWith( MessagePrefix, Prefix.Length ) )
                      return false;
                  if ( data.Length != MessageLength )
                      return false;
  
                  int index = Prefix.Length + MessagePrefix.Length;
                  byte id = data[index];
  
                  index += PeerIdLength;
                  byte[] publicIpBytes = data.Take( index, IpLength );
                  var publicIp = new IPAddress( publicIpBytes );
  
                  index += IpLength;
                  byte[] publicPortBytes = data.Take( index, IntLength );
                  int publicPort = publicPortBytes.GetInt();
  
                  index += IntLength;
                  byte[] localIpBytes = data.Take( index, IpLength );
                  var localIp = new IPAddress( localIpBytes );
  
                  index += IpLength;
                  byte[] localPortBytes = data.Take( index, IntLength );
                  int localPort = localPortBytes.GetInt();
  
                  message = new PeerAddressMessage( data, id, publicIp, publicPort, localIp, localPort );
  
                  return true;
              }
          }
  
          public class P2PKeepAliveMessage : UdpMessage
          {
              private static readonly byte[] MessagePrefix = { 11, 19 };
              private static P2PKeepAliveMessage _message;
  
              private P2PKeepAliveMessage( byte[] data )
                  : base( data )
              {
  
              }
  
              public static bool TryParse( byte[] data )
              {
                  if ( !data.StartsWith( Prefix ) )
                      return false;
                  if ( !data.StartsWith( MessagePrefix, Prefix.Length ) )
                      return false;
  
                  return true;
              }
  
              public static P2PKeepAliveMessage GetMessage()
              {
                  if ( _message == null )
                  {
                      var data = JoinBytes( Prefix, MessagePrefix );
                      _message = new P2PKeepAliveMessage( data );
                  }
  
                  return _message;
              }
          }
  
          #endregion
      }
  }
  

  回复于 2024-04-20T04:44:41+08:00