iframe-proxy | Sunbelt Computer Software

309 lines (248 loc) · 7.32 KB
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
#include "tcp_client.h"
#include <tbox/base/log.h>
#include <tbox/base/assert.h>
#include <tbox/base/defines.h>
#include <tbox/base/wrapped_recorder.h>
#include "tcp_connector.h"
#include "tcp_connection.h"
#include "tcp_factory.h"
#include "tcp_raw_factory.h"
#include "tls_factory_entry.h"
#undef  MODULE_ID
#define MODULE_ID "tbox.tcp"
namespace tbox {
namespace network {
struct TcpClient::Data {
    event::Loop *wp_loop;
    State state = State::kNone;
    ConnectedCallback    connected_cb;
    DisconnectedCallback disconnected_cb;
    ReceiveCallback      received_cb;
    size_t               received_threshold = 0;
    SendCompleteCallback send_complete_cb;
    ByteStream          *wp_receiver = nullptr;
    bool reconnect_enabled = true;
    TcpFactory   *sp_factory    = nullptr;
    TcpConnector *sp_connector  = nullptr;
    TcpConnection *sp_connection = nullptr;
    int cb_level = 0;
TcpClient::TcpClient(event::Loop *wp_loop)
  : d_(new Data)
    TBOX_ASSERT(d_ != nullptr);
    d_->wp_loop = wp_loop;
    d_->sp_factory = new TcpRawFactory;
    d_->sp_connector = d_->sp_factory->createConnector(wp_loop);
TcpClient::~TcpClient()
    TBOX_ASSERT(d_->cb_level == 0);
    cleanup();
    CHECK_DELETE_RESET_OBJ(d_->sp_connection);
    CHECK_DELETE_RESET_OBJ(d_->sp_connector);
    CHECK_DELETE_RESET_OBJ(d_->sp_factory);
    delete d_;
bool TcpClient::setTlsConfig(const TlsConfig &config)
    if (d_->state != State::kNone) {
        LogWarn("cannot set TLS config after initialization");
        return false;
    if (!config.isValid()) {
        LogWarn("invalid TLS config");
        return false;
    //! 替换 factory 和 connector
    TcpFactory *tls_factory = CreateTlsFactory(TlsRole::kClient, config);
    if (tls_factory == nullptr) {
        LogWarn("failed to create TLS factory, TLS module may not be linked");
        return false;
    if (!tls_factory->initialize()) {
        LogWarn("failed init TLS factory, config may invalid");
        delete tls_factory;
        return false;
    CHECK_DELETE_RESET_OBJ(d_->sp_connector);
    CHECK_DELETE_RESET_OBJ(d_->sp_factory);
    d_->sp_factory = tls_factory;
    d_->sp_connector = d_->sp_factory->createConnector(d_->wp_loop);
    return true;
bool TcpClient::initialize(const SockAddr &server_addr)
    if (d_->state != State::kNone) {
        LogWarn("not in none state, cleanup first.");
        return false;
    using namespace std::placeholders;
    d_->sp_connector->initialize(server_addr);
    d_->sp_connector->setConnectedCallback(std::bind(&TcpClient::onTcpConnected, this, _1));
    d_->state = State::kInited;
    return true;
void TcpClient::setConnectedCallback(const ConnectedCallback &cb)
    d_->connected_cb = cb;
void TcpClient::setDisconnectedCallback(const DisconnectedCallback &cb)
    d_->disconnected_cb = cb;
void TcpClient::setAutoReconnect(bool enable)
    d_->reconnect_enabled = enable;
void TcpClient::setReconnectDelayCalcFunc(const ReconnectDelayCalc &func)
    d_->sp_connector->setReconnectDelayCalcFunc(func);
bool TcpClient::start()
    if (d_->state != State::kInited) {
        LogWarn("not in idle state, initialize or stop first");
        return false;
    d_->state = State::kConnecting;
    return d_->sp_connector->start();
void TcpClient::stop()
    if (d_->state == State::kConnecting) {
        d_->state = State::kInited;
        d_->sp_connector->stop();
    } else if (d_->state == State::kConnected) {
        TcpConnection *tobe_delete = nullptr;
        std::swap(tobe_delete, d_->sp_connection);
        tobe_delete->disconnect();
        d_->wp_loop->runNext(
            [tobe_delete] { delete tobe_delete; },
            "TcpClient::stop, delete"
        d_->state = State::kInited;
bool TcpClient::shutdown(int howto)
    if (d_->state == State::kConnected)
        return d_->sp_connection->shutdown(howto);
    return false;
void TcpClient::cleanup()
    if (d_->state <= State::kNone)
        return;
    stop();
    d_->sp_connector->cleanup();
    d_->connected_cb = nullptr;
    d_->disconnected_cb = nullptr;
    d_->received_cb = nullptr;
    d_->received_threshold = 0;
    d_->send_complete_cb = nullptr;
    d_->wp_receiver = nullptr;
    d_->reconnect_enabled = true;
    d_->state = State::kNone;
TcpClient::State TcpClient::state() const
    return d_->state;
void TcpClient::setReceiveCallback(const ReceiveCallback &cb, size_t threshold)
    if (d_->sp_connection != nullptr)
        d_->sp_connection->setReceiveCallback(cb, threshold);
    d_->received_cb = cb;
    d_->received_threshold = threshold;
void TcpClient::setSendCompleteCallback(const SendCompleteCallback &cb)
    if (d_->sp_connection != nullptr)
        d_->sp_connection->setSendCompleteCallback(cb);
    d_->send_complete_cb = cb;
bool TcpClient::send(const void *data_ptr, size_t data_size)
    if (d_->sp_connection != nullptr)
        return d_->sp_connection->send(data_ptr, data_size);
    return false;
void TcpClient::bind(ByteStream *receiver)
    if (d_->sp_connection != nullptr)
        d_->sp_connection->bind(receiver);
    d_->wp_receiver = receiver;
void TcpClient::unbind()
    if (d_->sp_connection != nullptr)
        d_->sp_connection->unbind();
    d_->wp_receiver = nullptr;
Buffer* TcpClient::getReceiveBuffer()
    if (d_->sp_connection != nullptr)
        return d_->sp_connection->getReceiveBuffer();
    return nullptr;
void TcpClient::onTcpConnected(TcpConnection *new_conn)
    RECORD_SCOPE();
    new_conn->setDisconnectedCallback(std::bind(&TcpClient::onTcpDisconnected, this));
    new_conn->setReceiveCallback(d_->received_cb, d_->received_threshold);
    new_conn->setSendCompleteCallback(d_->send_complete_cb);
    if (d_->wp_receiver != nullptr)
        new_conn->bind(d_->wp_receiver);
    //! 可以直接释放，因为本函数一定是 d_->sp_connector 对象调用的
    CHECK_DELETE_RESET_OBJ(d_->sp_connection);
    d_->sp_connection = new_conn;
    d_->state = State::kConnected;
    if (d_->connected_cb) {
        RECORD_SCOPE();
        ++d_->cb_level;
        d_->connected_cb();
        --d_->cb_level;
void TcpClient::onTcpDisconnected()
    RECORD_SCOPE();
    TcpConnection *tobe_delete = nullptr;
    std::swap(tobe_delete, d_->sp_connection);
    //! 这里要使用延后释放，因为本函数一定是 d_->sp_connection 对象自己调用的
    d_->wp_loop->runNext(
        [tobe_delete] { delete tobe_delete; },
        "TcpClient::onTcpDisconnected, delete"
    d_->state = State::kInited;
    if (d_->reconnect_enabled)
        start();
    if (d_->disconnected_cb) {
        RECORD_SCOPE();
        ++d_->cb_level;
        d_->disconnected_cb();
        --d_->cb_level;
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

tcp_client.cpp

Latest commit

History

tcp_client.cpp

File metadata and controls
