http_response_writer.hpp

Go to the documentation of this file.

/*
 * Copyright 2015, alex at staticlibs.net
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// ---------------------------------------------------------------------
// pion:  a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc.  (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//

#ifndef STATICLIB_PION_HTTP_RESPONSE_WRITER_HPP
#define STATICLIB_PION_HTTP_RESPONSE_WRITER_HPP

#include <functional>
#include <list>
#include <memory>
#include <string>
#include <vector>

#include "asio.hpp"

#include "staticlib/config.hpp"
#include "staticlib/io/span.hpp"

#include "staticlib/pion/logger.hpp"
#include "staticlib/pion/http_message.hpp"
#include "staticlib/pion/http_response.hpp"
#include "staticlib/pion/tcp_connection.hpp"

namespace staticlib { 
namespace pion {

class http_response_writer {
    tcp_connection_ptr tcp_conn;

    std::vector<asio::const_buffer> content_buffers;

    std::vector<std::unique_ptr<char[]>> payload_cache;

    size_t content_length;

    bool client_supports_chunks;

    bool sending_chunks;

    bool sent_headers;

    std::unique_ptr<http_response> response;

    std::string response_line;

public:

    http_response_writer(tcp_connection_ptr& tcp_conn, const http_request& http_request) :
    tcp_conn(tcp_conn),
    content_length(0),
    client_supports_chunks(true),
    sending_chunks(false),
    sent_headers(false),
    response(new http_response(http_request)) {
        // set whether or not the client supports chunks
        supports_chunked_messages(response->get_chunks_supported());
    }

    http_response_writer(const http_response_writer&) = delete;

    http_response_writer& operator=(const http_response_writer&) = delete;

    http_response& get_response() {
        return *response;
    }

    void clear() {
        content_buffers.clear();
        payload_cache.clear();
        content_length = 0;
    }

    void write(sl::io::span<const char> data) {
        if (response->is_body_allowed() && data.size() > 0) {
            content_buffers.push_back(add_to_cache(data));
            content_length += data.size();
        }
    }

    void write_nocopy(sl::io::span<const char> data) {
        if (response->is_body_allowed() && data.size() > 0) {
            content_buffers.push_back(asio::buffer(data.data(), data.size()));
            content_length += data.size();
        }
    }

    static void send(std::unique_ptr<http_response_writer> self) {
        auto self_ptr = self.get();
        auto self_shared = sl::support::make_shared_with_release_deleter(self.release());
        self_ptr->send_more_data(false,
            [self_shared](const std::error_code& ec, std::size_t bt) { 
                auto self = sl::support::make_unique_from_shared_with_release_deleter(self_shared);
                if (nullptr != self.get()) {
                    handle_write(std::move(self), ec, bt); 
                } else {
                    STATICLIB_PION_LOG_WARN("staticlib.pion.http_response_writer",
                            "Lost context detected in 'async_write'");
                }
            });
    }

    template <typename SendHandler> void send_chunk(SendHandler send_handler) {
        sending_chunks = true;
        if (!supports_chunked_messages()) {
            // sending data in chunks, but the client does not support chunking;
            // make sure that the connection will be closed when we are all done
            tcp_conn->set_lifecycle(tcp_connection::lifecycle::close);
        }
        // make sure that we did not lose the TCP connection
        if (tcp_conn->is_open()) {
            // send more data
            send_more_data(false, send_handler);
        } else {
            tcp_conn->finish();
        }
    }

    static void send_final_chunk(std::unique_ptr<http_response_writer> self) {
        self->sending_chunks = true;
        auto self_ptr = self.get();
        auto self_shared = sl::support::make_shared_with_release_deleter(self.release());
        self_ptr->send_more_data(true,
            [self_shared](const std::error_code& ec, std::size_t bt) { 
                auto self = sl::support::make_unique_from_shared_with_release_deleter(self_shared);
                if (nullptr != self.get()) {
                    handle_write(std::move(self), ec, bt); 
                } else {
                    STATICLIB_PION_LOG_WARN("staticlib.pion.http_response_writer",
                            "Lost context detected in 'async_write' final");
                }
            });
    }

    tcp_connection_ptr& get_connection() {
        return tcp_conn;
    }

    size_t get_content_length() const {
        return content_length;
    }

    void supports_chunked_messages(bool b) {
        client_supports_chunks = b;
    }

    bool supports_chunked_messages() const {
        return client_supports_chunks;
    }

    bool sending_chunked_message() const {
        return sending_chunks;
    }

private:

    void prepare_buffers_for_send(std::vector<asio::const_buffer>& write_buffers) {
        if (get_content_length() > 0) {
            response->set_content_length(get_content_length());
        }
        response->prepare_buffers_for_send(write_buffers, get_connection()->get_keep_alive(),
                sending_chunked_message());
    }

    static void handle_write(std::unique_ptr<http_response_writer> self,
            const std::error_code& ec, std::size_t bytes_written) {
        if (!ec) {
            // response sent OK
            if (self->sending_chunked_message()) {
                STATICLIB_PION_LOG_DEBUG("staticlib.pion.http_response_writer",
                        "Sent HTTP response chunk of " << bytes_written << " bytes");
            } else {
                STATICLIB_PION_LOG_DEBUG("staticlib.pion.http_response_writer",
                        "Sent HTTP response of " << bytes_written << " bytes ("
                        << (self->get_connection()->get_keep_alive() ? "keeping alive)" : "closing)"));
            }
        }
        self->tcp_conn->finish();
    }

    template <typename SendHandler>
    void send_more_data(const bool send_final_chunk, SendHandler send_handler) {
        // make sure that we did not lose the TCP connection
        if (tcp_conn->is_open()) {
            // make sure that the content-length is up-to-date
            // prepare the write buffers to be sent
            auto write_buffers = std::vector<asio::const_buffer>();
            prepare_write_buffers(write_buffers, send_final_chunk);
            // send data in the write buffers
            auto send_handler_stranded = tcp_conn->get_strand().wrap(send_handler);
            tcp_conn->async_write(write_buffers, send_handler_stranded);
        } else {
            tcp_conn->finish();
        }
    }

    void prepare_write_buffers(std::vector<asio::const_buffer>& write_buffers, 
            const bool send_final_chunk) {
        // check if the HTTP headers have been sent yet
        if (! sent_headers) {
            // initialize write buffers for send operation
            prepare_buffers_for_send(write_buffers);

            // only send the headers once
            sent_headers = true;
        }

        // combine I/O write buffers (headers and content) so that everything
        // can be sent together; otherwise, we would have to send headers
        // and content separately, which would not be as efficient

        // don't send anything if there is no data in content buffers
        if (content_length > 0) {
            if (supports_chunked_messages() && sending_chunked_message()) {
                // prepare the next chunk of data to send
                // write chunk length in hex
                auto cast_buf = std::array<char, 35>();
                #ifdef _WIN32
                auto written = sprintf_s(cast_buf.data(), cast_buf.size(), "%lx", static_cast<long>(content_length));
                #else // !WIN32
                auto written = sprintf(cast_buf.data(), "%lx", static_cast<long>(content_length));
                #endif // WIN32

                // add chunk length as a string at the back of the text cache
                // append length of chunk to write_buffers
                write_buffers.push_back(add_to_cache({cast_buf.data(), written}));
                // append an extra CRLF for chunk formatting
                write_buffers.push_back(asio::buffer(http_message::STRING_CRLF));

                // append response content buffers
                write_buffers.insert(write_buffers.end(), content_buffers.begin(),
                                     content_buffers.end());
                // append an extra CRLF for chunk formatting
                write_buffers.push_back(asio::buffer(http_message::STRING_CRLF));
            } else {
                // append response content buffers
                write_buffers.insert(write_buffers.end(), content_buffers.begin(),
                                     content_buffers.end());
            }
        }

        // prepare a zero-byte (final) chunk
        if (send_final_chunk && supports_chunked_messages() && sending_chunked_message()) {
            // add chunk length as a string at the back of the text cache
            char zero = '0';
            // append length of chunk to write_buffers
            write_buffers.push_back(add_to_cache({std::addressof(zero), 1}));
            // append an extra CRLF for chunk formatting
            write_buffers.push_back(asio::buffer(http_message::STRING_CRLF));
            write_buffers.push_back(asio::buffer(http_message::STRING_CRLF));
        }
    }

    asio::const_buffer add_to_cache(sl::io::span<const char> data) {
        payload_cache.emplace_back(new char[data.size()]);
        char* dest = payload_cache.back().get();
        std::memcpy(dest, data.data(), data.size());
        return asio::buffer(dest, data.size());
    }
};

using response_writer_ptr = std::unique_ptr<http_response_writer>;

} // namespace
}

#endif // STATICLIB_PION_HTTP_RESPONSE_WRITER_HPP