P2P通讯的C++实现-UDP Hole Punching方法

Title: P2P通讯的C++实现-UDP Hole Punching方法

整理时间: 2016-03-24 by kagula

 

UDP Hole Punching方法，需要服务端。

假设有A、B两个客户端和S一个服务器

Step 1 : A、B发送UDP请求给S，S知道了A、B在公网的IP和端口。

Step 2: A从S中取B在公网的IP和端口。

             B从S中取A在公网的IP和端口。

Step 3: A通过B在公网的IP和端口向B发送UDP请求。

              B通过A在公网的IP和端口向A发送UDP请求。

Step Final:

              A同B之间可以通过UDP直接互相发送信息。

目前看来这种方法最大的缺点, 还是需要服务器。

整理后的服务端文件

#include <iostream>
#include <sstream>
#include <string>
#include <list>
#include <boost/array.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/asio.hpp>
#include <boost/thread.hpp>

using boost::asio::ip::udp;

class udp_server
{
public:
udp_server(boost::asio::io_service &io_service) :
_sock(io_service, udp::endpoint(udp::v4(), 2333))
{
session_receive();
}
void session_receive();
void handle_receive(const boost::system::error_code &ec, std::size_t len);
void session_send(udp::endpoint &ep, std::string write_message);
void handle_send(const boost::system::error_code &ec, std::size_t len);
private:
udp::socket _sock;
boost::array<char, 256> _recv_buffer;
std::string _write_message;
std::list<udp::endpoint> _endpoint_list;
udp::endpoint _remote_endpoint;//current endpoint
};

void udp_server::session_receive()
{
_sock.async_receive_from(
boost::asio::buffer(_recv_buffer),
_remote_endpoint,
boost::bind(&udp_server::handle_receive,
this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}

void udp_server::handle_receive(const boost::system::error_code &ec, std::size_t len)
{
std::string receive_message(_recv_buffer.data(), len);
if (strcmp(receive_message.c_str(), "login") == 0)
{
int isLogged = 0;
for (std::list<udp::endpoint>::iterator iter = _endpoint_list.begin(); iter != _endpoint_list.end(); ++iter)
{
if (*iter == _remote_endpoint)
{
session_send(_remote_endpoint, "You have already logged in.\n");
isLogged = 1;
break;
}
if (!isLogged)
{
std::cout << "User login.\nAddress : " << _remote_endpoint.address().to_string() << std::endl;
std::cout << "Port : " << _remote_endpoint.port() << std::endl;
_endpoint_list.push_back(_remote_endpoint);
session_send(_remote_endpoint, "login success.\n");
}
}
}
else if (strcmp(receive_message.c_str(), "logout") == 0)
{
int isLogged = 0;
for (std::list<udp::endpoint>::iterator iter = _endpoint_list.begin(); iter != _endpoint_list.end(); ++iter)
{
if (*iter == _remote_endpoint)
{
isLogged = 1;
_endpoint_list.erase(iter);
std::cout << "User logout.\nAddress : " << _remote_endpoint.address().to_string() << std::endl;
std::cout << "Port : " << _remote_endpoint.port() << std::endl;
session_send(_remote_endpoint, "Logout success.\n");
break;
}
}
if (!isLogged)
session_send(_remote_endpoint, "Logout failed, you have not logged in.\n");
}
else if (strcmp(receive_message.c_str(), "list") == 0)
{
std::ostringstream message;
int i = 0;
for (std::list<udp::endpoint>::iterator iter = _endpoint_list.begin(); iter != _endpoint_list.end(); ++iter)
{
if (*iter == _remote_endpoint)
message << "[" << i << "]" << iter->address().to_string() << ":" << iter->port() << " (yourself)" << std::endl;
else
message << "[" << i << "]" << iter->address().to_string() << ":" << iter->port() << std::endl;
i++;
}
session_send(_remote_endpoint, message.str());
}
else if (strncmp(receive_message.c_str(), "punch", 5) == 0)
{
int punched_client = atoi(receive_message.c_str() + 6);
std::list<udp::endpoint>::iterator iter = _endpoint_list.begin();
for (int i = 0; i < punched_client && iter != _endpoint_list.end(); ++i, ++iter);
std::ostringstream message;
if (iter == _endpoint_list.end())
message << "Punch failed, no such client.";
else
{
std::ostringstream peer_message;
//udp::endpoint peer_endpoint(iter->address(), iter->port);
peer_message << "PUNCH_REQUEST " << _remote_endpoint.address().to_string() << ":" << _remote_endpoint.port() << std::endl;
session_send(*iter, peer_message.str());
message << "PUNCH_SUCCESS " << iter->address().to_string() << ":" << iter->port() << std::endl;
}
session_send(_remote_endpoint, message.str());
}
else if (strcmp(receive_message.c_str(), "help") == 0)
{
session_send(_remote_endpoint, "Command:\
\n\thelp : Show this information.\
\n\tlogin : Login p2p server to make you punchable.\
\n\tlogout : Logout p2p server so that other client(s) won't find you.\
\n\tlist: List all client(s) that have login.\
\n\tpunch <client_number>: send punch request to remote client and start a p2p session\n");
}
else
{
session_send(_remote_endpoint, "Unknown command, please type 'help' to see more options.\n");
}
session_receive();
}

void udp_server::session_send(udp::endpoint &ep, std::string write_message)
{
//std::getline(std::cin, _write_message);
_sock.async_send_to(boost::asio::buffer(write_message),
ep,
boost::bind(&udp_server::handle_send,
this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}

void udp_server::handle_send(const boost::system::error_code &ec, std::size_t len)
{
//session_send();
}

int main(int argc, char *argv[])
{
boost::asio::io_service io_service;
udp_server server(io_service);
io_service.run();
return 0;
}

整理后的客户端文件

#include <iostream>
#include <string>
#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <cstring>
#include <cstdlib>
boost::shared_mutex io_mutex;

namespace
{
int p2p_connect = 0;
}

using boost::asio::ip::udp;
class udp_client
{
public:
udp_client(boost::asio::io_service &io_service, const char *host, const char *port):_sock(io_service)
{
udp::resolver _resolver(io_service);
udp::resolver::query _query(udp::v4(), host, port);
_server_endpoint = *_resolver.resolve(_query);
_sock.open(udp::v4());
start_send(); //**Must send first**
}

void start_send();
void session_send();
void handle_send(const boost::system::error_code &ec, std::size_t len);
void session_receive();
void handle_recevie(const boost::system::error_code &ec, std::size_t len);
void p2p_receive(udp::socket &sock, udp::endpoint &peer_endpoint);
void p2p_send(udp::socket *sock, udp::endpoint *peer_endpoint);
private:
udp::socket _sock;
udp::endpoint _server_endpoint;
boost::array<char, 512> _recv_buffer;
std::string _write_message;
};

void udp_client::start_send()
{
_sock.send_to(boost::asio::buffer("help"), _server_endpoint);
session_receive();
}

void udp_client::session_send()
{
std::getline(std::cin, _write_message);
_sock.async_send_to(
boost::asio::buffer(_write_message),
_server_endpoint,
boost::bind(&udp_client::handle_send,
this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}

void udp_client::handle_send(const boost::system::error_code &ec, std::size_t len)
{
//if(p2p_connect)
//    return;
//else
//    session_send();
}

void udp_client::session_receive()
{
_sock.async_receive_from(
boost::asio::buffer(_recv_buffer),
_server_endpoint,
boost::bind(&udp_client::handle_recevie,
this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}

void udp_client::handle_recevie(const boost::system::error_code &ec, std::size_t len)
{
std::string receive_message(_recv_buffer.data(), len);
if (strncmp(receive_message.c_str(), "PUNCH_SUCCESS", 13) == 0)
{
//punch finished
//start a p2p session to remote peer
std::cout << receive_message << std::endl;
p2p_connect = 1;
char str_endpoint[127];
strcpy(str_endpoint, receive_message.c_str() + 14);
char *peer_ip = strtok(str_endpoint, ":");
char *peer_port = strtok(NULL, ":");
udp::endpoint request_peer(boost::asio::ip::address::from_string(peer_ip),
std::atoi(peer_port));
_sock.send_to(boost::asio::buffer("Sender peer connection complete."), request_peer);
boost::thread(boost::bind(&udp_client::p2p_send, this, &_sock, &request_peer));
p2p_receive(_sock, request_peer);
}
else if (strncmp(receive_message.c_str(), "PUNCH_REQUEST", 13) == 0)
{
//send something to request remote peer
//and start a p2p session
std::cout << receive_message << std::endl;
p2p_connect = 1;
char str_endpoint[127];
strcpy(str_endpoint, receive_message.c_str() + 14);
char *peer_ip = strtok(str_endpoint, ":");
char *peer_port = strtok(NULL, ":");
udp::endpoint request_peer(boost::asio::ip::address::from_string(peer_ip),std::atoi(peer_port));

std::cin.clear(std::cin.rdstate() & std::cin.eofbit);
_sock.send_to(boost::asio::buffer("Receiver peer connection complete."), request_peer);
boost::thread(boost::bind(&udp_client::p2p_send, this, &_sock, &request_peer));
p2p_receive(_sock, request_peer);
}
else
{
std::cout << receive_message << std::endl;
}
session_receive();
if (p2p_connect)
return;
else
session_send();
}

void udp_client::p2p_receive(udp::socket &sock, udp::endpoint &peer_endpoint)
{
for (;;)
{
boost::system::error_code error;
//blocked until successfully received
size_t len = sock.receive_from(boost::asio::buffer(_recv_buffer),
peer_endpoint, 0, error);
std::string receive_message(_recv_buffer.data(), len);
std::cout << receive_message << std::endl;
}
}

void udp_client::p2p_send(udp::socket *sock, udp::endpoint *peer_endpoint)
{
while (std::getline(std::cin, _write_message))
{
sock->send_to(boost::asio::buffer(_write_message), *peer_endpoint);//blocked
}
}

int main(int argc, char *argv[])
{
if (argc != 3)
{
std::cerr << "Usage: client <Server IP> <Server Port>" << std::endl;
return 1;
}

boost::asio::io_service io_service;
udp_client client(io_service, argv[1], argv[2]);

//run in 2 threads
//boost::thread(boost::bind(&boost::asio::io_service::run, &io_service));
io_service.run();
return 0;
}

参考

[1]《P2P通信原理与实现(C++)》
http://www.tuicool.com/articles/YNBVrei