Boost socket iostreams echo server avec compression zlib se met en veille jusqu'à ce que la connexion soit fermée

Jan 18 2021

J'essaie de créer un serveur d'écho simple avec une compression zlib en suivant ceci et ces exemples.

Mon idée est d'envoyer une chaîne maintenant car je peux convertir les types POD en string ( std::string(reinterpret_cast<const char *>(&pod), sizeof(pod))) avant d'envoyer quand je serai sûr que la couche de transport fonctionne.

Et il y a un problème ici. Le client compresse les données, les envoie et dit que les données ont été envoyées mais que le serveur est bloqué lors de la lecture des données. Je ne comprends pas pourquoi cela arrive.

J'ai essayé d'utiliser operator<<avec out.flush(), j'ai également essayé d'utiliser boost::iostreams::copy(). Le résultat est le même. L'exemple de code est (j'utilise le même fichier source pour le serveur et le client en fonction des arguments):

#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/zlib.hpp>
#include <boost/iostreams/copy.hpp>
#include <boost/asio.hpp>

#include <iostream>
#include <sstream>

namespace ip = boost::asio::ip;
using ip::tcp;

const unsigned short port = 9999;
const char host[] = "127.0.0.1";

void receive()
{
    boost::asio::io_context ctx;
    tcp::endpoint ep(ip::address::from_string(host), port);
    tcp::acceptor a(ctx, ep);

    tcp::iostream stream;
    a.accept(stream.socket());

    std::stringstream buffer;

    std::cout << "start session" << std::endl;

    try
    {
        for (;;)
        {
            {
                boost::iostreams::filtering_istream in;
                in.push(boost::iostreams::zlib_decompressor());
                in.push(stream);

                std::cout << "start reading" << std::endl;

                // looks like server is blocked here
                boost::iostreams::copy(in, buffer);
            }

            std::cout << "data: " << buffer.str() << std::endl;

            {
                boost::iostreams::filtering_ostream out;
                out.push(boost::iostreams::zlib_compressor());
                out.push(stream);

                boost::iostreams::copy(buffer, out);
            }

            std::cout << "Reply is sended" << std::endl;
        }
    }
    catch(const boost::iostreams::zlib_error &e)
    {
        std::cerr << e.what() << e.error() << '\n';
        stream.close();
    }
}

void send(const std::string &data)
{
    tcp::endpoint ep(ip::address::from_string(host), port);
    
    tcp::iostream stream;
    stream.connect(ep);

    std::stringstream buffer;
    buffer << data;

    if (!stream)
    {
        std::cerr << "Cannot connect to " << host << ":" << port << std::endl;
        return;
    }

    try
    {
        {
            boost::iostreams::filtering_ostream out;
            out.push(boost::iostreams::zlib_compressor());
            out.push(stream);

            out << buffer.str();
            out.flush();
        }

        std::cout << "sended: " << data << std::endl;
        buffer.str("");

        {
            boost::iostreams::filtering_istream in;
            in.push(boost::iostreams::zlib_decompressor());
            in.push(stream);

            // looks like client is blocked here
            boost::iostreams::copy(in, buffer);
        }

        std::cout << "result: " << buffer.str() << std::endl;
    }
    catch(const boost::iostreams::zlib_error &e)
    {
        std::cerr << e.what() << '\n';
    }
}

int main(int argc, const char *argv[])
{
    if (argc > 1 && argv[1] ==  std::string("sender"))
        send("hello world");
    else
        receive();

    return 0;
}

Je démarre d'abord le serveur, puis je démarre le client. La sortie suivante est produite:

Serveur

$ ./example
# now it waits while client will be accepted
start session
start reading

Client

$ ./example sender
sended: hello world

Les programmes sont bloqués avec la sortie ci-dessus. Je suppose que le serveur attend toujours les données du client et il ne sait pas que le client a envoyé tout ce qu'il avait.

Si je ferme le client avec, Ctrl + Cla sortie est la suivante:

$ ./example
# now it waits while client will be accepted
start session
start reading
# now it is blocked until I press Ctrl + C
data: hello world
Reply is sended
start reading
zlib error-5

$ ./example sender
sended: hello world
^C

Je suppose que zlib error-5c'est parce que le serveur pense que l'archive est incomplète.

Le comportement attendu n'est pas de blocage. Le message doit apparaître dans la sortie du programme serveur lors du démarrage du client.

Pourquoi le programme est-il bloqué à la lecture? Comment puis-je résoudre ce problème?

Réponses

1 sehe Jan 18 2021 at 21:56

iostreams::copy fait exactement cela: il copie le flux.

Compliments à votre code. C'est très lisible :) Cela me rappelle cette réponse Lire et écrire des fichiers avec le socket iostream boost . La principale différence est que cette réponse envoie un seul blob compressé et se ferme.

Vous avez "raison" que le décompresseur sait quand un bloc compressé est terminé, mais il ne décide pas qu'un autre ne suivra pas.

Vous devez donc ajouter un cadrage. La manière traditionnelle est de passer une longueur hors bande. J'ai implémenté les modifications tout en réduisant la duplication de code en utilisant des manipulateurs IO.

template <typename T> struct LengthPrefixed {
    T _wrapped;

    friend std::ostream& operator<<(std::ostream& os, LengthPrefixed lp) ;
    friend std::istream& operator>>(std::istream& is, LengthPrefixed lp) ;
};

template <typename T> struct ZLIB {
    T& data;
    ZLIB(T& ref) : data(ref){}

    friend std::ostream& operator<<(std::ostream& os, ZLIB z) ;
    friend std::istream& operator>>(std::istream& is, ZLIB z) ;
};

`ZLIB` manipulateur

Celui-ci encapsule principalement le code que vous avez dupliqué entre l'expéditeur / destinataire:

template <typename T> struct ZLIB {
    T& data;
    ZLIB(T& ref) : data(ref){}

    friend std::ostream& operator<<(std::ostream& os, ZLIB z) {
        {
            boost::iostreams::filtering_ostream out;
            out.push(boost::iostreams::zlib_compressor());
            out.push(os);
            out << z.data << std::flush;
        }
        return os.flush();
    }

    friend std::istream& operator>>(std::istream& is, ZLIB z) {
        boost::iostreams::filtering_istream in;
        in.push(boost::iostreams::zlib_decompressor());
        in.push(is);

        std::ostringstream oss;
        copy(in, oss);
        z.data = oss.str();

        return is;
    }
};

J'ai fait des Tmodèles pour qu'il puisse stocker std::string&ou en std::string const&fonction des besoins.

`LengthPrefixed` manipulateur

Ce manipulateur ne se soucie pas de ce qui est sérialisé, mais le préfixera simplement avec la longueur effective sur le fil:

template <typename T> struct LengthPrefixed {
    T _wrapped;

    friend std::ostream& operator<<(std::ostream& os, LengthPrefixed lp) {
        std::ostringstream oss;
        oss << lp._wrapped;
        auto on_the_wire = std::move(oss).str();

        debug << "Writing length " << on_the_wire.length() << std::endl;
        return os << on_the_wire.length() << "\n" << on_the_wire << std::flush;
    }

    friend std::istream& operator>>(std::istream& is, LengthPrefixed lp) {
        size_t len;
        if (is >> std::noskipws >> len && is.ignore(1, '\n')) {
            debug << "Reading length " << len << std::endl;

            std::string on_the_wire(len, '\0');
            if (is.read(on_the_wire.data(), on_the_wire.size())) {
                std::istringstream iss(on_the_wire);
                iss >> lp._wrapped;
            }
        }
        return is;
    }
};

On ajoute une subtilité: en stockant une référence ou une valeur en fonction de ce avec quoi on est construit on peut aussi accepter des temporaires (comme le manipulateur ZLIB):

Boost socket iostreams echo server avec compression zlib se met en veille jusqu'à ce que la connexion soit fermée

Réponses

ZLIB manipulateur

LengthPrefixed manipulateur

PROGRAMME DE DÉMO

Liste complète

`ZLIB` manipulateur

`LengthPrefixed` manipulateur