Thread portable class Gate portable class Timer class Pool class Terimber 2.0 About C++

Downloads Products & Services Support Clients Open Source About Home / Open source / Terimber 2.0 msg_cpp.h Go to the documentation of this file. /* * The Software License * ================================================================================= * Copyright (c) 2003-.The Terimber Corporation. All rights reserved. * ================================================================================= * 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. * The end-user documentation included with the redistribution, if any, * must include the following acknowledgment: * "This product includes software developed by the Terimber Corporation." * ================================================================================= * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED 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 THE TERIMBER CORPORATION OR ITS CONTRIBUTORS 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 _terimber_msg_cpp_h_ #define _terimber_msg_cpp_h_ #include "aiomsg/msg_c.h" #include "base/memory.h" #include "base/string.h" #include "base/list.h" #include "base/number.h" BEGIN_TERIMBER_NAMESPACE #pragma pack(4) typedef room_array< ub1_t > room_byte_t; enum transport_type { unknown = 0, sock, rpc }; const size_t user_type_send = 0x10000001; const size_t user_type_send_async = 0x10000002; const size_t user_type_post = 0x10000003; const size_t user_type_reply = 0x10000004; const size_t user_type_reply_async = 0x10000005; const size_t user_type_mask = 0x10000007; const size_t handshake_type = 0x20000000; const size_t system_type = 0x40000000; const size_t msg_id_handshake_request = 0x10000001; const size_t msg_id_handshake_reply = 0x10000002; const size_t msg_id_ping = 0x10000003; const size_t msg_id_shutdown = 0x10000004; const size_t msg_default_timeout = 10000; const size_t msg_crypt_block = 16; inline bool is_request(size_t type) { return type != user_type_reply && type != user_type_reply_async; } class msg_cpp : public msg_t { msg_cpp(byte_allocator* allocator_, size_t size_); virtual ~msg_cpp(); public: static inline msg_cpp* construct( byte_allocator* allocator_, size_t size_ ) { msg_cpp* msg = 0; void* msg_space = 0; // allocates memory for message // calls constructor using allocated memory // if size greater then zero then resize message body if ((msg_space = allocator_->allocate(sizeof(msg_cpp))) && (msg = new(msg_space) msg_cpp(allocator_, size_)) ) return msg; else return 0; } static inline byte_allocator* destroy( msg_cpp* msg ) { // save internal allocator byte_allocator* all = msg->_allocator; // call destructor msg->~msg_cpp(); // return allocator return all; } void pack_msg( const room_byte_t* key ); void unpack_msg( const room_byte_t* key ); bool resize( size_t size_ ); inline size_t get_size() const { return _size; } inline const ub1_t* get_body() const { return _body; } inline ub1_t* get_body() { return _body; } inline const ub1_t* get_block() const { return _block; } inline ub1_t* get_block() { return _block; } static inline size_t estimate_size( size_t size_ ) { return sizeof(msg_cpp) + block_size(size_); } static inline size_t crypt_size( size_t size_ ) { return size_ ? ALIGNED_MASK_SIZEOF(size_, msg_crypt_block) : 0; } static inline size_t block_size( size_t size_ ) { return crypt_size(size_) + _block_body_offset(); } private: static inline size_t _block_body_offset() { return sizeof(ub4_t) // leading block size + sizeof(msg_cpp) // whole class size - sizeof(void*) // minus vtable - sizeof(byte_allocator*) // minus allocator pointer - sizeof(void*) // minus _body pointer - sizeof(void*); // minus _block pointer } public: static inline ub4_t reverse32( ub4_t value ) { value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); return ((value & 0xFFFF0000) >> 8) | ((value & 0x0000FFFF) << 8); } static inline ub2_t reverse16( ub2_t value ) { return ((value & 0xFF00) >> 8) | ((value & 0x00FF) << 8); } static inline size_t pack32( ub1_t*& dest, ub4_t x ) { size_t size = sizeof(ub4_t); *(ub4_t*)dest = htonl(x); dest += size; return size; } static inline size_t unpack32( const ub1_t*& x, ub4_t& dest ) { size_t size = sizeof(ub4_t); dest = ntohl(*(ub4_t*)x); x += size; return size; } static inline size_t pack16( ub1_t*& dest, ub2_t x ) { size_t size = sizeof(ub2_t); *(ub2_t*)dest = htons(x); dest += size; return size; } static inline size_t unpack16( const ub1_t*& x, ub2_t& dest ) { size_t size = sizeof(ub2_t); dest = ntohs(*(ub2_t*)x); x += size; return size; } static inline size_t packaddr( ub1_t*& dest, const guid_t& x ) { size_t size = 0; size += pack32(dest, x.Data1); size += pack16(dest, x.Data2); size += pack16(dest, x.Data3); for (ub1_t index = 0; index < 8; ++index, size += sizeof(ub1_t)) *dest++ = x.Data4[index]; return size; } static inline size_t unpackaddr( const ub1_t*& x, guid_t& dest ) { size_t size = 0; size += unpack32(x, (ub4_t&)dest.Data1); size += unpack16(x, (ub2_t&)dest.Data2); size += unpack16(x, (ub2_t&)dest.Data3); for (size_t index = 0; index < 8; ++index, size += sizeof(ub1_t)) dest.Data4[index] = *x++; return size; } static inline size_t pack64( ub1_t*& dest, const ub8_t& x ) { size_t size = sizeof(ub8_t); *(ub4_t*)dest = htonl((ub4_t)(x & 0x00000000ffffffff)); *(ub4_t*)(dest + sizeof(ub4_t)) = htonl((ub4_t)((x >> 32) & 0x00000000ffffffff)); dest += size; return size; } static inline size_t unpack64( const ub1_t*& x, ub8_t& dest ) { size_t size = sizeof(ub8_t); dest = (ub8_t)ntohl(*(ub4_t*)x) + ((ub8_t)ntohl(*(ub4_t*)(x + sizeof(ub4_t))) << 32); x += size; return size; } public: ub4_t _type; guid_t _marker; sb8_t _timestamp; guid_t _sender; guid_t _receiver; guid_t _sessionid; private: ub4_t _size; byte_allocator* _allocator; ub1_t* _body; ub1_t* _block; }; class msg_pack { public: static void make_error_msg( msg_cpp* msg, const char* text ); static void make_reply_msg( const msg_cpp* msg, msg_cpp* reply ); }; class conf_peer { public: conf_peer() : _support_crypt(false), _crypt(2) { _address = null_uuid; } conf_peer(const conf_peer& x) : _crypt(x._crypt) { *this = x; } conf_peer& operator=(const conf_peer& x) { if (this != &x) { _address = x._address; _support_crypt = x._support_crypt; _crypt = x._crypt; } return *this; } guid_t _address; bool _support_crypt; room_byte_t _crypt; // private symmetric crypto key }; typedef list< conf_peer > msg_peer_list_t; class conf_listener { public: conf_listener() : _type(unknown), _connections(0), _ping((ub4_t)INFINITE), _port(0), _support_crypt(false), _crypt_accept(2) { } conf_listener(const conf_listener& x) : _crypt_accept(x._crypt_accept) { *this = x; } conf_listener& operator=(const conf_listener& x) { if (this != &x) { _type = x._type; _address = x._address; _port = x._port; _network = x._network; _info = x._info; _connections = x._connections; _ping = x._ping; _support_crypt = x._support_crypt; _crypt_accept = x._crypt_accept; _accept = x._accept; _reject = x._reject; } return *this; } transport_type _type; guid_t _address; ub2_t _port; string_t _network; string_t _info; ub4_t _ping; bool _support_crypt; ub4_t _connections; room_byte_t _crypt_accept; msg_peer_list_t _accept; msg_peer_list_t _reject; }; class conf_connection { public: conf_connection() : _type(unknown), _ping((ub4_t)INFINITE), _port(0), _support_crypt(false), _crypt_private(2), _crypt_external(2) { _address = null_uuid; _session = null_uuid; } conf_connection(const conf_connection& x) : _crypt_private(x._crypt_private), _crypt_external(x._crypt_external) { *this = x; } conf_connection& operator=(const conf_connection& x) { if (this != &x) { _type = x._type; _address = x._address; _port = x._port; _session = x._session; _info = x._info; _network = x._network; _ping = x._ping; _support_crypt = x._support_crypt; _crypt_private = x._crypt_private; _crypt_external = x._crypt_external; } return *this; } conf_connection& operator=(const conf_listener& x) { _type = x._type; _address = x._address; _port = x._port; _info = x._info; _network = x._network; _ping = x._ping; return *this; } transport_type _type; guid_t _address; ub2_t _port; string_t _network; string_t _info; ub4_t _ping; bool _support_crypt; room_byte_t _crypt_private; room_byte_t _crypt_external; guid_t _session; }; typedef list< conf_listener > msg_listener_list_t; typedef list< conf_connection > msg_connection_list_t; class conf_unit { public: conf_unit() { clear(); } conf_unit(const conf_unit& x) { *this = x; } conf_unit& operator=(const conf_unit& x) { if (this != &x) { clear(); _listeners = x._listeners; _connections = x._connections; } return *this; } void clear() { _listeners.clear(); _connections.clear(); } msg_listener_list_t _listeners; msg_connection_list_t _connections; }; #pragma pack() END_TERIMBER_NAMESPACE #endif // _terimber_msg_cpp_h_

© Copyright Terimber 2003-.