LCOV - code coverage report
Current view: top level - root/contrail/src/contrail-common/io - tcp_session.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 449 529 84.9 %
Date: 2026-11-16 02:06:09 Functions: 48 57 84.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #include "io/tcp_session.h"
       7             : 
       8             : #include <algorithm>
       9             : #include <string>
      10             : 
      11             : #include <boost/asio.hpp>
      12             : #include <boost/asio/detail/socket_option.hpp>
      13             : #include <boost/bind/bind.hpp>
      14             : #include <boost/scoped_array.hpp>
      15             : #include <boost/asio/detail/recycling_allocator.hpp>
      16             : 
      17             : #include "base/logging.h"
      18             : #include "base/address_util.h"
      19             : #include "io/event_manager.h"
      20             : #include "io/io_log.h"
      21             : #include "io/io_utils.h"
      22             : #include "io/tcp_message_write.h"
      23             : #include "io/tcp_server.h"
      24             : #include "base/address_util.h"
      25             : 
      26             : using boost::asio::async_write;
      27             : using boost::asio::buffer;
      28             : using boost::asio::buffer_cast;
      29             : using boost::asio::detail::socket_option::integer;
      30             : using boost::asio::const_buffer;
      31             : using boost::asio::mutable_buffer;
      32             : using boost::asio::mutable_buffers_1;
      33             : using boost::asio::null_buffers;
      34             : using boost::asio::socket_base;
      35             : using boost::bind;
      36             : using boost::function;
      37             : using boost::scoped_array;
      38             : using boost::system::error_code;
      39             : using std::min;
      40             : using std::ostringstream;
      41             : using std::string;
      42             : using namespace boost::placeholders;
      43             : 
      44             : using boost::asio::error::try_again;
      45             : using boost::asio::error::would_block;
      46             : using boost::asio::error::in_progress;
      47             : using boost::asio::error::interrupted;
      48             : using boost::asio::error::network_down;
      49             : using boost::asio::error::network_reset;
      50             : using boost::asio::error::network_unreachable;
      51             : using boost::asio::error::no_buffer_space;
      52             : using boost::asio::placeholders::error;
      53             : using boost::asio::placeholders::bytes_transferred;
      54             : using boost::asio::ip::tcp;
      55             : 
      56             : int TcpSession::reader_task_id_ = -1;
      57             : 
      58             : class TcpSession::Reader : public Task {
      59             : public:
      60             :     typedef function<void(Buffer)> ReadHandler;
      61             : 
      62        4725 :     Reader(TcpSessionPtr session, ReadHandler read_fn, Buffer buffer)
      63       18900 :         : Task(session->reader_task_id(), session->GetSessionInstance()),
      64        4725 :           session_(session), read_fn_(read_fn), buffer_(buffer) {
      65        4725 :     }
      66        4725 :     virtual bool Run() {
      67        4725 :         if (session_->IsEstablished()) {
      68        4698 :             read_fn_(buffer_);
      69        4698 :             if (session_->IsReaderDeferred()) {
      70             :                 // Update socket read block count.
      71           1 :                 session_->stats_.read_block_start_time = UTCTimestampUsec();
      72           1 :                 session_->stats_.read_blocked++;
      73           1 :                 session_->server_->stats_.read_blocked++;
      74             :             } else {
      75        4697 :                 session_->AsyncReadStart();
      76             :             }
      77             :         }
      78        4725 :         return true;
      79             :     }
      80           0 :     string Description() const { return "TcpSession::Reader"; }
      81             : 
      82             : private:
      83             :     TcpSessionPtr session_;
      84             :     ReadHandler read_fn_;
      85             :     Buffer buffer_;
      86             : };
      87             : 
      88        1309 : TcpSession::TcpSession(
      89             :     TcpServer *server, Socket *socket, bool async_read_ready,
      90        1309 :     size_t buffer_send_size)
      91        1310 :     : server_(server),
      92        1310 :       socket_(socket),
      93        1310 :       read_on_connect_(async_read_ready),
      94        1310 :       established_(false),
      95        1310 :       closed_(false),
      96        1309 :       direction_(ACTIVE),
      97        1310 :       writer_(new TcpMessageWriter(this, buffer_send_size)),
      98        3929 :       name_("-") {
      99        1310 :     refcount_ = 0;
     100        1310 :     if (reader_task_id_ == -1) {
     101          60 :         TaskScheduler *scheduler = TaskScheduler::GetInstance();
     102          60 :         reader_task_id_ = scheduler->GetTaskId("io::ReaderTask");
     103             :     }
     104        1310 :     if (server_) {
     105        1307 :         io_strand_.reset(new Strand(server->event_manager()->io_service()->get_executor()));
     106             :     }
     107        1310 :     defer_reader_ = false;
     108        1310 :     write_blocked_ = false;
     109        1310 :     tcp_close_in_progress_ = false;
     110        1310 : }
     111             : 
     112        1308 : TcpSession::~TcpSession() {
     113        1308 :     assert(!established_);
     114        1308 :     for (BufferQueue::iterator iter = buffer_queue_.begin();
     115        5758 :          iter != buffer_queue_.end(); ++iter) {
     116        4448 :         DeleteBuffer(*iter);
     117             :     }
     118        1309 :     buffer_queue_.clear();
     119        1309 : }
     120             : 
     121       89743 : mutable_buffer TcpSession::AllocateBuffer(size_t buffer_size) {
     122       89743 :     uint8_t *data = new uint8_t[buffer_size];
     123       89743 :     mutable_buffer buffer = mutable_buffer(data, buffer_size);
     124       89743 :     buffer_queue_.push_back(buffer);
     125       89743 :     return buffer;
     126             : }
     127             : 
     128       89736 : void TcpSession::DeleteBuffer(mutable_buffer buffer) {
     129       89736 :     uint8_t *data = buffer_cast<uint8_t *>(buffer);
     130       89736 :     delete[] data;
     131       89743 : }
     132             : 
     133       85824 : static int BufferCmp(const mutable_buffer &lhs, const const_buffer &rhs) {
     134       85824 :     const uint8_t *lp = buffer_cast<uint8_t *>(lhs);
     135       85824 :     const uint8_t *rp = buffer_cast<const uint8_t *>(rhs);
     136       85824 :     if (lp < rp) {
     137         489 :         return -1;
     138             :     }
     139       85335 :     if (lp > rp) {
     140          43 :         return 1;
     141             :     }
     142       85292 :     return 0;
     143             : }
     144             : 
     145       84780 : void TcpSession::ReleaseBuffer(Buffer buffer) {
     146       84780 :     std::scoped_lock lock(mutex_);
     147       84780 :     ReleaseBufferLocked(buffer);
     148       84780 : }
     149             : 
     150       85293 : void TcpSession::ReleaseBufferLocked(Buffer buffer) {
     151       85293 :     for (BufferQueue::iterator iter = buffer_queue_.begin();
     152       85825 :          iter != buffer_queue_.end(); ++iter) {
     153       85825 :         if (BufferCmp(*iter, buffer) == 0) {
     154       85292 :             DeleteBuffer(*iter);
     155       85293 :             buffer_queue_.erase(iter);
     156       85293 :             return;
     157             :         }
     158             :     }
     159           0 :     assert(false);
     160             : }
     161             : 
     162       90233 : void TcpSession::AsyncReadStartInternal(TcpSessionPtr session) {
     163             :     // Update socket read block time.
     164       90233 :     if (stats_.read_block_start_time) {
     165           1 :         uint64_t blocked_usecs = UTCTimestampUsec() -
     166           1 :             stats_.read_block_start_time;
     167           1 :         stats_.read_block_start_time = 0;
     168           1 :         stats_.read_blocked_duration_usecs += blocked_usecs;
     169           1 :         server_->stats_.read_blocked_duration_usecs += blocked_usecs;
     170             :     }
     171             : 
     172       90233 :     std::scoped_lock lock(mutex_);
     173       90233 :     AsyncReadSome();
     174       90233 : }
     175             : 
     176       90239 : void TcpSession::AsyncReadStart() {
     177       90239 :     if (io_strand_) {
     178       90239 :         boost::asio::detail::recycling_allocator<void> allocator;
     179      180479 :         io_strand_->post(bind(&TcpSession::AsyncReadStartInternal, this,
     180      180476 :                          TcpSessionPtr(this)), allocator);
     181             :     }
     182       90240 : }
     183             : 
     184           2 : void TcpSession::SetDeferReader(bool defer_reader) {
     185           2 :     if (defer_reader_ != defer_reader) {
     186           2 :         defer_reader_ = defer_reader;
     187             :         // Call AsyncReadStart if reader was previously deferred
     188           2 :         if (!defer_reader_) {
     189           1 :             AsyncReadStart();
     190             :         }
     191             :     }
     192           2 : }
     193             : 
     194       11647 : void TcpSession::AsyncReadSome() {
     195       11647 :     if (IsEstablishedLocked()) {
     196       23292 :         socket()->async_read_some(null_buffers(),
     197       23292 :             bind(&TcpSession::AsyncReadHandler, TcpSessionPtr(this)));
     198             :     }
     199       11647 : }
     200             : 
     201       69613 : void TcpSession::AsyncWrite(const uint8_t *data, std::size_t size) {
     202       69613 :     async_write(*socket(), buffer(data, size),
     203      139226 :         bind(&TcpSession::AsyncWriteHandler, TcpSessionPtr(this),
     204             :              error, bytes_transferred));
     205       69613 : }
     206             : 
     207      205409 : TcpSession::Endpoint TcpSession::local_endpoint() const {
     208      205409 :     std::scoped_lock lock(mutex_);
     209      205409 :     if (!established_)
     210           0 :         return Endpoint();
     211             : 
     212      205409 :     error_code error;
     213      205409 :     Endpoint local = socket()->local_endpoint(error);
     214      205409 :     if (error) {
     215           0 :         return Endpoint();
     216             :     }
     217      205409 :     return local;
     218      205409 : }
     219             : 
     220        2585 : void TcpSession::set_observer(EventObserver observer) {
     221        2585 :     std::scoped_lock lock(obs_mutex_);
     222        2586 :     observer_ = observer;
     223        2583 : }
     224             : 
     225        1150 : void TcpSession::SetName() {
     226        1150 :     ostringstream out;
     227        1150 :     error_code error;
     228        1150 :     Endpoint local;
     229             : 
     230        1150 :     local = socket()->local_endpoint(error);
     231        1150 :     out << local.address().to_string() << ":" << local.port() << "::";
     232        1150 :     out << remote_.address().to_string() << ":" << remote_.port();
     233             : 
     234        1150 :     name_ = out.str();
     235             : 
     236        1150 :     out.str("");
     237        1150 :     std::string hostname = "";
     238        1150 :     if (local.address().is_v4()) {
     239        1147 :         hostname = ResolveCanonicalName(local.address().to_string());
     240             :     } else {
     241           3 :         hostname = ResolveCanonicalNameIPv6(local.address().to_string());
     242             :     }
     243        1150 :     out << hostname << ":" << remote_.address().to_string();
     244        1150 :     uve_key_str_ = out.str();
     245        1150 : }
     246             : 
     247        1150 : void TcpSession::SessionEstablished(Endpoint remote,
     248             :                                     Direction direction) {
     249        1150 :     established_ = true;
     250        1150 :     remote_ = remote;
     251        1150 :     remote_addr_str_ = remote.address().to_string();
     252        1150 :     direction_ = direction;
     253        1150 :     SetName();
     254        1150 : }
     255             : 
     256         511 : void TcpSession::Accepted() {
     257         511 :     TCP_SESSION_LOG_DEBUG(this, TCP_DIR_OUT,
     258             :                           "Passive session Accept complete");
     259             :     {
     260         511 :         std::scoped_lock obs_lock(obs_mutex_);
     261         511 :         if (observer_) {
     262         171 :             observer_(this, ACCEPT);
     263             :         }
     264         511 :     }
     265             : 
     266         511 :     if (read_on_connect_) {
     267         214 :         AsyncReadStart();
     268             :     }
     269         511 : }
     270             : 
     271         599 : bool TcpSession::Connected(Endpoint remote) {
     272         599 :     assert(refcount_);
     273             : 
     274             :     {
     275         599 :         std::scoped_lock lock(mutex_);
     276         599 :         if (closed_) {
     277           0 :             return false;
     278             :         }
     279         599 :         SessionEstablished(remote, TcpSession::ACTIVE);
     280         599 :     }
     281         599 :     SetSocketOptions();
     282             : 
     283         599 :     TCP_SESSION_LOG_DEBUG(this, TCP_DIR_IN,
     284             :                           "Active session connection complete");
     285             : 
     286             :     {
     287         599 :         std::scoped_lock obs_lock(obs_mutex_);
     288         599 :         if (observer_) {
     289         599 :             observer_(this, CONNECT_COMPLETE);
     290             :         }
     291         599 :     }
     292             : 
     293         599 :     if (read_on_connect_) {
     294         599 :         AsyncReadStart();
     295             :     }
     296         599 :     return true;
     297             : }
     298             : 
     299          88 : void TcpSession::ConnectFailed() {
     300          88 :     std::scoped_lock obs_lock(obs_mutex_);
     301          88 :     if (observer_) {
     302          88 :         observer_(this, CONNECT_FAILED);
     303             :     }
     304          88 : }
     305             : 
     306             : // Requires: lock must not be held
     307        1307 : void TcpSession::CloseInternal(const error_code &ec,
     308             :                                bool call_observer, bool notify_server) {
     309        1307 :     std::unique_lock<std::mutex> lock(mutex_);
     310             : 
     311        1307 :     if (socket() != NULL && !closed_) {
     312        1307 :         error_code error;
     313        1307 :         socket()->shutdown(tcp::socket::shutdown_both, error);
     314        1307 :         if (error) {
     315         309 :             TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     316             :                 "Shutdown failed due to error: " << error.message());
     317             :         }
     318        1307 :         socket()->close(error);
     319             :     }
     320        1307 :     closed_ = true;
     321        1307 :     tcp_close_in_progress_ = false;
     322             : 
     323        1307 :     if (!established_) {
     324         157 :         return;
     325             :     }
     326        1150 :     established_ = false;
     327             : 
     328             :     // copy the ec to close reason
     329        1150 :     close_reason_ = ec;
     330             : 
     331             :     // Take a reference through intrusive pointer to protect session from
     332             :     // possibly getting deleted from another thread.
     333        1150 :     TcpSessionPtr session = TcpSessionPtr(this);
     334        1150 :     lock.unlock();
     335             : 
     336        1150 :     if (call_observer) {
     337         629 :         std::scoped_lock obs_lock(obs_mutex_);
     338         629 :         if (observer_) {
     339         362 :             observer_(this, CLOSE);
     340             :         }
     341         629 :     }
     342             : 
     343        1150 :     if (notify_server) {
     344        1110 :         server_->OnSessionClose(this);
     345             :     }
     346        1306 : }
     347             : 
     348       78570 : void TcpSession::TriggerAsyncReadHandler() {
     349       78570 :     if (io_strand_) {
     350       78570 :         boost::asio::detail::recycling_allocator<void> allocator;
     351      157140 :         io_strand_->post(bind(&TcpSession::AsyncReadHandler,
     352      157140 :                               TcpSessionPtr(this)), allocator);
     353             :     }
     354       78570 : }
     355             : 
     356        2306 : void TcpSession::Close() {
     357        2306 :     std::unique_lock<std::mutex> lock(mutex_);
     358             : 
     359             :     // Close can be called by application during cleanup. At this time
     360             :     // session may be already closed due to error and there may be write
     361             :     // data in the buffer, ignore if socket is closed.
     362        2306 :     if (closed_) {
     363        1523 :         return;
     364             :     }
     365             : 
     366         783 :     if (server_ && writer_->IsWritePending()) {
     367         147 :         tcp_close_in_progress_ = true;
     368         147 :         return;
     369             :     }
     370         636 :     lock.unlock();
     371             : 
     372         636 :     error_code ec;
     373         636 :     CloseInternal(ec, false);
     374        2306 : }
     375             : 
     376             : // virtual method overriden in derrived classes.
     377           2 : void TcpSession::WriteReady(const error_code &error) {
     378           2 : }
     379             : 
     380      136213 : void TcpSession::AsyncWriteHandler(TcpSessionPtr session,
     381             :                                    const error_code &error,
     382             :                                    std::size_t wrote) {
     383      136213 :     std::unique_lock<std::mutex> lock(session->mutex_);
     384      136213 :     if (session->IsSocketErrorHard(error)) {
     385           0 :         lock.unlock();
     386           0 :         TCP_SESSION_LOG_ERROR(session, TCP_DIR_OUT,
     387             :                               "Write failed due to error: " << error.message());
     388           0 :         session->CloseInternal(error, true);
     389           0 :         return;
     390             :     }
     391             : 
     392             :     //
     393             :     // Ignore if connection is already closed.
     394             :     //
     395      136213 :     if (session->IsClosedLocked()) return;
     396             : 
     397             :     // Update socket write bytes statistics.
     398      136212 :     session->stats_.write_bytes += wrote;
     399      136212 :     session->server_->stats_.write_bytes += wrote;
     400             : 
     401      136212 :     bool send_ready = false;
     402      136212 :     bool more_write = session->writer_->UpdateBufferQueue(wrote, &send_ready);
     403             : 
     404             :     // Subsequent write
     405      136212 :     if (more_write) {
     406       18315 :         session->writer_->TriggerAsyncWrite();
     407      117897 :     } else if (session->tcp_close_in_progress_) {
     408         116 :         lock.unlock();
     409         116 :         session->CloseInternal(error, true);
     410         116 :         return;
     411             :     }
     412             : 
     413      136096 :     lock.unlock();
     414      136096 :     if (send_ready)
     415           4 :         session->WriteReady(error);
     416      136096 :     return;
     417      136213 : }
     418             : 
     419      117898 : void TcpSession::AsyncWriteInternal(TcpSessionPtr session) {
     420             : 
     421      117898 :     std::scoped_lock lock(session->mutex_);
     422             : 
     423             :     //
     424             :     // Ignore if connection is already closed.
     425             :     //
     426      117898 :     if (session->IsClosedLocked()) return;
     427      117898 :     session->writer_->TriggerAsyncWrite();
     428      117898 : }
     429             : 
     430      134101 : bool TcpSession::Send(const uint8_t *data, size_t size, size_t *sent) {
     431      134101 :     bool ret = true;
     432      134101 :     std::unique_lock<std::mutex> lock(mutex_);
     433             : 
     434             :     // Reset sent, if provided.
     435      134100 :     if (sent) *sent = 0;
     436             : 
     437             :     //
     438             :     // If the session closed in the mean while, bail out
     439             :     // If session close is triggered, but close in progress, bail out
     440             :     //
     441      134100 :     if (!IsEstablishedLocked()) return false;
     442             : 
     443      133963 :     if (socket()->non_blocking()) {
     444      133951 :         error_code error;
     445      133951 :         int len = writer_->AsyncSend(data, size, &error);
     446      133843 :         lock.unlock();
     447      133964 :         if (len < 0) {
     448           0 :             TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     449             :                                   "Write failed due to error: "
     450             :                                   << error.category().name() << " "
     451             :                                   << error.message());
     452           0 :             CloseInternal(error, true);
     453           0 :             return false;
     454             :         }
     455      133964 :         if ((size_t) len != size)
     456          14 :             ret = false;
     457      133964 :         if (sent) *sent = (len > 0) ? len : 0;
     458             :     }
     459      133964 :     return ret;
     460      134091 : }
     461             : 
     462        4725 : Task* TcpSession::CreateReaderTask(mutable_buffer buffer,
     463             :                                   size_t bytes_transferred) {
     464        4725 :     Buffer rdbuf(buffer_cast<const uint8_t *>(buffer), bytes_transferred);
     465        4725 :     Reader *task = new Reader(TcpSessionPtr(this),
     466        4725 :                               bind(&TcpSession::OnRead, this, _1), rdbuf);
     467        4725 :     return (task);
     468             : }
     469             : 
     470       18840 : size_t TcpSession::ReadSome(mutable_buffer buffer, error_code *error) {
     471       18840 :     return socket()->read_some(mutable_buffers_1(buffer), *error);
     472             : }
     473             : 
     474             : // Tests with large data have shown large amounts of data being read in one
     475             : // read_some() call, if available. Hence, allocate memory for all the bytes
     476             : // available in the socket, but no less t han kDefaultBufferSize.
     477        5060 : size_t TcpSession::GetReadBufferSize() const {
     478        5060 :     error_code error;
     479        5060 :     size_t size = socket_->available(error);
     480        5060 :     if (size < kDefaultBufferSize)
     481        4758 :         size = kDefaultBufferSize;
     482        5060 :     return size;
     483             : }
     484             : 
     485       90168 : void TcpSession::AsyncReadHandler(TcpSessionPtr session) {
     486       90168 :     std::unique_lock<std::mutex> lock(session->mutex_);
     487       90168 :     if (session->closed_) {
     488         425 :         return;
     489             :     }
     490             : 
     491             :     mutable_buffer buffer =
     492       89743 :         session->AllocateBuffer(session->GetReadBufferSize());
     493             : 
     494       89743 :     error_code error;
     495       89743 :     size_t bytes_transferred = session->ReadSome(buffer, &error);
     496       89743 :     if (session->IsSocketErrorHard(error)) {
     497         513 :         session->ReleaseBufferLocked(buffer);
     498             :         // eof is returned when the peer closed the socket, no need to log error
     499         513 :         if (error != boost::asio::error::eof) {
     500          73 :             if (strcmp(error.category().name(), "asio.ssl") == 0  &&
     501           0 :                 error.value() == SSL_SHORT_READ_ERROR) {
     502           0 :             TCP_SESSION_LOG_DEBUG(session, TCP_DIR_IN,
     503             :                     "Read failed due to error "
     504             :                     << error.category().name() << " "
     505             :                     << error.value()
     506             :                     << " : " << error.message());
     507             :             } else {
     508          73 :             TCP_SESSION_LOG_ERROR(session, TCP_DIR_IN,
     509             :                     "Read failed due to error "
     510             :                     << error.category().name() << " "
     511             :                     << error.value()
     512             :                     << " : " << error.message());
     513             :             }
     514             :         }
     515         513 :         lock.unlock();
     516         513 :         session->CloseInternal(error, true);
     517         513 :         return;
     518             :     }
     519             : 
     520             :     // Update read statistics.
     521       89230 :     session->stats_.read_calls++;
     522       89230 :     session->stats_.read_bytes += bytes_transferred;
     523       89230 :     session->server_->stats_.read_calls++;
     524       89230 :     session->server_->stats_.read_bytes += bytes_transferred;
     525             : 
     526       89230 :     Task *task = session->CreateReaderTask(buffer, bytes_transferred);
     527             :     // Starting a new task for the session
     528       89230 :     TaskScheduler *scheduler = TaskScheduler::GetInstance();
     529       89230 :     scheduler->Enqueue(task);
     530       90168 : }
     531             : 
     532        4462 : int TcpSession::GetSessionInstance() const {
     533        4462 :     return Task::kTaskInstanceAny;
     534             : }
     535             : 
     536             : 
     537         608 : int32_t TcpSession::local_port() const {
     538         608 :     if (socket() == NULL) {
     539           0 :         return -1;
     540             :     }
     541         608 :     error_code error;
     542         608 :     Endpoint local = socket()->local_endpoint(error);
     543         608 :     if (IsSocketErrorHard(error)) {
     544           0 :         return -1;
     545             :     }
     546         608 :     return local.port();
     547             : }
     548             : 
     549         608 : int32_t TcpSession::remote_port() const {
     550         608 :     if (socket() == NULL) {
     551           0 :         return -1;
     552             :     }
     553         608 :     error_code error;
     554         608 :     Endpoint remote = socket()->remote_endpoint(error);
     555         608 :     if (IsSocketErrorHard(error)) {
     556         161 :         return -1;
     557             :     }
     558         447 :     return remote.port();
     559             : }
     560             : 
     561           0 : int TcpSession::SetMd5SocketOption(uint32_t peer_ip,
     562             :                                    const string &md5_password) {
     563           0 :     return server()->SetMd5SocketOption(socket_->native_handle(), peer_ip,
     564           0 :                                         md5_password);
     565             : }
     566             : 
     567           0 : int TcpSession::ClearMd5SocketOption(uint32_t peer_ip) {
     568           0 :     return server()->SetMd5SocketOption(socket_->native_handle(), peer_ip, "");
     569             : }
     570             : 
     571          60 : int TcpSession::SetDscpSocketOption(uint8_t value) {
     572          60 :     return server()->SetDscpSocketOption(socket()->native_handle(), value);
     573             : }
     574             : 
     575           0 : uint8_t TcpSession::GetDscpValue() const {
     576           0 :     return server_->GetDscpValue(socket()->native_handle());
     577             : }
     578             : 
     579         295 : TcpMessageReader::TcpMessageReader(TcpSession *session,
     580         295 :                                    ReceiveCallback callback)
     581         295 :     : session_(session), callback_(callback), offset_(0), remain_(-1) {
     582         295 : }
     583             : 
     584         298 : TcpMessageReader::~TcpMessageReader() {
     585         298 : }
     586             : 
     587             : // Returns a buffer allocation size that is larger than the message.
     588           2 : int TcpMessageReader::AllocBufferSize(int length) {
     589           2 :     const int kMaxMessageSize = GetMaxMessageSize();
     590           2 :     if (length == -1) {
     591           0 :         return kMaxMessageSize;
     592             :     }
     593           2 :     int bufsize = 1 << 8;
     594           3 :     for (; bufsize < kMaxMessageSize && bufsize < length; bufsize <<= 1) {
     595             :     }
     596           2 :     return bufsize;
     597             : }
     598             : 
     599           2 : uint8_t *TcpMessageReader::BufferConcat(uint8_t *data, Buffer buffer,
     600             :                                         int msglength) {
     601           2 :     uint8_t *dst = data;
     602             : 
     603           7 :     while (!queue_.empty()) {
     604           5 :         Buffer head = queue_.front();
     605           5 :         const uint8_t *cp = TcpSession::BufferData(head) + offset_;
     606           5 :         int bytes = TcpSession::BufferSize(head) - offset_;
     607           5 :         assert((dst - data) + bytes < msglength);
     608           5 :         memcpy(dst, cp, bytes);
     609           5 :         dst += bytes;
     610           5 :         queue_.pop_front();
     611           5 :         session_->ReleaseBuffer(head);
     612           5 :         offset_ = 0;
     613           5 :         remain_ = -1;
     614             :     }
     615             : 
     616           2 :     int count = msglength - (dst - data);
     617           2 :     assert((dst - data) + count <= msglength);
     618           2 :     memcpy(dst, TcpSession::BufferData(buffer), count);
     619           2 :     offset_ = count;
     620             : 
     621           2 :     return data;
     622             : }
     623             : 
     624           3 : int TcpMessageReader::QueueByteLength() const {
     625           3 :     int total = 0;
     626           3 :     for (BufferQueue::const_iterator iter = queue_.begin();
     627           9 :          iter != queue_.end(); ++iter) {
     628           6 :         if (total == 0) {
     629           3 :             total = TcpSession::BufferSize(*iter) - offset_;
     630             :         } else {
     631           3 :             total += TcpSession::BufferSize(*iter);
     632             :         }
     633             :     }
     634           3 :     return total;
     635             : }
     636             : 
     637           2 : TcpMessageReader::Buffer TcpMessageReader::PullUp(
     638             :                uint8_t *data, Buffer buffer, size_t size) const {
     639           2 :     size_t offset = 0;
     640             : 
     641           2 :     for (BufferQueue::const_iterator iter = queue_.begin();
     642           7 :          iter != queue_.end(); ++iter) {
     643             :         const uint8_t *cp;
     644             :         int avail;
     645           5 :         if (offset == 0) {
     646           2 :             cp = TcpSession::BufferData(*iter) + offset_;
     647           2 :             avail = TcpSession::BufferSize(*iter) - offset_;
     648             :         } else {
     649           3 :             cp = TcpSession::BufferData(*iter);
     650           3 :             avail = TcpSession::BufferSize(*iter);
     651             :         }
     652           5 :         int remain = size - offset;
     653           5 :         avail = min(avail, remain);
     654           5 :         assert(offset + avail <= size);
     655           5 :         memcpy(data + offset, cp, avail);
     656           5 :         offset += avail;
     657             :     }
     658             : 
     659           2 :     int avail = TcpSession::BufferSize(buffer);
     660           2 :     int remain = size - offset;
     661           2 :     avail = min(avail, remain);
     662           2 :     assert(offset + avail <= size);
     663           2 :     memcpy(data + offset, TcpSession::BufferData(buffer), avail);
     664           2 :     offset += avail;
     665             : 
     666           2 :     if (offset < size) {
     667           0 :         return Buffer();
     668             :     }
     669           2 :     return Buffer(data, size);
     670             : }
     671             : 
     672             : // Read the socket stream and send messages to the peer object.
     673        4109 : void TcpMessageReader::OnRead(Buffer buffer) {
     674        4109 :     const int kHeaderLenSize = GetHeaderLenSize();
     675        4109 :     size_t size = TcpSession::BufferSize(buffer);
     676        4109 :     TCP_SESSION_LOG_UT_DEBUG(session_, TCP_DIR_IN, "Read " << size << " bytes");
     677             : 
     678        4109 :     if (!queue_.empty()) {
     679           5 :         int msglength = MsgLength(queue_.front(), offset_);
     680           5 :         if (msglength < 0) {
     681           3 :             int queuelen = QueueByteLength();
     682           3 :             if (queuelen + static_cast<int>(size) < kHeaderLenSize) {
     683           1 :                 queue_.push_back(buffer);
     684           1 :                 return;
     685             :             }
     686           2 :             scoped_array<uint8_t> data(new uint8_t[kHeaderLenSize]);
     687           2 :             Buffer header = PullUp(data.get(), buffer, kHeaderLenSize);
     688           2 :             assert(TcpSession::BufferSize(header) == (size_t) kHeaderLenSize);
     689             : 
     690           2 :             msglength = MsgLength(header, 0);
     691           2 :             remain_ = msglength - queuelen;
     692           2 :         }
     693             : 
     694           4 :         assert(remain_ > 0);
     695           4 :         if (size < (size_t) remain_) {
     696           2 :             queue_.push_back(buffer);
     697           2 :             remain_ -= size;
     698           2 :             return;
     699             :         }
     700             : 
     701             :         // concat the buffers into a contiguous message.
     702           2 :         scoped_array<uint8_t> data(new uint8_t[AllocBufferSize(msglength)]);
     703           2 :         BufferConcat(data.get(), buffer, msglength);
     704           2 :         assert(remain_ == -1);
     705             :         // Receive the message
     706           2 :         bool success = callback_(data.get(), msglength);
     707           2 :         if (!success)
     708           0 :             return;
     709           2 :     }
     710             : 
     711        4106 :     int avail = size - offset_;
     712       13951 :     while (avail > 0) {
     713        9848 :         int msglength = MsgLength(buffer, offset_);
     714        9848 :         if (msglength < 0) {
     715           1 :             break;
     716             :         }
     717        9847 :         if (msglength > avail) {
     718           1 :             remain_ = msglength - avail;
     719           1 :             break;
     720             :         }
     721             :         // Receive the message
     722             :         bool success =
     723        9846 :             callback_(TcpSession::BufferData(buffer) + offset_, msglength);
     724        9846 :         offset_ += msglength;
     725        9846 :         avail -= msglength;
     726        9846 :         if (!success)
     727           1 :             return;
     728             :     }
     729             : 
     730        4105 :     if (avail > 0) {
     731           2 :         queue_.push_back(buffer);
     732             :     } else {
     733        4103 :         session_->ReleaseBuffer(buffer);
     734        4103 :         offset_ = 0;
     735        4103 :         assert(remain_ == -1);
     736             :     }
     737             : }
     738             : 
     739             : //
     740             : // Check if a socker error is hard and fatal. Only then should we close the
     741             : // socket. Soft errors like EINTR and EAGAIN should be ignored or properly
     742             : // handled with retries
     743             : //
     744      227172 : bool TcpSession::IsSocketErrorHard(const error_code &ec) {
     745      227172 :     if (!ec)
     746      220566 :         return false;
     747        6606 :     if (ec == try_again)
     748        5932 :         return false;
     749         674 :     if (ec == would_block)
     750           0 :         return false;
     751         674 :     if (ec == in_progress)
     752           0 :         return false;
     753         674 :     if (ec == interrupted)
     754           0 :         return false;
     755         674 :     if (ec == network_down)
     756           0 :         return false;
     757         674 :     if (ec == network_reset)
     758           0 :         return false;
     759         674 :     if (ec == network_unreachable)
     760           0 :         return false;
     761         674 :     if (ec == no_buffer_space)
     762           0 :         return false;
     763             : 
     764         674 :     return true;
     765             : }
     766             : 
     767           0 : error_code TcpSession::SetTcpNoDelay() {
     768           0 :     error_code ec;
     769           0 :     boost::asio::ip::tcp::no_delay no_delay_option(true);
     770           0 :     socket()->set_option(no_delay_option, ec);
     771           0 :     if (ec) {
     772           0 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     773             :                 "tcp_no_delay set error: " << ec);
     774             :     }
     775           0 :     return ec;
     776             : }
     777             : 
     778           0 : error_code TcpSession::SetTcpSendBufSize(uint32_t size) {
     779           0 :     error_code ec;
     780           0 :     socket_base::send_buffer_size send_buffer_size_option(size);
     781           0 :     socket()->set_option(send_buffer_size_option, ec);
     782           0 :     if (ec) {
     783           0 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     784             :                               "send_buffer_size set error: " << ec);
     785           0 :         return ec;
     786             :     }
     787             : 
     788           0 :     return ec;
     789             : }
     790             : 
     791           0 : error_code TcpSession::SetTcpRecvBufSize(uint32_t size) {
     792           0 :     error_code ec;
     793           0 :     socket_base::receive_buffer_size receive_buffer_size_option(size);
     794           0 :     socket()->set_option(receive_buffer_size_option, ec);
     795           0 :     if (ec) {
     796           0 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_IN,
     797             :                               "receive_buffer_size set error: " << ec);
     798           0 :         return ec;
     799             :     }
     800             : 
     801           0 :     return ec;
     802             : }
     803             : 
     804         327 : error_code TcpSession::SetSocketKeepaliveOptions(int keepalive_time,
     805             :         int keepalive_intvl, int keepalive_probes, int tcp_user_timeout_val) {
     806         327 :     error_code ec;
     807         327 :     socket_base::keep_alive keep_alive_option(true);
     808         327 :     socket()->set_option(keep_alive_option, ec);
     809         327 :     if (ec) {
     810          22 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     811             :                 "keep_alive set error: " << ec);
     812          22 :         return ec;
     813             :     }
     814             : #ifdef TCP_KEEPIDLE
     815             :     typedef integer< IPPROTO_TCP, TCP_KEEPIDLE > keepalive_idle_time;
     816         305 :     keepalive_idle_time keepalive_idle_time_option(keepalive_time);
     817         305 :     socket()->set_option(keepalive_idle_time_option, ec);
     818         305 :     if (ec) {
     819           0 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     820             :             "keepalive_idle_time: " << keepalive_time << " set error: " << ec);
     821           0 :         return ec;
     822             :     }
     823             : #elif TCP_KEEPALIVE
     824             :     typedef integer< IPPROTO_TCP, TCP_KEEPALIVE > keepalive_idle_time;
     825             :     keepalive_idle_time keepalive_idle_time_option(keepalive_time);
     826             :     socket()->set_option(keepalive_idle_time_option, ec);
     827             :     if (ec) {
     828             :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     829             :             "keepalive_idle_time: " << keepalive_time << " set error: " << ec);
     830             :         return ec;
     831             :     }
     832             : #else
     833             : #error No TCP keepalive option defined.
     834             : #endif
     835             : #ifdef TCP_KEEPINTVL
     836             :     typedef integer< IPPROTO_TCP, TCP_KEEPINTVL > keepalive_interval;
     837         305 :     keepalive_interval keepalive_interval_option(keepalive_intvl);
     838         305 :     socket()->set_option(keepalive_interval_option, ec);
     839         305 :     if (ec) {
     840           0 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     841             :             "keepalive_interval: " << keepalive_intvl << " set error: " << ec);
     842           0 :         return ec;
     843             :     }
     844             : #endif
     845             : #ifdef TCP_KEEPCNT
     846             :     typedef integer< IPPROTO_TCP, TCP_KEEPCNT > keepalive_count;
     847         305 :     keepalive_count keepalive_count_option(keepalive_probes);
     848         305 :     socket()->set_option(keepalive_count_option, ec);
     849         305 :     if (ec) {
     850           0 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     851             :             "keepalive_probes: " << keepalive_probes << " set error: " << ec);
     852           0 :         return ec;
     853             :     }
     854             : #endif
     855             : #ifdef TCP_USER_TIMEOUT
     856             :     typedef integer< IPPROTO_TCP, TCP_USER_TIMEOUT > tcp_user_timeout;
     857         305 :     tcp_user_timeout tcp_user_timeout_option(tcp_user_timeout_val);
     858         305 :     socket()->set_option(tcp_user_timeout_option, ec);
     859         305 :     if (ec) {
     860           0 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     861             :             "tcp_user_timeout: " << tcp_user_timeout_val << " set error: "
     862             :             << ec);
     863           0 :         return ec;
     864             :     }
     865             : #endif
     866             : 
     867         305 :     return ec;
     868             : }
     869             : 
     870        1893 : error_code TcpSession::SetSocketOptions() {
     871        1893 :     error_code ec;
     872             : 
     873             :     //
     874             :     // Make socket write non-blocking
     875             :     //
     876        1893 :     socket()->non_blocking(true, ec);
     877        1893 :     if (ec) {
     878           0 :         TCP_SESSION_LOG_ERROR(this, TCP_DIR_NA,
     879             :                               "Cannot set socket non blocking: " << ec);
     880           0 :         return ec;
     881             :     }
     882             : 
     883        1893 :     char *buffer_size_str = getenv("TCP_SESSION_SOCKET_BUFFER_SIZE");
     884        1893 :     if (!buffer_size_str) return ec;
     885             : 
     886           0 :     uint32_t sz = static_cast<uint32_t>(strtoul(buffer_size_str, NULL, 0));
     887           0 :     if (sz) {
     888             :         //
     889             :         // Set socket send and receive buffer size
     890             :         //
     891             :         // Currently used only under test environments to trigger partial
     892             :         // sends more deterministically
     893             :         //
     894           0 :         socket_base::send_buffer_size send_buffer_size_option(sz);
     895           0 :         socket()->set_option(send_buffer_size_option, ec);
     896           0 :         if (ec) {
     897           0 :             TCP_SESSION_LOG_ERROR(this, TCP_DIR_OUT,
     898             :                                   "send_buffer_size set error: " << ec);
     899           0 :             return ec;
     900             :         }
     901             : 
     902           0 :         socket_base::receive_buffer_size receive_buffer_size_option(sz);
     903           0 :         socket()->set_option(receive_buffer_size_option, ec);
     904           0 :         if (ec) {
     905           0 :             TCP_SESSION_LOG_ERROR(this, TCP_DIR_IN,
     906             :                                   "receive_buffer_size set error: " << ec);
     907           0 :             return ec;
     908             :         }
     909             :     }
     910             : 
     911           0 :     return ec;
     912             : }
     913             : 
     914           9 : void TcpSession::GetRxSocketStats(SocketIOStats *socket_stats) const {
     915           9 :     stats_.GetRxStats(socket_stats);
     916           9 : }
     917             : 
     918           7 : void TcpSession::GetTxSocketStats(SocketIOStats *socket_stats) const {
     919           7 :     stats_.GetTxStats(socket_stats);
     920           7 : }

Generated by: LCOV version 1.14