使用 Boost.Asio 进行广播的问题

如果问题之前已得到解答，我提前表示歉意，但我已经搜索并没有找到任何对我有帮助的东西。正如问题标题所示，我正在尝试将包从服务器广播到一组侦听任何消息的客户端。

客户端将计算一秒钟内收到的消息数。

服务器端的事情是这样的：

class Server
{
public:

    Server(boost::asio::io_service& io)
        : socket(io, udp::endpoint(udp::v4(), 8888))
        , broadcastEndpoint(address_v4::broadcast(), 8888)
        , tickHandler(boost::bind(&Server::Tick, this, boost::asio::placeholders::error))
        , timer(io, boost::posix_time::milliseconds(20))
    {
        socket.set_option(boost::asio::socket_base::reuse_address(true));
        socket.set_option(boost::asio::socket_base::broadcast(true));

        timer.async_wait(tickHandler);
    }

private:

    void Tick(const boost::system::error_code&)
    {
        socket.send_to(boost::asio::buffer(buffer), broadcastEndpoint);

        timer.expires_at(timer.expires_at() + boost::posix_time::milliseconds(20));
        timer.async_wait(tickHandler);
    }

private:

    udp::socket socket;
    udp::endpoint broadcastEndpoint;

    boost::function<void(const boost::system::error_code&)> tickHandler;
    boost::asio::deadline_timer timer;

    boost::array<char, 100> buffer;

};

它的初始化和运行方式如下：

int main()
{
    try
    {
        boost::asio::io_service io;
        Server server(io);
        io.run();
    }
    catch (const std::exception& e)
    {
        std::cerr << e.what() << "\n";
    }

    return 0;
}

这（显然）工作得很好。现在客户来了...

void HandleReceive(const boost::system::error_code&, std::size_t bytes)
{
    std::cout << "Got " << bytes << " bytes\n";
}

int main(int argc, char* argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " <host>\n";
        return 1;
    }

    try
    {
        boost::asio::io_service io;

        udp::resolver resolver(io);
        udp::resolver::query query(udp::v4(), argv[1], "1666");

        udp::endpoint serverEndpoint = *resolver.resolve(query);
        //std::cout << serverEndpoint.address() << "\n";

        udp::socket socket(io);
        socket.open(udp::v4());

        socket.bind(serverEndpoint);

        udp::endpoint senderEndpoint;
        boost::array<char, 300> buffer;

        auto counter = 0;
        auto start = std::chrono::system_clock::now();

        while (true)
        {
            socket.receive_from(boost::asio::buffer(buffer), senderEndpoint);
            ++counter;

            auto current = std::chrono::system_clock::now();
            if (current - start >= std::chrono::seconds(1))
            {
                std::cout << counter << "\n";

                counter = 0;
                start = current;
            }
        }
    }
    catch (const std::exception& e)
    {
        std::cerr << e.what() << "\n";
    }

当在同一台计算机上运行服务器和客户端时，这有效，但当我在与运行客户端的计算机不同的计算机上运行服务器时，这不起作用。

首先，我必须解析服务器的地址，这对我来说似乎很奇怪。也许我不知道广播到底是如何工作的，但我认为服务器会使用其套接字发送一条消息，并打开广播选项，并且该消息将到达同一网络中的所有套接字。

我读到你应该将客户端的套接字绑定到address_v4::any()地址。我做到了，它不起作用（说一些关于已经使用地址/端口的套接字的信息）。

提前致谢。

PS：我使用的是Windows 8。

我有点惊讶这能在同一台机器上工作。我没想到监听端口 1666 的客户端会接收发送到端口 8888 上的广播地址的数据。

bind() http://www.boost.org/doc/libs/1_53_0/doc/html/boost_asio/reference/basic_datagram_socket/bind/overload1.html assigns a local endpoint (composed of a local address and port) to the socket. When a socket binds to an endpoint, it specifies that the socket will only receive data sent to the bound address and port. It is often advised to bind to address_v4::any() http://www.boost.org/doc/libs/1_53_0/doc/html/boost_asio/reference/ip__address_v4/any.html, as this will use all available interfaces for listening. In the case of a system with multiple interfaces (possible multiple NIC cards), binding to a specific interface address will result in the socket only listening to data received from the specified interface^[1]. Thus, one might find themselves obtaining an address through resolve() http://www.boost.org/doc/libs/1_53_0/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload1.html when the application wants to bind to a specific network interface and wants to support resolving it by providing the IP directly (127.0.0.1) or a name (localhost).

需要注意的是，当绑定到套接字时，端点由地址和地址组成。and港口。这就是我惊讶的原因，它可以在同一台机器上运行。如果服务器正在写入广播：8888，则绑定到端口 1666 的套接字不应接收数据报。尽管如此，这里还是端点和网络的可视化：

                                                               .--------.
                                                              .--------.|
.--------. address: any                         address: any .--------.||
|        | port: any      /                  \    port: 8888 |        |||
| server |-( ----------->| address: broadcast |----------> )-| client ||'
|        |                \    port: 8888    /               |        |'
'--------'                                                   '--------'

服务器绑定到任何地址和任何端口，启用广播选项，并将数据发送到远程端点（广播：8888）。绑定到端口 8888 上的任何地址的客户端都应该收到数据。

一个简单的例子如下。

服务器：

#include <boost/asio.hpp>

int main()
{
  namespace ip = boost::asio::ip;
  boost::asio::io_service io_service;

  // Server binds to any address and any port.
  ip::udp::socket socket(io_service,
                         ip::udp::endpoint(ip::udp::v4(), 0));
  socket.set_option(boost::asio::socket_base::broadcast(true));

  // Broadcast will go to port 8888.
  ip::udp::endpoint broadcast_endpoint(ip::address_v4::broadcast(), 8888);

  // Broadcast data.
  boost::array<char, 4> buffer;
  socket.send_to(boost::asio::buffer(buffer), broadcast_endpoint);
}

客户端：

#include <iostream>

#include <boost/asio.hpp>

int main()
{
  namespace ip = boost::asio::ip;
  boost::asio::io_service io_service;

  // Client binds to any address on port 8888 (the same port on which
  // broadcast data is sent from server).
  ip::udp::socket socket(io_service, 
                         ip::udp::endpoint(ip::udp::v4(), 8888 ));

  ip::udp::endpoint sender_endpoint;

  // Receive data.
  boost::array<char, 4> buffer;
  std::size_t bytes_transferred = 
    socket.receive_from(boost::asio::buffer(buffer), sender_endpoint);

  std::cout << "got " << bytes_transferred << " bytes." << std::endl;
}

当客户端与服务器不在同一位置时，可能会出现各种与网络相关的问题：

• 验证服务器和客户端之间的连接。
• 验证防火墙例外。
• 验证路由设备上的广播支持/例外。
• 使用网络分析工具，例如Wireshark http://www.wireshark.org/，以验证生存时间 http://en.wikipedia.org/wiki/Time_to_live数据包中的字段足够高，不会在路由过程中被丢弃。

_{1. On Linux, broadcast datagrams received by an adapter will not be passed to a socket bound to a specific interface, as the datagram's destination is set to the broadcast address. On the other hand, Windows will pass broadcast datagrams received by an adapter to sockets bound to a specific interface.}