boost soket iostreams echo sunucusu, zlib sıkıştırmalı bağlantı kapanana kadar uyur

Jan 18 2021

Aşağıdaki zlib sıkıştırma ile basit yankı sunucusu oluşturmaya çalışın bu ve bu örnekler.

Benim fikrim şimdi bazı dizeler göndermek çünkü POD türlerini std::string(reinterpret_cast<const char *>(&pod), sizeof(pod))göndermeden önce taşıma katmanının çalıştığından emin olacağım zaman string ( ) ' e dönüştürebilirim .

Ve burada bir sorun var. İstemci verileri sıkıştırır, gönderir ve verilerin gönderildiğini söyler, ancak sunucu veri okumada engellenir. Neden olduğunu anlayamıyorum.

Ben kullanmaya çalıştı operator<<ile out.flush()de ben kullanmaya çalıştı, boost::iostreams::copy(). Sonuç aynı. Kod örneği (argümanlara bağlı olarak sunucu ve istemci için aynı kaynak dosyasını kullanıyorum):

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

Önce sunucuyu ve ardından istemciyi başlatırım. Aşağıdaki çıktı üretilir:

Sunucu

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

Müşteri

$ ./example sender
sended: hello world

Programlar yukarıdaki çıktıyla bloke edilir. Sanırım sunucu hala istemciden gelen verileri bekliyor ve istemcinin elindekileri gönderdiğini bilmiyor.

İstemciyi kapatırsam Ctrl + Cçıktı şu olur:

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

Sanırım bunun zlib error-5nedeni sunucunun arşivin eksik olduğunu düşünmesi.

Beklenen davranış engelleme değildir. Mesaj, istemci başlatıldığında sunucu programı çıktısında görünmelidir.

Program okuma konusunda neden engelleniyor? Nasıl düzeltebilirim?

Yanıtlar

1 sehe Jan 18 2021 at 21:56

iostreams::copy sadece bunu yapar: akışı kopyalar.

Kodunuza iltifat. Çok okunabilir :) Bana bu cevabı hatırlatıyor iostream soketi ile dosya okuma ve yazma . Temel fark, bu yanıtın tek bir sıkıştırılmış blob göndermesi ve kapanmasıdır.

Dekompresörün sıkıştırılmış bir bloğun ne zaman tamamlandığını bildiği konusunda "haklısınız", ancak diğerinin takip etmeyeceğine karar vermiyor.

Yani çerçeveleme eklemeniz gerekiyor. Geleneksel yöntem, bant dışı bir uzunluk geçirmektir. IO manipülatörlerini kullanarak kod çoğaltmasını azaltırken değişiklikleri uyguladım.

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` manipülatör

Bu, esas olarak gönderen / alıcı arasında kopyaladığınız kodu kapsüller:

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

Ben yapılan Tbu saklayabilirsiniz böylece şablon std::string&veya std::string const&ihtiyaca göre.

`LengthPrefixed` manipülatör

Bu manipülatör, neyin serileştirildiğini umursamıyor, ancak basitçe tel üzerinde etkin uzunluk ile ön ekleyecektir:

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

Bir incelik ekliyoruz: Neyle inşa edildiğimize bağlı olarak bir referans veya değer saklayarak geçicileri de kabul edebiliriz (ZLIB manipülatörü gibi):

boost soket iostreams echo sunucusu, zlib sıkıştırmalı bağlantı kapanana kadar uyur

Yanıtlar

ZLIB manipülatör

LengthPrefixed manipülatör

DEMO PROGRAMI

Tam Liste

`ZLIB` manipülatör

`LengthPrefixed` manipülatör