Comment définir un temps d'arrêt sur les sockets de blocage dans boost asio?

même des années après la question initiale, il n'y a toujours pas de réponse satisfaisante.

L'utilisation manuelle de select n'est pas une bonne option

1. le numéro du descripteur de fichier doit être inférieur à 1024
2. FD peut être signalé comme étant prêt en raison d'un mauvais total de contrôle.

Appel io_service.run_one() est aussi une mauvaise idée, car il peut y avoir d'autres options async qui ont besoin d'un io_service pour toujours run(). Et le document de boost sur le blocage du client tcp est difficile à comprendre.

voici donc ma solution. L'idée clé est la suivante:

{
    Semaphore r_sem;
    boost::system::error_code r_ec;
    boost::asio::async_read(s,buffer,
                            [this, &r_ec, &r_sem](const boost::system::error_code& ec_, size_t) {
                                r_ec=ec_;
                                r_sem.notify();
                            });
    if(!r_sem.wait_for(std::chrono::seconds(3))) // wait for 3 seconds
    {
        s.cancel();
        r_sem.wait();
        throw boost::system::system_error(boost::asio::error::try_again);
    }
    else if(r_ec)
        throw boost::system::system_error(r_ec);
}

Ici Semaphore est juste un mutex et une condition_variable.

wait_for est mis en œuvre par http://en.cppreference.com/w/cpp/thread/condition_variable/wait_for

le code Complet est à https://github.com/scinart/cpplib/blob/master/include/asio.hpp

des Exemples est dans https://github.com/scinart/cpplib/blob/master/test/test_asio.cpp

Le meilleur Exemple à https://github.com/scinart/cpplib/blob/master/test/test_SyncBoostIO.cpp

TL;DR

socket.set_option(boost::asio::detail::socket_option::integer<SOL_SOCKET, SO_RCVTIMEO>{ 200 });

RÉPONSE COMPLÈTE Cette question est posée encore et encore pendant de nombreuses années. Les réponses que j'ai vues jusqu'à présent sont assez pauvres. Je vais ajouter cette info ici, dans l'une des premières occurrences de cette question.

toute personne essayant D'utiliser ASIO pour simplifier son code réseau serait parfaitement heureuse si l'auteur ajoutait simplement un paramètre optionnel timeout à toutes les fonctions de synchronisation et d'asynchrone. Malheureusement, il est peu probable que cela se produise (dans mon humble l'opinion, juste pour des raisons idéologiques, après tout, comme dans ASIO est pour une raison).

voici donc les moyens de dépouiller ce pauvre chat disponible jusqu'à présent, aucun d'eux n'est particulièrement appétissant. Disons qu'il nous faut 200ms de temps mort.

1) Bonne (Mauvaise) ancienne API de socket:

const int timeout = 200;
::setsockopt(socket.native_handle(), SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof timeout);//SO_SNDTIMEO for send ops

veuillez noter ces particularités: - const int pour timeout-sur Windows le type requis est en fait DWORD, mais l'ensemble actuel de compilateurs a heureusement la même chose, donc const int fonctionnera à la fois dans Gagner et Posix monde. - (const char*) pour la valeur. Sur Windows const char* est nécessaire, Posix nécessite const void* en C++ const char* convertir à const void* silencieusement tandis que l'inverse n'est pas vrai.

avantages: fonctionne et fonctionnera probablement toujours car l'API socket est ancienne et stable. Assez Simple. Rapide. Inconvénients: techniquement pourrait exiger des fichiers d'en-tête appropriés (différents sur Win et même différentes saveurs UNIX) pour setsockopt et les macros, mais l'implémentation actuelle de toute façon, ASIO pollue l'Espace-nom mondial avec eux. Nécessite une variable pour timeout. Pas de type sécurisé. Sur Windows, nécessite que la socket soit en mode superposé pour fonctionner (ce que L'implémentation actuelle D'ASIO utilise heureusement, mais c'est toujours un détail d'implémentation). LAID!

2) Personnalisé ASIO option de socket:

typedef boost::asio::detail::socket_option::integer<SOL_SOCKET, SO_RCVTIMEO> rcv_timeout_option; //somewhere in your headers to be used everywhere you need it
//...
socket.set_option(rcv_timeout_option{ 200 });

avantages: assez Simple. Rapide. Belle (avec typedef). Inconvénients: dépend de détails de mise en œuvre ASIO, qui pourrait changer (mais OTOH tout sera il est peu probable que de tels détails changent, alors que les IPA publics peuvent faire l'objet d'une normalisation). Mais au cas où cela se produirait, vous devrez soit écrire un cours selon https://www.boost.org/doc/libs/1_68_0/doc/html/boost_asio/reference/SettableSocketOption.html (qui est bien sûr une PITA majeure grâce à la sur-Ingénierie évidente de cette partie D'ASIO) ou mieux encore revenir à 1.

3) Utiliser C++ async / future installation.

#include <future>
#include <chrono>
//...
auto status = std::async(std::launch::async, [&] (){ /*your stream ops*/ })
    .wait_for(std::chrono::milliseconds{ 200 });
switch (status)
    {
    case std::future_status::deferred:
    //... should never happen with std::launch::async
        break;
    case std::future_status::ready:
    //...
        break;
    case std::future_status::timeout:
    //...
        break;
    }

avantages: standard. Inconvénients: lance toujours un nouveau thread (dans la pratique), qui est relativement lent (pourrait être assez bon pour les clients, mais conduira à la vulnérabilité de DoS pour les serveurs comme les threads et les sockets sont des ressources "coûteuses"). N'essayez pas d'utiliser std::lancement::reporté au lieu de std::lancement::asynchrone pour éviter de nouveau thread lancement wait_for retournera toujours future_status::différé sans essayer d'exécuter le code.

4) La méthode prescrit par ASIO-utiliser des opérations asynchrones seulement (ce qui n'est pas vraiment la réponse à la question).

avantages: assez bon pour les serveurs aussi si l'extensibilité énorme pour les transactions courtes n'est pas nécessaire. Inconvénients: assez verbeux (donc je ne vais même pas inclure d'exemples - voir les exemples D'ASIO). Nécessite une gestion très soigneuse de tous vos objets utilisés par les opérations asynchrones et leurs manipulateurs de complétion, ce qui nécessite en pratique toutes les classes contenant et utilisant de telles données les opérations async sont dérivées de enable_shared_from_this, qui nécessite toutes les classes de ce type allouées sur heap, ce qui signifie (au moins pour les opérations courtes) que l'évolutivité commencera à diminuer après environ 16 threads car chaque alloc/dealloc de heap utilisera une barrière de mémoire.

vous pouvez envelopper les appels synchrones dans des contrats à terme et attendre qu'ils soient complétés par un timeout (wait_timeout).

http://www.boost.org/doc/libs/1_47_0/doc/html/thread/synchronization.html#thread.synchronization.futures

certainement pas une taille unique convient à tous, mais fonctionne bien pour par exemple contourner les délais de connexion lente.

Sur *nix, il vous suffit d'utiliser l'alarme (le) de sorte que votre prise d'appel échoue avec EINTR