/* * 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 #include #include #include #include #include #include #include #include #include #include #include namespace websocketpp { namespace transport { namespace iostream { /// Empty timer class to stub out for timer functionality that iostream /// transport doesn't support struct timer { void cancel() {} }; template class connection : public lib::enable_shared_from_this< connection > { public: /// Type of this connection transport component typedef connection type; /// Type of a shared pointer to this connection transport component typedef lib::shared_ptr ptr; /// transport concurrency policy typedef typename config::concurrency_type concurrency_type; /// Type of this transport's access logging policy typedef typename config::alog_type alog_type; /// Type of this transport's error logging policy 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_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"); } /// Get a shared pointer to this component ptr get_shared() { return type::shared_from_this(); } /// Register a std::ostream with the transport for writing output /** * Register a std::ostream with the transport. All future writes will be * done to this output stream. * * @param o A pointer to the ostream to use for output. */ void register_ostream(std::ostream * o) { // TODO: lock transport state? scoped_lock_type lock(m_read_mutex); m_output_stream = o; } /// Set uri hook /** * Called by the endpoint as a connection is being established to provide * the uri being connected to to the transport layer. * * This transport policy doesn't use the uri so it is ignored. * * @since 0.6.0 * * @param u The uri to set */ void set_uri(uri_ptr) {} /// Overloaded stream input operator /** * Attempts to read input from the given stream into the transport. Bytes * will be extracted from the input stream to fulfill any pending reads. * Input in this manner will only read until the current read buffer has * been filled. Then it will signal the library to process the input. If the * library's input handler adds a new async_read, additional bytes will be * read, otherwise the input operation will end. * * When this function returns one of the following conditions is true: * - There is no outstanding read operation * - There are no more bytes available in the input stream * * You can use tellg() on the input stream to determine if all of the input * bytes were read or not. * * If there is no pending read operation when the input method is called, it * will return immediately and tellg() will not have changed. */ 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; } /// Manual input supply (read some) /** * Copies bytes from buf into WebSocket++'s input buffers. Bytes will be * copied from the supplied buffer to fulfill any pending library reads. It * will return the number of bytes successfully processed. If there are no * pending reads read_some will return immediately. Not all of the bytes may * be able to be read in one call. * * @since 0.3.0-alpha4 * * @param buf Char buffer to read into the websocket * @param len Length of buf * @return The number of characters from buf actually read. */ 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); } /// Manual input supply (read all) /** * Similar to read_some, but continues to read until all bytes in the * supplied buffer have been read or the connection runs out of read * requests. * * This method still may not read all of the bytes in the input buffer. if * it doesn't it indicates that the connection was most likely closed or * is in an error state where it is no longer accepting new input. * * @since 0.3.0 * * @param buf Char buffer to read into the websocket * @param len Length of buf * @return The number of characters from buf actually read. */ 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; } /// Manual input supply (DEPRECATED) /** * @deprecated DEPRECATED in favor of read_some() * @see read_some() */ size_t readsome(char const * buf, size_t len) { return this->read_some(buf,len); } /// Signal EOF /** * Signals to the transport that data stream being read has reached EOF and * that no more bytes may be read or written to/from the transport. * * @since 0.3.0-alpha4 */ 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)); } } /// Signal transport error /** * Signals to the transport that a fatal data stream error has occurred and * that no more bytes may be read or written to/from the transport. * * @since 0.3.0-alpha4 */ 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)); } } /// Set whether or not this connection is secure /** * The iostream transport does not provide any security features. As such * it defaults to returning false when `is_secure` is called. However, the * iostream transport may be used to wrap an external socket API that may * provide secure transport. This method allows that external API to flag * whether or not this connection is secure so that users of the WebSocket++ * API will get more accurate information. * * @since 0.3.0-alpha4 * * @param value Whether or not this connection is secure. */ void set_secure(bool value) { m_is_secure = value; } /// Tests whether or not the underlying transport is secure /** * iostream transport will return false always because it has no information * about the ultimate remote endpoint. This may or may not be accurate * depending on the real source of bytes being input. The `set_secure` * method may be used to flag connections that are secured by an external * API * * @return Whether or not the underlying transport is secure */ bool is_secure() const { return m_is_secure; } /// Set human readable remote endpoint address /** * Sets the remote endpoint address returned by `get_remote_endpoint`. This * value should be a human readable string that describes the remote * endpoint. Typically an IP address or hostname, perhaps with a port. But * may be something else depending on the nature of the underlying * transport. * * If none is set the default is "iostream transport". * * @since 0.3.0-alpha4 * * @param value The remote endpoint address to set. */ void set_remote_endpoint(std::string value) { m_remote_endpoint = value; } /// Get human readable remote endpoint address /** * The iostream transport has no information about the ultimate remote * endpoint. It will return the string "iostream transport". The * `set_remote_endpoint` method may be used by external network code to set * a more accurate value. * * This value is used in access and error logs and is available to the end * application for including in user facing interfaces and messages. * * @return A string identifying the address of the remote endpoint */ std::string get_remote_endpoint() const { return m_remote_endpoint; } /// Get the connection handle /** * @return The handle for this connection. */ connection_hdl get_handle() const { return m_connection_hdl; } /// Call back a function after a period of time. /** * Timers are not implemented in this transport. The timer pointer will * always be empty. The handler will never be called. * * @param duration Length of time to wait in milliseconds * @param callback The function to call back when the timer has expired * @return A handle that can be used to cancel the timer if it is no longer * needed. */ timer_ptr set_timer(long, timer_handler) { return timer_ptr(); } /// Sets the write handler /** * The write handler is called when the iostream transport receives data * that needs to be written to the appropriate output location. This handler * can be used in place of registering an ostream for output. * * The signature of the handler is * `lib::error_code (connection_hdl, char const *, size_t)` The * code returned will be reported and logged by the core library. * * See also, set_vector_write_handler, for an optional write handler that * allows more efficient handling of multiple writes at once. * * @see set_vector_write_handler * * @since 0.5.0 * * @param h The handler to call when data is to be written. */ void set_write_handler(write_handler h) { m_write_handler = h; } /// Sets the vectored write handler /** * The vectored write handler is called when the iostream transport receives * multiple chunks of data that need to be written to the appropriate output * location. This handler can be used in conjunction with the write_handler * in place of registering an ostream for output. * * The sequence of buffers represents bytes that should be written * consecutively and it is suggested to group the buffers into as few next * layer packets as possible. Vector write is used to allow implementations * that support it to coalesce writes into a single TCP packet or TLS * segment for improved efficiency. * * This is an optional handler. If it is not defined then multiple calls * will be made to the standard write handler. * * The signature of the handler is * `lib::error_code (connection_hdl, std::vector * const & bufs)`. The code returned will be reported and logged by the core * library. The `websocketpp::transport::buffer` type is a struct with two * data members. buf (char const *) and len (size_t). * * @since 0.6.0 * * @param h The handler to call when vectored data is to be written. */ void set_vector_write_handler(vector_write_handler h) { m_vector_write_handler = h; } /// Sets the shutdown handler /** * The shutdown handler is called when the iostream transport receives a * notification from the core library that it is finished with all read and * write operations and that the underlying transport can be cleaned up. * * If you are using iostream transport with another socket library, this is * a good time to close/shutdown the socket for this connection. * * The signature of the handler is `lib::error_code (connection_hdl)`. The * code returned will be reported and logged by the core library. * * @since 0.5.0 * * @param h The handler to call on connection shutdown. */ void set_shutdown_handler(shutdown_handler h) { m_shutdown_handler = h; } protected: /// Initialize the connection transport /** * Initialize the connection's transport component. * * @param handler The `init_handler` to call when initialization is done */ void init(init_handler handler) { m_alog.write(log::alevel::devel,"iostream connection init"); handler(lib::error_code()); } /// Initiate an async_read for at least num_bytes bytes into buf /** * Initiates an async_read request for at least num_bytes bytes. The input * will be read into buf. A maximum of len bytes will be input. When the * operation is complete, handler will be called with the status and number * of bytes read. * * This method may or may not call handler from within the initial call. The * application should be prepared to accept either. * * The application should never call this method a second time before it has * been called back for the first read. If this is done, the second read * will be called back immediately with a double_read error. * * If num_bytes or len are zero handler will be called back immediately * indicating success. * * @param num_bytes Don't call handler until at least this many bytes have * been read. * @param buf The buffer to read bytes into * @param len The size of buf. At maximum, this many bytes will be read. * @param handler The callback to invoke when the operation is complete or * ends in an error */ 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; } /// Asyncronous Transport Write /** * Write len bytes in buf to the output method. Call handler to report * success or failure. handler may or may not be called during async_write, * but it must be safe for this to happen. * * Will return 0 on success. Other possible errors (not exhaustive) * output_stream_required: No output stream was registered to write to * bad_stream: a ostream pass through error * * This method will attempt to write to the registered ostream first. If an * ostream is not registered it will use the write handler. If neither are * registered then an error is passed up to the connection. * * @param buf buffer to read bytes from * @param len number of bytes to write * @param handler Callback to invoke with operation status. */ 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); } /// Asyncronous Transport Write (scatter-gather) /** * Write a sequence of buffers to the output method. Call handler to report * success or failure. handler may or may not be called during async_write, * but it must be safe for this to happen. * * Will return 0 on success. Other possible errors (not exhaustive) * output_stream_required: No output stream was registered to write to * bad_stream: a ostream pass through error * * This method will attempt to write to the registered ostream first. If an * ostream is not registered it will use the write handler. If neither are * registered then an error is passed up to the connection. * * @param bufs vector of buffers to write * @param handler Callback to invoke with operation status. */ void async_write(std::vector 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::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::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); } /// Set Connection Handle /** * @param hdl The new handle */ void set_handle(connection_hdl hdl) { m_connection_hdl = hdl; } /// Call given handler back within the transport's event system (if present) /** * Invoke a callback within the transport's event system if it has one. If * it doesn't, the handler will be invoked immediately before this function * returns. * * @param handler The callback to invoke * * @return Whether or not the transport was able to register the handler for * callback. */ lib::error_code dispatch(dispatch_handler handler) { handler(); return lib::error_code(); } /// Perform cleanup on socket shutdown_handler /** * If a shutdown handler is set, call it and pass through its return error * code. Otherwise assume there is nothing to do and pass through a success * code. * * @param handler The `shutdown_handler` to call back when complete */ 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(m_len-m_cursor)); if (in.gcount() == 0) { m_elog.write(log::elevel::devel,"read zero bytes"); break; } m_cursor += static_cast(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; } /// Signal that a requested read is complete /** * Sets the reading flag to false and returns the handler that should be * called back with the result of the read. The cursor position that is sent * is whatever the value of m_cursor is. * * It MUST NOT be called when m_reading is false. * it MUST be called while holding the read lock * * It is important to use this method rather than directly setting/calling * m_read_handler back because this function makes sure to delete the * locally stored handler which contains shared pointers that will otherwise * cause circular reference based memory leaks. * * @param ec The error code to forward to the read handler */ 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