epee::levin::async_protocol_handler< t_connection_context > Class Template Reference

#include <levin_protocol_handler_async.h>

Collaboration diagram for epee::levin::async_protocol_handler< t_connection_context >:

Classes
struct	invoke_response_handler_base
struct	anvoke_handler

Public Types
enum	stream_state { stream_state_head , stream_state_body }
typedef t_connection_context	connection_context
typedef async_protocol_handler_config< t_connection_context >	config_type

Public Member Functions
template<class callback_t>
bool	add_invoke_response_handler (const callback_t &cb, uint64_t timeout, async_protocol_handler &con, int command)
	async_protocol_handler (net_utils::i_service_endpoint *psnd_hndlr, config_type &config, t_connection_context &conn_context)
virtual	~async_protocol_handler ()
bool	start_outer_call ()
bool	finish_outer_call ()
bool	release_protocol ()
bool	close ()
void	update_connection_context (const connection_context &contxt)
void	request_callback ()
void	handle_qued_callback ()
virtual bool	handle_recv (const void *ptr, size_t cb)
bool	after_init_connection ()
template<class callback_t>
bool	async_invoke (int command, const epee::span< const uint8_t > in_buff, const callback_t &cb, size_t timeout=LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
int	invoke (int command, const epee::span< const uint8_t > in_buff, std::string &buff_out)
int	notify (int command, const epee::span< const uint8_t > in_buff)
boost::uuids::uuid	get_connection_id ()
t_connection_context &	get_context_ref ()

Public Attributes
std::atomic< bool >	m_deletion_initiated
std::atomic< bool >	m_protocol_released
volatile uint32_t	m_invoke_buf_ready
volatile int	m_invoke_result_code
critical_section	m_local_inv_buff_lock
std::string	m_local_inv_buff
critical_section	m_send_lock
critical_section	m_call_lock
volatile uint32_t	m_wait_count
volatile uint32_t	m_close_called
bucket_head2	m_current_head
net_utils::i_service_endpoint *	m_pservice_endpoint
config_type &	m_config
t_connection_context &	m_connection_context
net_utils::buffer	m_cache_in_buffer
stream_state	m_state
int32_t	m_oponent_protocol_ver
bool	m_connection_initialized
critical_section	m_invoke_response_handlers_lock
std::list< boost::shared_ptr< invoke_response_handler_base > >	m_invoke_response_handlers

Friends
template<class callback_t>
struct	anvoke_handler

Detailed Description

template<class t_connection_context = net_utils::connection_context_base>
class epee::levin::async_protocol_handler< t_connection_context >

Definition at line 116 of file levin_protocol_handler_async.h.

Member Typedef Documentation

config_type

template<class t_connection_context = net_utils::connection_context_base>

typedef async_protocol_handler_config<t_connection_context> epee::levin::async_protocol_handler< t_connection_context >::config_type

Definition at line 120 of file levin_protocol_handler_async.h.

connection_context

template<class t_connection_context = net_utils::connection_context_base>

typedef t_connection_context epee::levin::async_protocol_handler< t_connection_context >::connection_context

Definition at line 119 of file levin_protocol_handler_async.h.

Member Enumeration Documentation

stream_state

template<class t_connection_context = net_utils::connection_context_base>

enum epee::levin::async_protocol_handler::stream_state

Enumerator
stream_state_head
stream_state_body

Definition at line 122 of file levin_protocol_handler_async.h.

  {
    stream_state_head,
    stream_state_body
  };

Constructor & Destructor Documentation

async_protocol_handler()

template<class t_connection_context = net_utils::connection_context_base>

epee::levin::async_protocol_handler< t_connection_context >::async_protocol_handler ( net_utils::i_service_endpoint * psnd_hndlr, config_type & config, t_connection_context & conn_context )

inline

Definition at line 262 of file levin_protocol_handler_async.h.

                                       :
            m_current_head(bucket_head2()),
            m_pservice_endpoint(psnd_hndlr), 
            m_config(config), 
            m_connection_context(conn_context), 
            m_cache_in_buffer(4 * 1024),
            m_state(stream_state_head)
  {
    m_close_called = 0;
    m_deletion_initiated = false;
    m_protocol_released = false;
    m_wait_count = 0;
    m_oponent_protocol_ver = 0;
    m_connection_initialized = false;
    m_invoke_buf_ready = 0;
    m_invoke_result_code = LEVIN_ERROR_CONNECTION;
  }

Here is the caller graph for this function:

~async_protocol_handler()

template<class t_connection_context = net_utils::connection_context_base>

virtual epee::levin::async_protocol_handler< t_connection_context >::~async_protocol_handler ( )

inlinevirtual

Definition at line 281 of file levin_protocol_handler_async.h.

  {
    try
    {
 
    m_deletion_initiated = true;
    if(m_connection_initialized)
    {
      m_config.del_connection(this);
    }
 
    for (size_t i = 0; i < 60 * 1000 / 100 && 0 != boost::interprocess::ipcdetail::atomic_read32(&m_wait_count); ++i)
    {
      misc_utils::sleep_no_w(100);
    }
    CHECK_AND_ASSERT_MES_NO_RET(0 == boost::interprocess::ipcdetail::atomic_read32(&m_wait_count), "Failed to wait for operation completion. m_wait_count = " << m_wait_count);
 
    MTRACE(m_connection_context << "~async_protocol_handler()");
 
    }
    catch (...) { /* ignore */ }
  }

Member Function Documentation

add_invoke_response_handler()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

bool epee::levin::async_protocol_handler< t_connection_context >::add_invoke_response_handler ( const callback_t & cb, uint64_t timeout, async_protocol_handler< t_connection_context > & con, int command )

inline

Definition at line 253 of file levin_protocol_handler_async.h.

  {
    CRITICAL_REGION_LOCAL(m_invoke_response_handlers_lock);
    boost::shared_ptr<invoke_response_handler_base> handler(boost::make_shared<anvoke_handler<callback_t>>(cb, timeout, con, command));
    m_invoke_response_handlers.push_back(handler);
    return handler->is_timer_started();
  }

after_init_connection()

template<class t_connection_context = net_utils::connection_context_base>

bool epee::levin::async_protocol_handler< t_connection_context >::after_init_connection ( )

inline

Definition at line 549 of file levin_protocol_handler_async.h.

  {
    if (!m_connection_initialized)
    {
      m_connection_initialized = true;
      m_config.add_connection(this);
    }
    return true;
  }

async_invoke()

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

bool epee::levin::async_protocol_handler< t_connection_context >::async_invoke ( int command, const epee::span< const uint8_t > in_buff, const callback_t & cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED )

inline

Definition at line 560 of file levin_protocol_handler_async.h.

  {
    misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
      boost::bind(&async_protocol_handler::finish_outer_call, this));
 
    if(timeout == LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
      timeout = m_config.m_invoke_timeout;
 
    int err_code = LEVIN_OK;
    do
    {
      if(m_deletion_initiated)
      {
        err_code = LEVIN_ERROR_CONNECTION_DESTROYED;
        break;
      }
 
      CRITICAL_REGION_LOCAL(m_call_lock);
 
      if(m_deletion_initiated)
      {
        err_code = LEVIN_ERROR_CONNECTION_DESTROYED;
        break;
      }
 
      bucket_head2 head = {0};
      head.m_signature = SWAP64LE(LEVIN_SIGNATURE);
      head.m_cb = SWAP64LE(in_buff.size());
      head.m_have_to_return_data = true;
 
      head.m_flags = SWAP32LE(LEVIN_PACKET_REQUEST);
      head.m_command = SWAP32LE(command);
      head.m_protocol_version = SWAP32LE(LEVIN_PROTOCOL_VER_1);
 
      boost::interprocess::ipcdetail::atomic_write32(&m_invoke_buf_ready, 0);
      CRITICAL_REGION_BEGIN(m_send_lock);
      CRITICAL_REGION_LOCAL1(m_invoke_response_handlers_lock);
      if(!m_pservice_endpoint->do_send(&head, sizeof(head)))
      {
        LOG_ERROR_CC(m_connection_context, "Failed to do_send");
        err_code = LEVIN_ERROR_CONNECTION;
        break;
      }
 
      if(!m_pservice_endpoint->do_send(in_buff.data(), in_buff.size()))
      {
        LOG_ERROR_CC(m_connection_context, "Failed to do_send");
        err_code = LEVIN_ERROR_CONNECTION;
        break;
      }
 
      if(!add_invoke_response_handler(cb, timeout, *this, command))
      {
        err_code = LEVIN_ERROR_CONNECTION_DESTROYED;
        break;
      }
      CRITICAL_REGION_END();
    } while (false);
 
    if (LEVIN_OK != err_code)
    {
      epee::span<const uint8_t> stub_buff{(const uint8_t*)"", 0};
      // Never call callback inside critical section, that can cause deadlock
      cb(err_code, stub_buff, m_connection_context);
      return false;
    }
 
    return true;
  }

Here is the caller graph for this function:

close()

template<class t_connection_context = net_utils::connection_context_base>

bool epee::levin::async_protocol_handler< t_connection_context >::close ( )

inline

Definition at line 340 of file levin_protocol_handler_async.h.

  {    
    boost::interprocess::ipcdetail::atomic_inc32(&m_close_called);
 
    m_pservice_endpoint->close();
    return true;
  }

Here is the caller graph for this function:

finish_outer_call()

template<class t_connection_context = net_utils::connection_context_base>

bool epee::levin::async_protocol_handler< t_connection_context >::finish_outer_call ( )

inline

Definition at line 315 of file levin_protocol_handler_async.h.

  {
    MTRACE(m_connection_context << "[levin_protocol] <<-- finish_outer_call");
    boost::interprocess::ipcdetail::atomic_dec32(&m_wait_count);
    m_pservice_endpoint->release();
    return true;
  }

Here is the caller graph for this function:

get_connection_id()

template<class t_connection_context = net_utils::connection_context_base>

boost::uuids::uuid epee::levin::async_protocol_handler< t_connection_context >::get_connection_id ( )

inline

Definition at line 747 of file levin_protocol_handler_async.h.

{return m_connection_context.m_connection_id;}

get_context_ref()

template<class t_connection_context = net_utils::connection_context_base>

t_connection_context & epee::levin::async_protocol_handler< t_connection_context >::get_context_ref ( )

inline

Definition at line 749 of file levin_protocol_handler_async.h.

{return m_connection_context;}

Here is the caller graph for this function:

handle_qued_callback()

template<class t_connection_context = net_utils::connection_context_base>

void epee::levin::async_protocol_handler< t_connection_context >::handle_qued_callback ( )

inline

Definition at line 361 of file levin_protocol_handler_async.h.

  {
    m_config.m_pcommands_handler->callback(m_connection_context);
  }

handle_recv()

template<class t_connection_context = net_utils::connection_context_base>

virtual bool epee::levin::async_protocol_handler< t_connection_context >::handle_recv ( const void * ptr, size_t cb )

inlinevirtual

Definition at line 366 of file levin_protocol_handler_async.h.

  {
    if(boost::interprocess::ipcdetail::atomic_read32(&m_close_called))
      return false; //closing connections
 
    if(!m_config.m_pcommands_handler)
    {
      MERROR(m_connection_context << "Commands handler not set!");
      return false;
    }
 
    if(m_cache_in_buffer.size() +  cb > m_config.m_max_packet_size)
    {
      MWARNING(m_connection_context << "Maximum packet size exceed!, m_max_packet_size = " << m_config.m_max_packet_size
                          << ", packet received " << m_cache_in_buffer.size() +  cb 
                          << ", connection will be closed.");
      return false;
    }
 
    m_cache_in_buffer.append((const char*)ptr, cb);
 
    bool is_continue = true;
    while(is_continue)
    {
      switch(m_state)
      {
      case stream_state_body:
        if(m_cache_in_buffer.size() < m_current_head.m_cb)
        {
          is_continue = false;
          if(cb >= MIN_BYTES_WANTED)
          {
            CRITICAL_REGION_LOCAL(m_invoke_response_handlers_lock);
            if (!m_invoke_response_handlers.empty())
            {
              //async call scenario
              boost::shared_ptr<invoke_response_handler_base> response_handler = m_invoke_response_handlers.front();
              response_handler->reset_timer();
              MDEBUG(m_connection_context << "LEVIN_PACKET partial msg received. len=" << cb);
            }
          }
          break;
        }
        {
          epee::span<const uint8_t> buff_to_invoke = m_cache_in_buffer.carve((std::string::size_type)m_current_head.m_cb);
 
          bool is_response = (m_oponent_protocol_ver == LEVIN_PROTOCOL_VER_1 && m_current_head.m_flags&LEVIN_PACKET_RESPONSE);
 
          MDEBUG(m_connection_context << "LEVIN_PACKET_RECEIVED. [len=" << m_current_head.m_cb
            << ", flags" << m_current_head.m_flags 
            << ", r?=" << m_current_head.m_have_to_return_data 
            <<", cmd = " << m_current_head.m_command 
            << ", v=" << m_current_head.m_protocol_version);
 
          if(is_response)
          {//response to some invoke 
 
            epee::critical_region_t<decltype(m_invoke_response_handlers_lock)> invoke_response_handlers_guard(m_invoke_response_handlers_lock);
            if(!m_invoke_response_handlers.empty())
            {//async call scenario
              boost::shared_ptr<invoke_response_handler_base> response_handler = m_invoke_response_handlers.front();
              bool timer_cancelled = response_handler->cancel_timer();
               // Don't pop handler, to avoid destroying it
              if(timer_cancelled)
                m_invoke_response_handlers.pop_front();
              invoke_response_handlers_guard.unlock();
 
              if(timer_cancelled)
                response_handler->handle(m_current_head.m_return_code, buff_to_invoke, m_connection_context);
            }
            else
            {
              invoke_response_handlers_guard.unlock();
              //use sync call scenario
              if(!boost::interprocess::ipcdetail::atomic_read32(&m_wait_count) && !boost::interprocess::ipcdetail::atomic_read32(&m_close_called))
              {
                MERROR(m_connection_context << "no active invoke when response came, wtf?");
                return false;
              }else
              {
                CRITICAL_REGION_BEGIN(m_local_inv_buff_lock);
                m_local_inv_buff = std::string((const char*)buff_to_invoke.data(), buff_to_invoke.size());
                buff_to_invoke = epee::span<const uint8_t>((const uint8_t*)NULL, 0);
                m_invoke_result_code = m_current_head.m_return_code;
                CRITICAL_REGION_END();
                boost::interprocess::ipcdetail::atomic_write32(&m_invoke_buf_ready, 1);
              }
            }
          }else
          {
            if(m_current_head.m_have_to_return_data)
            {
              std::string return_buff;
              m_current_head.m_return_code = m_config.m_pcommands_handler->invoke(
                                                                  m_current_head.m_command, 
                                                                  buff_to_invoke, 
                                                                  return_buff, 
                                                                  m_connection_context);
              m_current_head.m_cb = return_buff.size();
              m_current_head.m_have_to_return_data = false;
              m_current_head.m_protocol_version = LEVIN_PROTOCOL_VER_1;
              m_current_head.m_flags = LEVIN_PACKET_RESPONSE;
#if BYTE_ORDER == LITTLE_ENDIAN
              std::string send_buff((const char*)&m_current_head, sizeof(m_current_head));
#else
              bucket_head2 head = m_current_head;
              head.m_signature = SWAP64LE(head.m_signature);
              head.m_cb = SWAP64LE(head.m_cb);
              head.m_command = SWAP32LE(head.m_command);
              head.m_return_code = SWAP32LE(head.m_return_code);
              head.m_flags = SWAP32LE(head.m_flags);
              head.m_protocol_version = SWAP32LE(head.m_protocol_version);
              std::string send_buff((const char*)&head, sizeof(head));
#endif
              send_buff += return_buff;
              CRITICAL_REGION_BEGIN(m_send_lock);
              if(!m_pservice_endpoint->do_send(send_buff.data(), send_buff.size()))
                return false;
              CRITICAL_REGION_END();
              MDEBUG(m_connection_context << "LEVIN_PACKET_SENT. [len=" << m_current_head.m_cb
                << ", flags" << m_current_head.m_flags 
                << ", r?=" << m_current_head.m_have_to_return_data 
                <<", cmd = " << m_current_head.m_command 
                << ", ver=" << m_current_head.m_protocol_version);
            }
            else
              m_config.m_pcommands_handler->notify(m_current_head.m_command, buff_to_invoke, m_connection_context);
          }
        }
        m_state = stream_state_head;
        break;
      case stream_state_head:
        {
          if(m_cache_in_buffer.size() < sizeof(bucket_head2))
          {
            if(m_cache_in_buffer.size() >= sizeof(uint64_t) && *((uint64_t*)m_cache_in_buffer.span(8).data()) != SWAP64LE(LEVIN_SIGNATURE))
            {
              MWARNING(m_connection_context << "Signature mismatch, connection will be closed");
              return false;
            }
            is_continue = false;
            break;
          }
 
#if BYTE_ORDER == LITTLE_ENDIAN
          bucket_head2& phead = *(bucket_head2*)m_cache_in_buffer.span(sizeof(bucket_head2)).data();
#else
          bucket_head2 phead = *(bucket_head2*)m_cache_in_buffer.span(sizeof(bucket_head2)).data();
          phead.m_signature = SWAP64LE(phead.m_signature);
          phead.m_cb = SWAP64LE(phead.m_cb);
          phead.m_command = SWAP32LE(phead.m_command);
          phead.m_return_code = SWAP32LE(phead.m_return_code);
          phead.m_flags = SWAP32LE(phead.m_flags);
          phead.m_protocol_version = SWAP32LE(phead.m_protocol_version);
#endif
          if(LEVIN_SIGNATURE != phead.m_signature)
          {
            LOG_ERROR_CC(m_connection_context, "Signature mismatch, connection will be closed");
            return false;
          }
          m_current_head = phead;
 
          m_cache_in_buffer.erase(sizeof(bucket_head2));
          m_state = stream_state_body;
          m_oponent_protocol_ver = m_current_head.m_protocol_version;
          if(m_current_head.m_cb > m_config.m_max_packet_size)
          {
            LOG_ERROR_CC(m_connection_context, "Maximum packet size exceed!, m_max_packet_size = " << m_config.m_max_packet_size 
              << ", packet header received " << m_current_head.m_cb 
              << ", connection will be closed.");
            return false;
          }
        }
        break;
      default:
        LOG_ERROR_CC(m_connection_context, "Undefined state in levin_server_impl::connection_handler, m_state=" << m_state);
        return false;
      }
    }
 
    return true;
  }

invoke()

template<class t_connection_context = net_utils::connection_context_base>

int epee::levin::async_protocol_handler< t_connection_context >::invoke ( int command, const epee::span< const uint8_t > in_buff, std::string & buff_out )

inline

Definition at line 630 of file levin_protocol_handler_async.h.

  {
    misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
                                      boost::bind(&async_protocol_handler::finish_outer_call, this));
 
    if(m_deletion_initiated)
      return LEVIN_ERROR_CONNECTION_DESTROYED;
 
    CRITICAL_REGION_LOCAL(m_call_lock);
 
    if(m_deletion_initiated)
      return LEVIN_ERROR_CONNECTION_DESTROYED;
 
    bucket_head2 head = {0};
    head.m_signature = SWAP64LE(LEVIN_SIGNATURE);
    head.m_cb = SWAP64LE(in_buff.size());
    head.m_have_to_return_data = true;
 
    head.m_flags = SWAP32LE(LEVIN_PACKET_REQUEST);
    head.m_command = SWAP32LE(command);
    head.m_protocol_version = SWAP32LE(LEVIN_PROTOCOL_VER_1);
 
    boost::interprocess::ipcdetail::atomic_write32(&m_invoke_buf_ready, 0);
    CRITICAL_REGION_BEGIN(m_send_lock);
    if(!m_pservice_endpoint->do_send(&head, sizeof(head)))
    {
      LOG_ERROR_CC(m_connection_context, "Failed to do_send");
      return LEVIN_ERROR_CONNECTION;
    }
 
    if(!m_pservice_endpoint->do_send(in_buff.data(), in_buff.size()))
    {
      LOG_ERROR_CC(m_connection_context, "Failed to do_send");
      return LEVIN_ERROR_CONNECTION;
    }
    CRITICAL_REGION_END();
 
    MDEBUG(m_connection_context << "LEVIN_PACKET_SENT. [len=" << head.m_cb
                            << ", f=" << head.m_flags 
                            << ", r?=" << head.m_have_to_return_data 
                            << ", cmd = " << head.m_command 
                            << ", ver=" << head.m_protocol_version);
 
    uint64_t ticks_start = misc_utils::get_tick_count();
    size_t prev_size = 0;
 
    while(!boost::interprocess::ipcdetail::atomic_read32(&m_invoke_buf_ready) && !m_deletion_initiated && !m_protocol_released)
    {
      if(m_cache_in_buffer.size() - prev_size >= MIN_BYTES_WANTED)
      {
        prev_size = m_cache_in_buffer.size();
        ticks_start = misc_utils::get_tick_count();
      }
      if(misc_utils::get_tick_count() - ticks_start > m_config.m_invoke_timeout)
      {
        MWARNING(m_connection_context << "invoke timeout (" << m_config.m_invoke_timeout << "), closing connection ");
        close();
        return LEVIN_ERROR_CONNECTION_TIMEDOUT;
      }
      if(!m_pservice_endpoint->call_run_once_service_io())
        return LEVIN_ERROR_CONNECTION_DESTROYED;
    }
 
    if(m_deletion_initiated || m_protocol_released)
      return LEVIN_ERROR_CONNECTION_DESTROYED;
 
    CRITICAL_REGION_BEGIN(m_local_inv_buff_lock);
    buff_out.swap(m_local_inv_buff);
    m_local_inv_buff.clear();
    CRITICAL_REGION_END();
 
    return m_invoke_result_code;
  }

Here is the caller graph for this function:

notify()

template<class t_connection_context = net_utils::connection_context_base>

int epee::levin::async_protocol_handler< t_connection_context >::notify ( int command, const epee::span< const uint8_t > in_buff )

inline

Definition at line 704 of file levin_protocol_handler_async.h.

  {
    misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
                          boost::bind(&async_protocol_handler::finish_outer_call, this));
 
    if(m_deletion_initiated)
      return LEVIN_ERROR_CONNECTION_DESTROYED;
 
    CRITICAL_REGION_LOCAL(m_call_lock);
 
    if(m_deletion_initiated)
      return LEVIN_ERROR_CONNECTION_DESTROYED;
 
    bucket_head2 head = {0};
    head.m_signature = SWAP64LE(LEVIN_SIGNATURE);
    head.m_have_to_return_data = false;
    head.m_cb = SWAP64LE(in_buff.size());
 
    head.m_command = SWAP32LE(command);
    head.m_protocol_version = SWAP32LE(LEVIN_PROTOCOL_VER_1);
    head.m_flags = SWAP32LE(LEVIN_PACKET_REQUEST);
    CRITICAL_REGION_BEGIN(m_send_lock);
    if(!m_pservice_endpoint->do_send(&head, sizeof(head)))
    {
      LOG_ERROR_CC(m_connection_context, "Failed to do_send()");
      return -1;
    }
 
    if(!m_pservice_endpoint->do_send(in_buff.data(), in_buff.size()))
    {
      LOG_ERROR_CC(m_connection_context, "Failed to do_send()");
      return -1;
    }
    CRITICAL_REGION_END();
    LOG_DEBUG_CC(m_connection_context, "LEVIN_PACKET_SENT. [len=" << head.m_cb <<
      ", f=" << head.m_flags << 
      ", r?=" << head.m_have_to_return_data <<
      ", cmd = " << head.m_command << 
      ", ver=" << head.m_protocol_version);
 
    return 1;
  }

Here is the caller graph for this function:

release_protocol()

template<class t_connection_context = net_utils::connection_context_base>

bool epee::levin::async_protocol_handler< t_connection_context >::release_protocol ( )

inline

Definition at line 323 of file levin_protocol_handler_async.h.

  {
    decltype(m_invoke_response_handlers) local_invoke_response_handlers;
    CRITICAL_REGION_BEGIN(m_invoke_response_handlers_lock);
    local_invoke_response_handlers.swap(m_invoke_response_handlers);
    m_protocol_released = true;
    CRITICAL_REGION_END();
 
    // Never call callback inside critical section, that can cause deadlock. Callback can be called when
    // invoke_response_handler_base is cancelled
    std::for_each(local_invoke_response_handlers.begin(), local_invoke_response_handlers.end(), [](const boost::shared_ptr<invoke_response_handler_base>& pinv_resp_hndlr) {
      pinv_resp_hndlr->cancel();
    });
 
    return true;
  }

request_callback()

template<class t_connection_context = net_utils::connection_context_base>

void epee::levin::async_protocol_handler< t_connection_context >::request_callback ( )

inline

Definition at line 353 of file levin_protocol_handler_async.h.

  {
    misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
      boost::bind(&async_protocol_handler::finish_outer_call, this));
 
    m_pservice_endpoint->request_callback();
  }

Here is the caller graph for this function:

start_outer_call()

template<class t_connection_context = net_utils::connection_context_base>

bool epee::levin::async_protocol_handler< t_connection_context >::start_outer_call ( )

inline

Definition at line 304 of file levin_protocol_handler_async.h.

  {
    MTRACE(m_connection_context << "[levin_protocol] -->> start_outer_call");
    if(!m_pservice_endpoint->add_ref())
    {
      MERROR(m_connection_context << "[levin_protocol] -->> start_outer_call failed");
      return false;
    }
    boost::interprocess::ipcdetail::atomic_inc32(&m_wait_count);
    return true;
  }

update_connection_context()

template<class t_connection_context = net_utils::connection_context_base>

void epee::levin::async_protocol_handler< t_connection_context >::update_connection_context ( const connection_context & contxt )

inline

Definition at line 348 of file levin_protocol_handler_async.h.

  {
    m_connection_context = contxt;
  }

Here is the caller graph for this function:

Friends And Related Symbol Documentation

anvoke_handler

template<class t_connection_context = net_utils::connection_context_base>

template<class callback_t>

friend struct anvoke_handler

friend

Definition at line 260 of file levin_protocol_handler_async.h.

Member Data Documentation

m_cache_in_buffer

template<class t_connection_context = net_utils::connection_context_base>

net_utils::buffer epee::levin::async_protocol_handler< t_connection_context >::m_cache_in_buffer

Definition at line 147 of file levin_protocol_handler_async.h.

m_call_lock

template<class t_connection_context = net_utils::connection_context_base>

critical_section epee::levin::async_protocol_handler< t_connection_context >::m_call_lock

Definition at line 138 of file levin_protocol_handler_async.h.

m_close_called

template<class t_connection_context = net_utils::connection_context_base>

volatile uint32_t epee::levin::async_protocol_handler< t_connection_context >::m_close_called

Definition at line 141 of file levin_protocol_handler_async.h.

m_config

template<class t_connection_context = net_utils::connection_context_base>

config_type& epee::levin::async_protocol_handler< t_connection_context >::m_config

Definition at line 144 of file levin_protocol_handler_async.h.

m_connection_context

template<class t_connection_context = net_utils::connection_context_base>

t_connection_context& epee::levin::async_protocol_handler< t_connection_context >::m_connection_context

Definition at line 145 of file levin_protocol_handler_async.h.

m_connection_initialized

template<class t_connection_context = net_utils::connection_context_base>

bool epee::levin::async_protocol_handler< t_connection_context >::m_connection_initialized

Definition at line 151 of file levin_protocol_handler_async.h.

m_current_head

template<class t_connection_context = net_utils::connection_context_base>

bucket_head2 epee::levin::async_protocol_handler< t_connection_context >::m_current_head

Definition at line 142 of file levin_protocol_handler_async.h.

m_deletion_initiated

template<class t_connection_context = net_utils::connection_context_base>

std::atomic<bool> epee::levin::async_protocol_handler< t_connection_context >::m_deletion_initiated

Definition at line 128 of file levin_protocol_handler_async.h.

m_invoke_buf_ready

template<class t_connection_context = net_utils::connection_context_base>

volatile uint32_t epee::levin::async_protocol_handler< t_connection_context >::m_invoke_buf_ready

Definition at line 130 of file levin_protocol_handler_async.h.

m_invoke_response_handlers

template<class t_connection_context = net_utils::connection_context_base>

std::list<boost::shared_ptr<invoke_response_handler_base> > epee::levin::async_protocol_handler< t_connection_context >::m_invoke_response_handlers

Definition at line 250 of file levin_protocol_handler_async.h.

m_invoke_response_handlers_lock

template<class t_connection_context = net_utils::connection_context_base>

critical_section epee::levin::async_protocol_handler< t_connection_context >::m_invoke_response_handlers_lock

Definition at line 249 of file levin_protocol_handler_async.h.

m_invoke_result_code

template<class t_connection_context = net_utils::connection_context_base>

volatile int epee::levin::async_protocol_handler< t_connection_context >::m_invoke_result_code

Definition at line 132 of file levin_protocol_handler_async.h.

m_local_inv_buff

template<class t_connection_context = net_utils::connection_context_base>

std::string epee::levin::async_protocol_handler< t_connection_context >::m_local_inv_buff

Definition at line 135 of file levin_protocol_handler_async.h.

m_local_inv_buff_lock

template<class t_connection_context = net_utils::connection_context_base>

critical_section epee::levin::async_protocol_handler< t_connection_context >::m_local_inv_buff_lock

Definition at line 134 of file levin_protocol_handler_async.h.

m_oponent_protocol_ver

template<class t_connection_context = net_utils::connection_context_base>

int32_t epee::levin::async_protocol_handler< t_connection_context >::m_oponent_protocol_ver

Definition at line 150 of file levin_protocol_handler_async.h.

m_protocol_released

template<class t_connection_context = net_utils::connection_context_base>

std::atomic<bool> epee::levin::async_protocol_handler< t_connection_context >::m_protocol_released

Definition at line 129 of file levin_protocol_handler_async.h.

m_pservice_endpoint

template<class t_connection_context = net_utils::connection_context_base>

net_utils::i_service_endpoint* epee::levin::async_protocol_handler< t_connection_context >::m_pservice_endpoint

Definition at line 143 of file levin_protocol_handler_async.h.

m_send_lock

template<class t_connection_context = net_utils::connection_context_base>

critical_section epee::levin::async_protocol_handler< t_connection_context >::m_send_lock

Definition at line 137 of file levin_protocol_handler_async.h.

m_state

template<class t_connection_context = net_utils::connection_context_base>

stream_state epee::levin::async_protocol_handler< t_connection_context >::m_state

Definition at line 148 of file levin_protocol_handler_async.h.

m_wait_count

template<class t_connection_context = net_utils::connection_context_base>

volatile uint32_t epee::levin::async_protocol_handler< t_connection_context >::m_wait_count

Definition at line 140 of file levin_protocol_handler_async.h.

---

The documentation for this class was generated from the following file:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/contrib/epee/include/net/levin_protocol_handler_async.h