UDP打孔。让服务器与客户端通话如何实现?

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (2)
  • 关注 (0)
  • 查看 (269)

我一直在阅读很多关于如何实现UDP打孔的问题,但出于某种原因,我无法使其工作。

对于那些不熟悉udp打孔的人来说,这是我自己的定义:

目标是能够在服务器的帮助下在两个客户端(客户端A和客户端B)之间传输数据。因此,客户端A连接到服务器并发送其信息。客户B做同样的事情。服务器具有必要的信息,以便客户端A能够将数据发送到客户端B,反之亦然。因此,服务器将这些信息提供给两个客户端。一旦两个客户端都有相互的信息,就可以在没有服务器的帮助下在这些客户端之间开始发送和接收数据。

我的目标是能够做我刚刚描述的(udp打孔)。在这样做之前,我认为能够从服务器连接到客户端会很有帮助。为了做到这一点,我计划向服务器发送关于客户端的信息。一旦服务器收到该信息,就尝试从头开始连接到客户端。一旦我能够执行,我应该拥有一切我需要开始实施真正的udp打孔。

这是我如何设置的东西:

顶部路由器的服务器和底部路由器连接到LAN端口。底层路由器(NAT)通过WAN端口连接到顶层路由器。客户端计算机连接到底部路由器到其一个LAN端口。

所以在这方面,客户端能够看到服务器,但服务器无法看到客户端。

所以我在伪代码中完成的算法是:

  • 客户端连接到服务器。
  • 客户端将一些UDP包发送到服务器以打开NAT上的一些端口
  • 在客户端正在监听的端口上向服务器发送信息。
  • 一旦服务器收到该信息,就尝试从头开始连接到客户端。

以下是代码中的实现:

服务器:

static void Main()
{     
    /* Part 1 receive data from client */
    UdpClient listener = new UdpClient(11000);
    IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, 11000);
    string received_data;
    byte[] receive_byte_array = listener.Receive(ref groupEP);       
    received_data = Encoding.ASCII.GetString(receive_byte_array, 0, receive_byte_array.Length);

    // get info
    var ip = groupEP.Address.ToString();
    var port = groupEP.Port;

    /* Part 2 atempt to connect to client from scratch */
    // now atempt to send data to client from scratch once we have the info       
    Socket sendSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
    IPEndPoint endPointClient = new IPEndPoint(IPAddress.Parse(ip), port);
    sendSocket.SendTo(Encoding.ASCII.GetBytes("Hello"), endPointClient);
}

客户:

static void Main(string[] args)
{
    /* Part 1 send info to server */
    Socket sending_socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram,  ProtocolType.Udp);
    IPAddress send_to_address = IPAddress.Parse("192.168.0.132");
    IPEndPoint sending_end_point = new IPEndPoint(send_to_address, 11000);
    sending_socket.SendTo(Encoding.ASCII.GetBytes("Test"), sending_end_point);

    // get info
    var port = sending_socket.LocalEndPoint.ToString().Split(':')[1];

    /* Part 2 receive data from server */
    IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, int.Parse(port));
    byte[] buffer = new byte[1024];
    sending_socket.Receive(buffer);
} 

出于某种原因,它工作了几次!它在客户端成功接收数据时工作:sending_socket.Receive(buffer);

注意事项: 如果在第二部分的服务器上,我使用实例变量listner而不是创建新变量,sendSocket并通过该变量发送字节,客户端可以接收正在发送的数据。请记住,服务器的第二部分将由第二个客户端B实现,这就是为什么我要重新初始化变量的原因......

这是查看同一问题的另一种方式。当我初始化一个新对象而不是使用同一个对象时,客户端不会收到响应。

我有一个UdpClient类型的对象。我能够将该对象的数据发送给其他对等体。如果我使用相同的属性创建另一个具有相同属性的对象并尝试发送数据,则不起作用!我可能会错过初始化一些变量。我可以用反射设置私有变量,所以我不应该有问题。反正这里是服务器代码:

public static void Main()
{
    // wait for client to send data
    UdpClient listener = new UdpClient(11000);
    IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, 11000);        
    byte[] receive_byte_array = listener.Receive(ref groupEP);

    // connect so that we are able to send data back
    listener.Connect(groupEP);

    byte[] dataToSend = new byte[] { 1, 2, 3, 4, 5 };

    // now let's atempt to reply back

    // this part does not work!
    UdpClient newClient = CopyUdpClient(listener, groupEP);
    newClient.Send(dataToSend, dataToSend.Length);

    // this part works!
    listener.Send(dataToSend, dataToSend.Length);
}

static UdpClient CopyUdpClient(UdpClient client, IPEndPoint groupEP)
{
    var ip = groupEP.Address.ToString();
    var port = groupEP.Port;
    var newUdpClient = new UdpClient(ip, port);
    return newUdpClient;
}

客户端代码基本上将数据发送到服务器,然后等待响应:

    string ipOfServer = "192.168.0.132";
    int portServerIsListeningOn = 11000;

    // send data to server
    Socket sending_socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
    IPAddress send_to_address = IPAddress.Parse(ipOfServer);
    IPEndPoint sending_end_point = new IPEndPoint(send_to_address, portServerIsListeningOn);
    sending_socket.SendTo(Encoding.ASCII.GetBytes("Test"), sending_end_point);

    // get info
    var port = sending_socket.LocalEndPoint.ToString().Split(':')[1];

    // now wait for server to send data back
    IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, int.Parse(port));
    byte[] buffer = new byte[1024];
    sending_socket.Receive(buffer); // <----- keeps waiting in here :(

注意客户端在路由器(NAT)后面,否则我不会有这个问题。我想复制udpClient的原因是,我可以将该变量发送到另一台计算机,使其他计算机可以将数据发送到客户端。

所以我的问题是 为什么原始对象listener能够发送数据但newClient不能?sending_socket.Receive(buffer);即使在服务器执行该行后,客户端仍然在排队等待:newClient.Send(dataToSend, dataToSend.Length);。当侦听器发送数据而不是newClient时,客户端成功接收数据。为什么这两个变量具有相同的目标IP和端口?这些变量如何不同?

注意:如果服务器和客户端位于同一网络上,则复制工作和变量newClient能够将数据发送到客户端。为了模拟这个问题,客户端必须在NAT(路由器)后面。这种网络的一个例子可能由两台路由器组成。我们称它们为路由器X和路由器Y.还需要一个服务器呼叫S和一个客户端C.因此S可以连接到X的LAN端口之一。C可以连接到Y的LAN端口之一。最后将Y的WAN端口连接到X的LAN端口之一。

提问于
用户回答回答于

服务器代码:

class Program
{
    static byte[] dataToSend = new byte[] { 1, 2, 3, 4, 5 };

    // get the ip and port number where the client will be listening on
    static IPEndPoint GetClientInfo()
    {
        // wait for client to send data
        using (UdpClient listener = new UdpClient(11000))
        {
            IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, 11000);
            byte[] receive_byte_array = listener.Receive(ref groupEP);

            return groupEP;
        }
    }

    static void Main(string[] args)
    {
        var info = GetClientInfo(); // get client info

        /* NOW THAT WE HAVE THE INFO FROM THE CLIENT WE ARE GONG TO SEND
           DATA TO IT FROM SCRATCH!. NOTE THE CLIENT IS BEHIND A NAT AND
           WE WILL STILL BE ABLE TO SEND PACKAGES TO IT
        */

        // create a new client. this client will be created on a 
        // different computer when I do readl udp punch holing
        UdpClient newClient = ConstructUdpClient(info);

        // send data
        newClient.Send(dataToSend, dataToSend.Length);            
    }

    // Construct a socket with the info received from the client
    static UdpClient ConstructUdpClient(IPEndPoint clientInfo)
    {          
        var ip = clientInfo.Address.ToString();
        var port = clientInfo.Port;

        // this is the part I was missing!!!!
        // the local end point must match. this should be the ip this computer is listening on
        // and also the port            
        UdpClient client = new UdpClient(new IPEndPoint( IPAddress.Any, 11000));

        // lastly we are missing to set the end points. (ip and port client is listening on)

        // the connect method sets the remote endpoints
        client.Connect(ip, port);

        return client;
    }
}

客户代码:

string ipOfServer = "192.168.0.139";
int portServerIsListeningOn = 11000;

// send data to server
Socket sending_socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
IPAddress send_to_address = IPAddress.Parse(ipOfServer);
IPEndPoint sending_end_point = new IPEndPoint(send_to_address, portServerIsListeningOn);
sending_socket.SendTo(Encoding.ASCII.GetBytes("Test"), sending_end_point);

// get info
var port = sending_socket.LocalEndPoint.ToString().Split(':')[1];

// now wait for server to send data back
IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, int.Parse(port));
byte[] buffer = new byte[1024];
sending_socket.Receive(buffer); // <----- we can receive data now!!!!!
用户回答回答于

首先,它实际上称为UDP打孔。让我试着解释这应该如何工作。

NAT路由器通常在将数据包从内部专用网络转发到外部互联网时进行端口映射

假设在NAT后面的机器上创建了一个UDP套接字,并将数据报发送到某个外部IP /端口。当携带该数据报的IP数据包离开发送机时,其IP报头将源地址字段设置为本地非全局可路由的私有IP地址(例如192.168.1.15),并且UDP报头将源端口字段设置为分配给任何端口套接字(明确地通过绑定,或由操作系统从临时端口隐式选取)。我将调用此源端口号P1

然后,当NAT路由器在外部网络上发送该数据包时,它会将源IP地址覆盖为其自己的外部IP地址(否则无法将数据包路由回),并且通常会将源UDP端口覆盖为其他值(可能是因为专用网络上的其他主机使用相同的源端口,这造成了不明确性)。原始源端口与新端口号(让我们标记它P2)之间的映射将保存在路由器中以匹配返回的数据包。此映射也可能是特定于目标IP地址目标UDP端口

所以,现在你已经在路由器上“打了一个洞” - 发送回路由器端口的UDP数据包P2通过UDP端口转发到内部计算机P1。同样,根据NAT的实施情况,这可能仅限于来自原始目标IP地址和目标UDP端口的数据包。

对于客户端到客户端的通信,您必须通过服务器告知外部IP /端口,希望NAT路由器将相同的内部源端口映射到相同的外部源端口。然后客户端将使用这些数据包发送数据包。

扫码关注云+社区

领取腾讯云代金券