Ich entschuldige mich im Voraus, wenn die Frage bereits beantwortet wurde, aber ich habe nichts gesucht und gefunden, was mir hilft. Wie aus dem Titel der Frage hervorgeht, versuche ich, ein Paket von einem Server an eine Gruppe von Clients zu senden, die auf Nachrichten warten.

Der Client zählt die Anzahl der Nachrichten, die er während einer Sekunde empfängt.

Die Serverseite der Dinge sieht so aus:

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;

};

Es wird folgendermaßen initialisiert und ausgeführt:

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

Dies funktioniert (anscheinend) gut. Nun kommt der Kunde ...

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

Dies funktioniert, wenn sowohl der Server als auch der Client auf demselben Computer ausgeführt werden, nicht jedoch, wenn der Server auf einem Computer ausgeführt wird, der sich von dem unterscheidet, auf dem ich den Client ausgeführt habe.

Als erstes erscheint es mir seltsam, dass ich die Adresse des Servers auflösen muss. Vielleicht weiß ich nicht, wie Broadcasting wirklich funktioniert, aber ich dachte, der Server würde eine Nachricht über seinen Socket mit aktivierter Broadcast-Option senden und sie an alle Sockets im selben Netzwerk senden.

Ich habe gelesen, Sie sollten den Client-Socket an die bindenaddress_v4::any() Adresse. Ich habe es getan, es funktioniert nicht (sagt etwas über einen Socket, der bereits die Adresse / den Port verwendet).

Danke im Voraus.

PS: Ich bin unter Windows 8.