Z góry przepraszam, jeśli pytanie zostało wcześniej udzielone, ale przeszukałem i nie znalazłem niczego, co by mi pomogło. Jak wskazuje tytuł pytania, próbuję nadać pakiet z serwera do zestawu klientów nasłuchujących dowolnej wiadomości.

Klient zliczy liczbę wiadomości, które otrzyma w ciągu jednej sekundy.

Strona serwera wygląda następująco:

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;

};

Jest inicjowany i uruchamiany w następujący sposób:

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;
}

To (najwyraźniej) działa dobrze. Teraz przychodzi klient ...

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";
    }

Działa to podczas uruchamiania serwera i klienta na tym samym komputerze, ale nie działa, gdy uruchamiam serwer na komputerze innym niż ten, na którym uruchamiam klienta.

Po pierwsze, wydaje mi się dziwne, że muszę rozwiązać adres serwera. Być może nie wiem, jak naprawdę działa transmisja, ale myślałem, że serwer wyśle ​​wiadomość za pomocą gniazda z włączoną opcją emisji i dotrze do wszystkich gniazd w tej samej sieci.

Czytałem, że powinieneś powiązać gniazdo klienta zaddress_v4::any() adres. Zrobiłem to, to nie działa (mówi coś o gnieździe już używającym adresu / portu).

Z góry dziękuję.

PS: Jestem pod Windows 8.