Der Boost-Socket iostreams-Echoserver mit zlib-Komprimierung wird so lange deaktiviert, bis die Verbindung geschlossen wird

Jan 18 2021

Ich versuche, anhand dieses und dieses Beispiels einen einfachen Echoserver mit zlib-Komprimierung zu erstellen .

Meine Idee ist es, jetzt einen String zu senden, da ich POD-Typen std::string(reinterpret_cast<const char *>(&pod), sizeof(pod))vor dem Senden in string ( ) konvertieren kann, wenn ich sicher bin, dass die Transportschicht funktioniert.

Und hier gibt es ein Problem. Der Client komprimiert Daten, sendet sie und sagt, dass Daten gesendet wurden, der Server jedoch beim Lesen der Daten blockiert ist. Ich kann nicht verstehen, warum es passiert.

Ich habe versucht, operator<<mit zu verwenden out.flush(), auch ich habe versucht, zu verwenden boost::iostreams::copy(). Das Ergebnis ist das gleiche. Das Codebeispiel lautet (ich verwende dieselbe Quelldatei für Server und Client, abhängig von den Argumenten):

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

Zuerst starte ich den Server und dann den Client. Die folgende Ausgabe wird erzeugt:

Server

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

Klient

$ ./example sender
sended: hello world

Die Programme werden mit der obigen Ausgabe blockiert. Ich denke, der Server wartet immer noch auf Daten vom Client und weiß nicht, dass der Client alles gesendet hat, was er hatte.

Wenn ich den Client mit schließe, Ctrl + Clautet die Ausgabe wie folgt:

$ ./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

und

$ ./example sender
sended: hello world
^C

Ich denke, das zlib error-5liegt daran, dass der Server das Archiv für unvollständig hält.

Das erwartete Verhalten ist keine Blockierung. Die Meldung muss in der Serverprogrammausgabe erscheinen, wenn der Client gestartet wurde.

Warum ist das Programm beim Lesen blockiert? Wie kann ich es reparieren?

Antworten

1 sehe Jan 18 2021 at 21:56

iostreams::copy macht genau das: es kopiert Stream.

Komplimente zu Ihrem Code. Es ist sehr gut lesbar :) Es erinnert mich an diese Antwort Lesen und Schreiben von Dateien mit Boost-Iostream-Socket . Der Hauptunterschied besteht darin, dass diese Antwort einen einzelnen komprimierten Blob sendet und schließt.

Sie haben "Recht", dass der Dekomprimierer weiß, wann ein komprimierter Block vollständig ist, aber er entscheidet nicht, dass ein anderer nicht folgt.

Sie müssen also einen Rahmen hinzufügen. Der traditionelle Weg ist, eine Länge außerhalb des Bandes zu passieren. Ich habe die Änderungen implementiert und gleichzeitig die Codeduplizierung mithilfe von E / A-Manipulatoren reduziert.

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

Und

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` Manipulator

Dieser kapselt hauptsächlich den Code, den Sie zwischen dem Absender / Empfänger dupliziert haben:

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

Ich habe TVorlagen erstellt, damit sie gespeichert werden können std::string&oder std::string const&je nach Bedarf.

`LengthPrefixed` Manipulator

Diesem Manipulator ist es egal, was serialisiert wird, sondern er wird ihm einfach die effektive Länge auf dem Draht voranstellen:

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

Wir fügen eine Subtilität hinzu: Indem wir eine Referenz oder einen Wert speichern, je nachdem, womit wir konstruiert sind, können wir auch temporäre Werte akzeptieren (wie den ZLIB-Manipulator):

Der Boost-Socket iostreams-Echoserver mit zlib-Komprimierung wird so lange deaktiviert, bis die Verbindung geschlossen wird

Antworten

ZLIB Manipulator

LengthPrefixed Manipulator

DEMO-PROGRAMM

Vollständige Auflistung

`ZLIB` Manipulator

`LengthPrefixed` Manipulator