connection.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014, Peter Thorson. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the WebSocket++ Project nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
 
#ifndef WEBSOCKETPP_TRANSPORT_IOSTREAM_CON_HPP
#define WEBSOCKETPP_TRANSPORT_IOSTREAM_CON_HPP
 
#include <websocketpp/transport/iostream/base.hpp>
 
#include <websocketpp/transport/base/connection.hpp>
 
#include <websocketpp/uri.hpp>
 
#include <websocketpp/logger/levels.hpp>
 
#include <websocketpp/common/connection_hdl.hpp>
#include <websocketpp/common/memory.hpp>
#include <websocketpp/common/platforms.hpp>
 
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
namespace websocketpp {
namespace transport {
namespace iostream {
 
struct timer {
    void cancel() {}
};
 
template <typename config>
class connection : public lib::enable_shared_from_this< connection<config> > {
public:
    typedef connection<config> type;
    typedef lib::shared_ptr<type> ptr;
 
    typedef typename config::concurrency_type concurrency_type;
    typedef typename config::alog_type alog_type;
    typedef typename config::elog_type elog_type;
 
    // Concurrency policy types
    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
    typedef typename concurrency_type::mutex_type mutex_type;
 
    typedef lib::shared_ptr<timer> timer_ptr;
 
    explicit connection(bool is_server, alog_type & alog, elog_type & elog)
      : m_output_stream(NULL)
      , m_reading(false)
      , m_is_server(is_server)
      , m_is_secure(false)
      , m_alog(alog)
      , m_elog(elog)
      , m_remote_endpoint("iostream transport")
    {
        m_alog.write(log::alevel::devel,"iostream con transport constructor");
    }
 
    ptr get_shared() {
        return type::shared_from_this();
    }
 
 
    void register_ostream(std::ostream * o) {
        // TODO: lock transport state?
        scoped_lock_type lock(m_read_mutex);
        m_output_stream = o;
    }
 
 
    void set_uri(uri_ptr) {}
 
 
    friend std::istream & operator>> (std::istream & in, type & t) {
        // this serializes calls to external read.
        scoped_lock_type lock(t.m_read_mutex);
 
        t.read(in);
 
        return in;
    }
 
 
    size_t read_some(char const * buf, size_t len) {
        // this serializes calls to external read.
        scoped_lock_type lock(m_read_mutex);
 
        return this->read_some_impl(buf,len);
    }
 
 
    size_t read_all(char const * buf, size_t len) {
        // this serializes calls to external read.
        scoped_lock_type lock(m_read_mutex);
 
        size_t total_read = 0;
        size_t temp_read = 0;
 
        do {
            temp_read = this->read_some_impl(buf+total_read,len-total_read);
            total_read += temp_read;
        } while (temp_read != 0 && total_read < len);
 
        return total_read;
    }
 
 
    size_t readsome(char const * buf, size_t len) {
        return this->read_some(buf,len);
    }
 
 
    void eof() {
        // this serializes calls to external read.
        scoped_lock_type lock(m_read_mutex);
 
        if (m_reading) {
            complete_read(make_error_code(transport::error::eof));
        }
    }
 
 
    void fatal_error() {
        // this serializes calls to external read.
        scoped_lock_type lock(m_read_mutex);
 
        if (m_reading) {
            complete_read(make_error_code(transport::error::pass_through));
        }
    }
 
 
    void set_secure(bool value) {
        m_is_secure = value;
    }
 
 
    bool is_secure() const {
        return m_is_secure;
    }
 
 
    void set_remote_endpoint(std::string value) {
        m_remote_endpoint = value;
    }
 
 
    std::string get_remote_endpoint() const {
        return m_remote_endpoint;
    }
 
 
    connection_hdl get_handle() const {
        return m_connection_hdl;
    }
 
 
    timer_ptr set_timer(long, timer_handler) {
        return timer_ptr();
    }
 
 
    void set_write_handler(write_handler h) {
        m_write_handler = h;
    }
 
 
    void set_vector_write_handler(vector_write_handler h) {
        m_vector_write_handler = h;
    }
 
 
    void set_shutdown_handler(shutdown_handler h) {
        m_shutdown_handler = h;
    }
protected:
 
    void init(init_handler handler) {
        m_alog.write(log::alevel::devel,"iostream connection init");
        handler(lib::error_code());
    }
 
 
    void async_read_at_least(size_t num_bytes, char *buf, size_t len,
        read_handler handler)
    {
        std::stringstream s;
        s << "iostream_con async_read_at_least: " << num_bytes;
        m_alog.write(log::alevel::devel,s.str());
 
        if (num_bytes > len) {
            handler(make_error_code(error::invalid_num_bytes),size_t(0));
            return;
        }
 
        if (m_reading == true) {
            handler(make_error_code(error::double_read),size_t(0));
            return;
        }
 
        if (num_bytes == 0 || len == 0) {
            handler(lib::error_code(),size_t(0));
            return;
        }
 
        m_buf = buf;
        m_len = len;
        m_bytes_needed = num_bytes;
        m_read_handler = handler;
        m_cursor = 0;
        m_reading = true;
    }
 
 
    void async_write(char const * buf, size_t len, transport::write_handler
        handler)
    {
        m_alog.write(log::alevel::devel,"iostream_con async_write");
        // TODO: lock transport state?
 
        lib::error_code ec;
 
        if (m_output_stream) {
            m_output_stream->write(buf,len);
 
            if (m_output_stream->bad()) {
                ec = make_error_code(error::bad_stream);
            }
        } else if (m_write_handler) {
            ec = m_write_handler(m_connection_hdl, buf, len);
        } else {
            ec = make_error_code(error::output_stream_required);
        }
 
        handler(ec);
    }
 
 
    void async_write(std::vector<buffer> const & bufs, transport::write_handler
        handler)
    {
        m_alog.write(log::alevel::devel,"iostream_con async_write buffer list");
        // TODO: lock transport state?
 
        lib::error_code ec;
 
        if (m_output_stream) {
            std::vector<buffer>::const_iterator it;
            for (it = bufs.begin(); it != bufs.end(); it++) {
                m_output_stream->write((*it).buf,(*it).len);
 
                if (m_output_stream->bad()) {
                    ec = make_error_code(error::bad_stream);
                    break;
                }
            }
        } else if (m_vector_write_handler) {
            ec = m_vector_write_handler(m_connection_hdl, bufs);
        } else if (m_write_handler) {
            std::vector<buffer>::const_iterator it;
            for (it = bufs.begin(); it != bufs.end(); it++) {
                ec = m_write_handler(m_connection_hdl, (*it).buf, (*it).len);
                if (ec) {break;}
            }
 
        } else {
            ec = make_error_code(error::output_stream_required);
        }
 
        handler(ec);
    }
 
 
    void set_handle(connection_hdl hdl) {
        m_connection_hdl = hdl;
    }
 
 
    lib::error_code dispatch(dispatch_handler handler) {
        handler();
        return lib::error_code();
    }
 
 
    void async_shutdown(transport::shutdown_handler handler) {
        lib::error_code ec;
 
        if (m_shutdown_handler) {
            ec = m_shutdown_handler(m_connection_hdl);
        }
 
        handler(ec);
    }
private:
    void read(std::istream &in) {
        m_alog.write(log::alevel::devel,"iostream_con read");
 
        while (in.good()) {
            if (!m_reading) {
                m_elog.write(log::elevel::devel,"write while not reading");
                break;
            }
 
            in.read(m_buf+m_cursor,static_cast<std::streamsize>(m_len-m_cursor));
 
            if (in.gcount() == 0) {
                m_elog.write(log::elevel::devel,"read zero bytes");
                break;
            }
 
            m_cursor += static_cast<size_t>(in.gcount());
 
            // TODO: error handling
            if (in.bad()) {
                m_reading = false;
                complete_read(make_error_code(error::bad_stream));
            }
 
            if (m_cursor >= m_bytes_needed) {
                m_reading = false;
                complete_read(lib::error_code());
            }
        }
    }
 
    size_t read_some_impl(char const * buf, size_t len) {
        m_alog.write(log::alevel::devel,"iostream_con read_some");
 
        if (!m_reading) {
            m_elog.write(log::elevel::devel,"write while not reading");
            return 0;
        }
 
        size_t bytes_to_copy = (std::min)(len,m_len-m_cursor);
 
        std::copy(buf,buf+bytes_to_copy,m_buf+m_cursor);
 
        m_cursor += bytes_to_copy;
 
        if (m_cursor >= m_bytes_needed) {
            complete_read(lib::error_code());
        }
 
        return bytes_to_copy;
    }
 
 
    void complete_read(lib::error_code const & ec) {
        m_reading = false;
 
        read_handler handler = m_read_handler;
        m_read_handler = read_handler();
 
        handler(ec,m_cursor);
    }
 
    // Read space (Protected by m_read_mutex)
    char *          m_buf;
    size_t          m_len;
    size_t          m_bytes_needed;
    read_handler    m_read_handler;
    size_t          m_cursor;
 
    // transport resources
    std::ostream *  m_output_stream;
    connection_hdl  m_connection_hdl;
    write_handler   m_write_handler;
    vector_write_handler m_vector_write_handler;
    shutdown_handler    m_shutdown_handler;
 
    bool            m_reading;
    bool const      m_is_server;
    bool            m_is_secure;
    alog_type &     m_alog;
    elog_type &     m_elog;
    std::string     m_remote_endpoint;
 
    // This lock ensures that only one thread can edit read data for this
    // connection. This is a very coarse lock that is basically locked all the
    // time. The nature of the connection is such that it cannot be
    // parallelized, the locking is here to prevent intra-connection concurrency
    // in order to allow inter-connection concurrency.
    mutex_type      m_read_mutex;
};
 
 
} // namespace iostream
} // namespace transport
} // namespace websocketpp
 
#endif // WEBSOCKETPP_TRANSPORT_IOSTREAM_CON_HPP