Как создать boost ssl iostream?

Предложение @Guy (с использованием boost::asio::streambuf) должно работать, и его, вероятно, проще всего реализовать. Главный недостаток такого подхода заключается в том, что все, что вы пишете в iostream, будет буферизоваться в памяти до конца, когда вызов boost::asio::write() сразу выгрузит все содержимое буфера в поток ssl. (Я должен отметить, что во многих случаях такая буферизация может быть желательна, и в вашем случае, вероятно, это не имеет никакого значения, поскольку вы сказали, что это приложение с небольшим объемом).

Если это всего лишь «разовый», я бы, вероятно, реализовал его, используя подход @Guy.

При этом есть ряд веских причин, по которым вы могли бы предпочесть решение, позволяющее использовать вызовы iostream для записи непосредственно в файл ssl_stream. Если вы обнаружите, что это так, вам нужно будет создать свой собственный класс-оболочку, который расширяет std::streambuf, переопределяет overflow() и sync() (и, возможно, другие, в зависимости от ваших потребностей).

К счастью, boost::iostreams предоставляет относительно простой способ чтобы сделать это без необходимости возиться со стандартными классами напрямую. Вы просто создаете свой собственный класс, реализующий соответствующий Device контракт. В данном случае это Sink, и класс boost::iostreams::sink предоставляется как удобный способ пройти большую часть пути. Когда у вас есть новый класс Sink, который инкапсулирует процесс записи в ваш базовый ssl_stream, все, что вам нужно сделать, это создать boost::iostreams::stream, шаблон которого соответствует вашему новому типу устройства, и вперед.

Это будет выглядеть примерно так (этот пример адаптирован из здесь, см. также эту связанную публикацию о stackoverflow) :

//---this should be considered to be "pseudo-code", 
//---it has not been tested, and probably won't even compile
//---

#include <boost/iostreams/concepts.hpp>
// other includes omitted for brevity ...

typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> ssl_stream;

class ssl_iostream_sink : public sink {
public:
    ssl_iostream_sink( ssl_stream *theStream )
    {
        stream = theStream;
    }

    std::streamsize write(const char* s, std::streamsize n)
    {
        // Write up to n characters to the underlying 
        // data sink into the buffer s, returning the 
        // number of characters written

        boost::asio::write(*stream, boost::asio::buffer(s, n));
    }
private:
    ssl_stream *stream;
};

Теперь ваш цикл приема может измениться и выглядеть примерно так:

for(;;)
{
    // Accept connection                                                                                            
    ssl_stream stream(io_service, context);
    tcp::endpoint peer_endpoint;
    acceptor.accept(stream.lowest_layer(), peer_endpoint);
    boost::system::error_code ec;
    stream.handshake(boost::asio::ssl::stream_base::server, ec);


    if (!ec) {

        // wrap the ssl stream with iostream
        ssl_iostream_sink my_sink(&stream);
        boost::iostream::stream<ssl_iostream_sink> iostream_object(my_sink);

        // Now it works the way you want...
        iostream_object << HTTPReply(200, "Okely-Dokely\n") << std::flush;
    }
}

Этот подход подключает поток ssl к инфраструктуре iostream. Так что теперь вы должны быть в состоянии сделать что-нибудь с iostream_object в приведенном выше примере, что вы обычно делаете с любым другим std::ostream (например, stdout). И то, что вы на него напишете, будет записано в ssl_stream за кулисами. Iostreams имеет встроенную буферизацию, поэтому некоторая степень буферизации будет иметь место внутри — но это хорошо — он будет буферизовать до тех пор, пока не накопит разумный объем данных, затем он выгрузит их в поток ssl и вернуться к буферизации. Последний std::flush, должен принудительно очистить буфер в ssl_stream.

Если вам нужно больше контроля над внутренней буферизацией (или любыми другими дополнительными функциями), взгляните на другие интересные функции, доступные в boost::iostreams. В частности, вы можете начать с просмотра stream_buffer.

Удачи!

Я думаю, что вы хотите использовать буферы потока (asio::streambuf)

Затем вы можете сделать что-то вроде (следует непроверенный код, написанный на лету):

boost::asio::streambuf msg;
std::ostream msg_stream(&msg);
msg_stream << "hello world";
msg_stream.flush();
boost::asio::write(stream, msg);

Точно так же ваша сторона чтения/получения может считывать в буфер потока в сочетании с std::istream, чтобы вы могли обрабатывать свой ввод, используя различные функции/операторы потока.

справочник по Asio для streambuf

Еще одно замечание: я думаю, вам следует ознакомиться с учебниками/примерами asio. Как только вы это сделаете, вы, вероятно, захотите изменить свой код, чтобы он работал асинхронно, а не в синхронном примере, который вы показали выше.

ssl::stream можно обернуть с помощью boost::iostreams/bidirectional, чтобы имитировать поведение, аналогичное tcp::iostream. сброса вывода перед дальнейшим чтением кажется, что нельзя избежать.

#include <regex>
#include <string>
#include <iostream>
#include <boost/iostreams/stream.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>

namespace bios = boost::iostreams;
namespace asio = boost::asio;
namespace ssl = boost::asio::ssl;

using std::string;
using boost::asio::ip::tcp;
using boost::system::system_error;
using boost::system::error_code;

int parse_url(const std::string &s,
    std::string& proto, std::string& host, std::string& path)
{
    std::smatch m;
    bool found = regex_search(s, m, std::regex("^(http[s]?)://([^/]*)(.*)$"));
    if (m.size() != 4)
        return -1;
    proto = m[1].str();
    host = m[2].str();
    path = m[3].str();
    return 0;
}

void get_page(std::iostream& s, const string& host, const string& path)
{ 
    s << "GET " <<  path << " HTTP/1.0\r\n"
        << "Host: " << host << "\r\n"
        << "Accept: */*\r\n"
        << "Connection: close\r\n\r\n" << std::flush;

    std::cout << s.rdbuf() << std::endl;;
}

typedef ssl::stream<tcp::socket> ssl_socket;
class ssl_wrapper : public bios::device<bios::bidirectional>
{
    ssl_socket& sock;
public:
    typedef char char_type;

    ssl_wrapper(ssl_socket& sock) : sock(sock) {}

    std::streamsize read(char_type* s, std::streamsize n) {
        error_code ec;          
        auto rc = asio::read(sock, asio::buffer(s,n), ec);
        return rc;
    }
    std::streamsize write(const char_type* s, std::streamsize n) {
        return asio::write(sock, asio::buffer(s,n));
    }
};

int main(int argc, char* argv[])
{
    std::string proto, host, path;
    if (argc!= 2 || parse_url(argv[1], proto, host, path)!=0)
        return EXIT_FAILURE;
    try {
        if (proto != "https") {
            tcp::iostream s(host, proto);
            s.expires_from_now(boost::posix_time::seconds(60));
            get_page(s, host, path);
        } else {
            asio::io_service ios;

            tcp::resolver resolver(ios);
            tcp::resolver::query query(host, "https");
            tcp::resolver::iterator endpoint_iterator = 
               resolver.resolve(query);

            ssl::context ctx(ssl::context::sslv23);
            ctx.set_default_verify_paths();
            ssl_socket socket(ios, ctx);

            asio::connect(socket.lowest_layer(), endpoint_iterator);

            socket.set_verify_mode(ssl::verify_none);
            socket.set_verify_callback(ssl::rfc2818_verification(host));
            socket.handshake(ssl_socket::client);

            bios::stream<ssl_wrapper> ss(socket);
            get_page(ss, host, path);
        }
    } catch (const std::exception& e) {
        std::cout << "Exception: " << e.what() << "\n";
    }
}