tcp_connection.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_TCP_CONNECTION_HPP
#define STATICLIB_PION_TCP_CONNECTION_HPP

#include <array>
#include <functional>
#include <memory>
#include <string>

#include "asio.hpp"
#include "asio/ssl.hpp"

#include "staticlib/config.hpp"

#include "staticlib/pion/algorithm.hpp"

namespace staticlib { 
namespace pion {

class tcp_connection : public std::enable_shared_from_this<tcp_connection> {

public:

    enum class lifecycle {
        close, 
        keepalive, 
        pipelined
    };

    using connection_handler = std::function<void(std::shared_ptr<tcp_connection>&)>;

    using read_buffer_type = std::array<char, 8192>;

    using socket_type = asio::ip::tcp::socket;

    using ssl_socket_type = asio::ssl::stream<asio::ip::tcp::socket>;

    using ssl_context_type = asio::ssl::context;

private:

    ssl_socket_type ssl_socket;

    bool ssl_flag;

    read_buffer_type read_buffer;

    std::pair<const char*, const char*> read_position;

    lifecycle current_lifecycle;

    connection_handler finished_handler;

    asio::io_service::strand strand;

    asio::steady_timer timer;

public:

    tcp_connection(asio::io_service& io_service, ssl_context_type& ssl_context, const bool ssl_flag_in,
            connection_handler finished_handler_in) :
    ssl_socket(io_service, ssl_context), 
    ssl_flag(ssl_flag_in),
    current_lifecycle(lifecycle::close),
    finished_handler(finished_handler_in),
    strand(io_service),
    timer(io_service) {
        save_read_pos(nullptr, nullptr);
    }

    tcp_connection(const tcp_connection&) = delete;

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

    virtual ~tcp_connection() {
        close();
    }

    bool is_open() const {
        return const_cast<ssl_socket_type&> (ssl_socket).lowest_layer().is_open();
    }

    void close() {
        if (is_open()) {
            try {
                // shutting down SSL will wait forever for a response from the remote end,
                // which causes it to hang indefinitely if the other end died unexpectedly
                // if (get_ssl_flag()) ssl_socket.shutdown();

                // windows seems to require this otherwise it doesn't
                // recognize that connections have been closed
                ssl_socket.next_layer().shutdown(asio::ip::tcp::socket::shutdown_both);
            } catch (...) {
            } // ignore exceptions

            // close the underlying socket (ignore errors)
            std::error_code ec;
            ssl_socket.next_layer().close(ec);
        }
    }

    void cancel() {
        // there is no good way to do this on windows until vista or later (0x0600)
        // http://www.boost.org/doc/libs/1_53_0/doc/html/boost_asio/reference/basic_stream_socket/cancel/overload2.html
        // note that the asio docs are misleading because close() is not thread-safe,
        // and the suggested #define statements cause WAY too much trouble and heartache
        #if !defined(_MSC_VER) || (_WIN32_WINNT >= 0x0600)
            std::error_code ec;
            ssl_socket.next_layer().cancel(ec);
        #endif // !WINXP
    }

    void cancel_timer() {
        #if !defined(_MSC_VER) || (_WIN32_WINNT >= 0x0600)
            std::error_code ec;
            timer.cancel(ec);
        #endif // !WINXP
    }

    template <typename AcceptHandler>
    void async_accept(asio::ip::tcp::acceptor& tcp_acceptor, AcceptHandler handler) {
        tcp_acceptor.async_accept(ssl_socket.lowest_layer(), handler);
    }

    template <typename SSLHandshakeHandler>
    void async_handshake_server(SSLHandshakeHandler handler) {
        ssl_socket.async_handshake(asio::ssl::stream_base::server, handler);
        ssl_flag = true;
    }

    template <typename ReadHandler>
    void async_read_some(ReadHandler handler) {
        if (get_ssl_flag()) {
            ssl_socket.async_read_some(asio::buffer(read_buffer), handler);
        } else {
            ssl_socket.next_layer().async_read_some(asio::buffer(read_buffer), handler);
        }
    }

    template <typename ConstBufferSequence, typename write_handler_t>
    void async_write(const ConstBufferSequence& buffers, write_handler_t handler) {
        if (get_ssl_flag()) {
            asio::async_write(ssl_socket, buffers, handler);
        } else {
            asio::async_write(ssl_socket.next_layer(), buffers, handler);
        }
    }

    void finish() {
        auto conn = shared_from_this();
        if (finished_handler) {
            finished_handler(conn);
        }
    }

    bool get_ssl_flag() const {
        return ssl_flag;
    }

    void set_lifecycle(lifecycle lcycle) {
        current_lifecycle = lcycle;
    }

    bool get_keep_alive() const {
        return current_lifecycle != lifecycle::close;
    }

    bool is_pipelined() const {
        return current_lifecycle == lifecycle::pipelined;
    }

    read_buffer_type& get_read_buffer() {
        return read_buffer;
    }

    void save_read_pos(const char *read_ptr, const char *read_end_ptr) {
        read_position.first = read_ptr;
        read_position.second = read_end_ptr;
    }

    void load_read_pos(const char *&read_ptr, const char *&read_end_ptr) const {
        read_ptr = read_position.first;
        read_end_ptr = read_position.second;
    }

    asio::ip::tcp::endpoint get_remote_endpoint() const {
        asio::ip::tcp::endpoint remote_endpoint;
        try {
            // const_cast is required since lowest_layer() is only defined non-const in asio
            remote_endpoint = const_cast<ssl_socket_type&> (ssl_socket).lowest_layer().remote_endpoint();
        } catch (asio::system_error& /* e */) {
            // do nothing
        }
        return remote_endpoint;
    }

    asio::ip::address get_remote_ip() const {
        return get_remote_endpoint().address();
    }

    unsigned short get_remote_port() const {
        return get_remote_endpoint().port();
    }

    asio::io_service& get_io_service() {
        return ssl_socket.lowest_layer().get_io_service();
    }

    socket_type& get_socket() {
        return ssl_socket.next_layer();
    }

    ssl_socket_type& get_ssl_socket() {
        return ssl_socket;
    }

    asio::io_service::strand& get_strand() {
        return strand;
    }

    asio::steady_timer& get_timer() {
        return timer;
    }

};

using tcp_connection_ptr = std::shared_ptr<tcp_connection>;

} // namespace
}

#endif // STATICLIB_PION_TCP_CONNECTION_HPP