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 aiosock.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_aiosock_h_ #define _terimber_aiosock_h_ #include "base/primitives.h" #include "base/stack.h" #include "base/list.h" #include "base/map.h" #include "threadpool/threadpool.h" #include "threadpool/thread.h" #include "aiosock/aiosockfactory.h" #include "aiocomport/aiocomport.h" BEGIN_TERIMBER_NAMESPACE #pragma pack(4) class aiosock_block : public OVERLAPPED { public: aiosock_block(); aiosock_block(const aiosock_block& x); aiosock_block& operator=(const aiosock_block& x); void clear(); void settimeout( size_t timeout ); public: aiosock_type _type; char* _buf; size_t _len; size_t _socket_ident; size_t _processed; int _err; void* _userdata; size_t _accept_ident; size_t _flags; ub1_t _accept_buf[2*(sizeof(struct sockaddr_in) + 16)]; sockaddr_in _address; #if OS_TYPE == OS_WIN32 size_t #else timeval #endif _timeout; sb8_t _expired; }; typedef SOCKET aio_sock_handle; class aiosock : public terimber_thread_employer, public terimber_aiosock { typedef node_allocator< base_list< aiosock_block* >::_node > aiosock_pblock_allocator_t; typedef _list< aiosock_block*, aiosock_pblock_allocator_t > aiosock_pblock_alloc_list_t; typedef list< aiosock_block* > aiosock_pblock_list_t; typedef node_allocator< aiosock_block > aiosock_block_allocator_t; class listener_info { public: listener_info( size_t curr_count, size_t max_count, void* userdata ) : _curr_count(curr_count), _max_count(max_count), _userdata(userdata) { } size_t _curr_count; size_t _max_count; void* _userdata; }; typedef map< size_t, listener_info > aiosock_listener_map_t; class aiosock_socket { public: aiosock_socket(bool tcp_udp, aio_sock_handle handle, terimber_aiosock_callback* callback ) : _handle(handle), _client_obj(callback), _callback_invoking(0), _tcp_udp(tcp_udp) { } aiosock_socket(const aiosock_socket& x) : _handle(x._handle), _client_obj(x._client_obj), _callback_invoking(x._callback_invoking), _tcp_udp(x._tcp_udp) {} ~aiosock_socket() { assert(_incoming_list.empty()); } aio_sock_handle _handle; terimber_aiosock_callback* _client_obj; aiosock_pblock_alloc_list_t _incoming_list; size_t _callback_invoking; bool _tcp_udp; }; typedef map< size_t, aiosock_socket > aiosock_socket_map_t; typedef map< size_t, aiosock_socket >::iterator aiosock_socket_map_iterator_t; typedef map< aio_sock_handle, aiosock_socket_map_iterator_t > aiosock_reverse_map_t; typedef map< aio_sock_handle, aiosock_socket_map_iterator_t >::iterator aiosock_reverse_map_iterator_t; typedef map< size_t, size_t > aiosock_delay_key_t; void _clear_block_lists() { if (!_outgoing_list.empty()) { for (aiosock_pblock_list_t::iterator out_iter = _outgoing_list.begin(); out_iter != _outgoing_list.end(); ++out_iter) { aiosock_block* block = *out_iter; _put_block(block); } _outgoing_list.clear(); } #if OS_TYPE == OS_WIN32 if (!_abounded_list.empty()) { for (aiosock_pblock_list_t::iterator tm_iter = _abounded_list.begin(); tm_iter != _abounded_list.end(); ++tm_iter) { aiosock_block* block = *tm_iter; _put_block(block); } _abounded_list.clear(); } #endif if (!_initial_list.empty()) { for (aiosock_pblock_list_t::iterator in_iter = _initial_list.begin(); in_iter != _initial_list.end(); ++in_iter) { aiosock_block* block = *in_iter; _put_block(block); } _initial_list.clear(); } } inline aiosock_block* _get_block() { aiosock_block* ptr = _block_allocator.allocate(); if (ptr) { new(ptr) aiosock_block(); } return ptr; } inline void _put_block(aiosock_block* block) { block->~aiosock_block(); _block_allocator.deallocate(block); } public: aiosock(size_t capacity, size_t deactivate_time_msec ); ~aiosock(); bool on(); void off(); virtual size_t create( terimber_aiosock_callback* callback, bool tcp_udp ); virtual void close( size_t ident ); virtual int send( size_t ident, const void* buf, size_t len, size_t timeout, const sockaddr_in* toaddr, void* userdata ); virtual int receive(size_t ident, void* buf, size_t len, size_t timeout, const sockaddr_in* fromaddr, void* userdata ); virtual int connect(size_t ident, const char* address, unsigned short port, size_t timeout, void* userdata ); virtual int listen( size_t ident, unsigned short port, size_t max_connection, const char* address, unsigned short accept_pool, void* userdata ); virtual int bind( size_t ident, const char* address, unsigned short port ); virtual int getpeeraddr(size_t ident, sockaddr_in& addr ); virtual int getsockaddr(size_t ident, sockaddr_in& addr ); virtual bool get_error_description( int err, char* buf, size_t len ) const { return resolve_sock_error_code(err, buf, len); } virtual void doxray(); static bool resolve_sock_error_code( int err, char* buf, size_t len ); protected: virtual bool v_has_job( size_t ident, void* data ); virtual void v_do_job( size_t ident, void* data ); private: bool resolve_socket_address(const char* address, unsigned short port, sockaddr_in& addr ); aio_sock_handle find_socket_handle( size_t ident ); void process_timeouted_blocks(); bool process_accept_blocks(); void complete_block( size_t sock_key, aiosock_block* ov, int err, size_t processed ); int _activate_block( size_t ident, aiosock_block* block, const sockaddr_in* pddr ); void _cancel_socket( aio_sock_handle handle ); #if OS_TYPE != OS_WIN32 void _cancel_aio( aio_sock_handle handle, OVERLAPPED* overlapped ); #endif size_t _assign_socket( aio_sock_handle handle, terimber_aiosock_callback* callback, bool tcp_udp ); void _close_socket( aio_sock_handle handle, bool tcp_udp ); int _process_block( aiosock_block* block ); // specific function for IO blocks processing int _process_connect( aio_sock_handle handle, aiosock_block* block ); int _process_accept( aio_sock_handle handle, terimber_aiosock_callback* client, aiosock_block* block ); int _process_send( aio_sock_handle handle, aiosock_block* block, bool tcp_udp ); int _process_recv( aio_sock_handle handle, aiosock_block* block, bool tcp_udp ); void wait_for_io_completion(); public: mutex _mtx; aiosock_socket_map_t _socket_map; aiosock_reverse_map_t _reverse_map; aiosock_listener_map_t _listeners_map; aiosock_delay_key_t _delay_key_map; unique_key_generator _socket_generator; aiosock_pblock_allocator_t _incoming_list_allocator; aiosock_block_allocator_t _block_allocator; aiosock_pblock_list_t _initial_list; aiosock_pblock_list_t _outgoing_list; #if OS_TYPE == OS_WIN32 aiosock_pblock_list_t _abounded_list; #endif private: HANDLE _aiosock_io_handle; threadpool _thread_pool; size_t _capacity; thread _in_thread; static bool _port_init; bool _on; bool _flag_io_port; event _start_io_port; event _stop_io_port; }; #pragma pack() END_TERIMBER_NAMESPACE #endif // _terimber_aioport_h_

© Copyright Terimber 2003-.