gdax-orderbook-hpp/demo/dependencies/websocketpp-0.7.0/websocketpp/transport/base/connection.hpp

   1 /*
   2  * Copyright (c) 2014, Peter Thorson. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *     * Redistributions of source code must retain the above copyright
   7  *       notice, this list of conditions and the following disclaimer.
   8  *     * Redistributions in binary form must reproduce the above copyright
   9  *       notice, this list of conditions and the following disclaimer in the
  10  *       documentation and/or other materials provided with the distribution.
  11  *     * Neither the name of the WebSocket++ Project nor the
  12  *       names of its contributors may be used to endorse or promote products
  13  *       derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
  19  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  22  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  24  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  */
  27
  28 #ifndef WEBSOCKETPP_TRANSPORT_BASE_CON_HPP
  29 #define WEBSOCKETPP_TRANSPORT_BASE_CON_HPP
  30
  31 #include <websocketpp/common/cpp11.hpp>
  32 #include <websocketpp/common/connection_hdl.hpp>
  33 #include <websocketpp/common/functional.hpp>
  34 #include <websocketpp/common/system_error.hpp>
  35
  36 #include <string>
  37
  38 namespace websocketpp {
  39 /// Transport policies provide network connectivity and timers
  40 /**
  41  * ### Connection Interface
  42  *
  43  * Transport connection components needs to provide:
  44  *
  45  * **init**\n
  46  * `void init(init_handler handler)`\n
  47  * Called once shortly after construction to give the policy the chance to
  48  * perform one time initialization. When complete, the policy must call the
  49  * supplied `init_handler` to continue setup. The handler takes one argument
  50  * with the error code if any. If an error is returned here setup will fail and
  51  * the connection will be aborted or terminated.
  52  *
  53  * WebSocket++ will call init only once. The transport must call `handler`
  54  * exactly once.
  55  *
  56  * **async_read_at_least**\n
  57  * `void async_read_at_least(size_t num_bytes, char *buf, size_t len,
  58  * read_handler handler)`\n
  59  * start an async read for at least num_bytes and at most len
  60  * bytes into buf. Call handler when done with number of bytes read.
  61  *
  62  * WebSocket++ promises to have only one async_read_at_least in flight at a
  63  * time. The transport must promise to only call read_handler once per async
  64  * read.
  65  *
  66  * **async_write**\n
  67  * `void async_write(const char* buf, size_t len, write_handler handler)`\n
  68  * `void async_write(std::vector<buffer> & bufs, write_handler handler)`\n
  69  * Start a write of all of the data in buf or bufs. In second case data is
  70  * written sequentially and in place without copying anything to a temporary
  71  * location.
  72  *
  73  * Websocket++ promises to have only one async_write in flight at a time.
  74  * The transport must promise to only call the write_handler once per async
  75  * write
  76  *
  77  * **set_handle**\n
  78  * `void set_handle(connection_hdl hdl)`\n
  79  * Called by WebSocket++ to let this policy know the hdl to the connection. It
  80  * may be stored for later use or ignored/discarded. This handle should be used
  81  * if the policy adds any connection handlers. Connection handlers must be
  82  * called with the handle as the first argument so that the handler code knows
  83  * which connection generated the callback.
  84  *
  85  * **set_timer**\n
  86  * `timer_ptr set_timer(long duration, timer_handler handler)`\n
  87  * WebSocket++ uses the timers provided by the transport policy as the
  88  * implementation of timers is often highly coupled with the implementation of
  89  * the networking event loops.
  90  *
  91  * Transport timer support is an optional feature. A transport method may elect
  92  * to implement a dummy timer object and have this method return an empty
  93  * pointer. If so, all timer related features of WebSocket++ core will be
  94  * disabled. This includes many security features designed to prevent denial of
  95  * service attacks. Use timer-free transport policies with caution.
  96  *
  97  * **get_remote_endpoint**\n
  98  * `std::string get_remote_endpoint()`\n
  99  * retrieve address of remote endpoint
 100  *
 101  * **is_secure**\n
 102  * `void is_secure()`\n
 103  * whether or not the connection to the remote endpoint is secure
 104  *
 105  * **dispatch**\n
 106  * `lib::error_code dispatch(dispatch_handler handler)`: invoke handler within
 107  * the transport's event system if it uses one. Otherwise, this method should
 108  * simply call `handler` immediately.
 109  *
 110  * **async_shutdown**\n
 111  * `void async_shutdown(shutdown_handler handler)`\n
 112  * Perform any cleanup necessary (if any). Call `handler` when complete.
 113  */
 114 namespace transport {
 115
 116 /// The type and signature of the callback passed to the init hook
 117 typedef lib::function<void(lib::error_code const &)> init_handler;
 118
 119 /// The type and signature of the callback passed to the read method
 120 typedef lib::function<void(lib::error_code const &,size_t)> read_handler;
 121
 122 /// The type and signature of the callback passed to the write method
 123 typedef lib::function<void(lib::error_code const &)> write_handler;
 124
 125 /// The type and signature of the callback passed to the read method
 126 typedef lib::function<void(lib::error_code const &)> timer_handler;
 127
 128 /// The type and signature of the callback passed to the shutdown method
 129 typedef lib::function<void(lib::error_code const &)> shutdown_handler;
 130
 131 /// The type and signature of the callback passed to the interrupt method
 132 typedef lib::function<void()> interrupt_handler;
 133
 134 /// The type and signature of the callback passed to the dispatch method
 135 typedef lib::function<void()> dispatch_handler;
 136
 137 /// A simple utility buffer class
 138 struct buffer {
 139     buffer(char const * b, size_t l) : buf(b),len(l) {}
 140
 141     char const * buf;
 142     size_t len;
 143 };
 144
 145 /// Generic transport related errors
 146 namespace error {
 147 enum value {
 148     /// Catch-all error for transport policy errors that don't fit in other
 149     /// categories
 150     general = 1,
 151
 152     /// underlying transport pass through
 153     pass_through,
 154
 155     /// async_read_at_least call requested more bytes than buffer can store
 156     invalid_num_bytes,
 157
 158     /// async_read called while another async_read was in progress
 159     double_read,
 160
 161     /// Operation aborted
 162     operation_aborted,
 163
 164     /// Operation not supported
 165     operation_not_supported,
 166
 167     /// End of file
 168     eof,
 169
 170     /// TLS short read
 171     tls_short_read,
 172
 173     /// Timer expired
 174     timeout,
 175
 176     /// read or write after shutdown
 177     action_after_shutdown,
 178
 179     /// Other TLS error
 180     tls_error
 181 };
 182
 183 class category : public lib::error_category {
 184     public:
 185     category() {}
 186
 187     char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
 188         return "websocketpp.transport";
 189     }
 190
 191     std::string message(int value) const {
 192         switch(value) {
 193             case general:
 194                 return "Generic transport policy error";
 195             case pass_through:
 196                 return "Underlying Transport Error";
 197             case invalid_num_bytes:
 198                 return "async_read_at_least call requested more bytes than buffer can store";
 199             case operation_aborted:
 200                 return "The operation was aborted";
 201             case operation_not_supported:
 202                 return "The operation is not supported by this transport";
 203             case eof:
 204                 return "End of File";
 205             case tls_short_read:
 206                 return "TLS Short Read";
 207             case timeout:
 208                 return "Timer Expired";
 209             case action_after_shutdown:
 210                 return "A transport action was requested after shutdown";
 211             case tls_error:
 212                 return "Generic TLS related error";
 213             default:
 214                 return "Unknown";
 215         }
 216     }
 217 };
 218
 219 inline lib::error_category const & get_category() {
 220     static category instance;
 221     return instance;
 222 }
 223
 224 inline lib::error_code make_error_code(error::value e) {
 225     return lib::error_code(static_cast<int>(e), get_category());
 226 }
 227
 228 } // namespace error
 229 } // namespace transport
 230 } // namespace websocketpp
 231 _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
 232 template<> struct is_error_code_enum<websocketpp::transport::error::value>
 233 {
 234     static bool const value = true;
 235 };
 236 _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
 237
 238 #endif // WEBSOCKETPP_TRANSPORT_BASE_CON_HPP