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 : }
|