Method read_loop

libraries/net/message_oriented_connection.cpp:162–272

    };

    void message_oriented_connection_impl::read_loop()
    {
      VERIFY_CORRECT_THREAD();
      const int BUFFER_SIZE = 16;
      const int LEFTOVER = BUFFER_SIZE - sizeof(message_header);
      static_assert(BUFFER_SIZE >= sizeof(message_header), "insufficient buffer");

      no_parallel_execution_guard guard( &_read_loop_in_progress );

      _connected_time = fc::time_point::now();

      fc::oexception exception_to_rethrow;
      bool call_on_connection_closed = false;
      bool io_error = false;

      try
      {
        message m;
        char buffer[BUFFER_SIZE];
        while( true )
        {
          try {
            _sock.read(buffer, BUFFER_SIZE);
          } catch ( const fc::canceled_exception& ) {
            io_error = true;
            throw;
          }
          _bytes_received += BUFFER_SIZE;
          memcpy((char*)&m, buffer, sizeof(message_header));
          FC_ASSERT( m.size.value() <= MAX_MESSAGE_SIZE, "", ("m.size",m.size.value())("MAX_MESSAGE_SIZE",MAX_MESSAGE_SIZE) );

          size_t remaining_bytes_with_padding = 16 * ((m.size.value() - LEFTOVER + 15) / 16);
          m.data.resize(LEFTOVER + remaining_bytes_with_padding); //give extra 16 bytes to allow for padding added in send call
          std::copy(buffer + sizeof(message_header), buffer + sizeof(buffer), m.data.begin());
          if (remaining_bytes_with_padding)
          {
            try {
              _sock.read(&m.data[LEFTOVER], remaining_bytes_with_padding);
            } catch ( const fc::canceled_exception& ) {
              io_error = true;
              throw;
            }
            _bytes_received += remaining_bytes_with_padding;
          }
          m.data.resize(m.size.value()); // truncate off the padding bytes

          _last_message_received_time = fc::time_point::now();

          try
          {
            // message handling errors are warnings...
            _delegate->on_message(_self, m);
          }
          /// Dedicated catches needed to distinguish from general fc::exception
          catch ( const fc::canceled_exception& e ) { throw; }
          catch ( const fc::eof_exception& e ) { throw; }
          catch ( const fc::exception& e)
          {