d_(new Data)

{

TBOX_ASSERT(d_ != nullptr);

d_->wp_loop = wp_loop;

d_->sp_factory = new TcpRawFactory;

d_->sp_acceptor = d_->sp_factory->createAcceptor(wp_loop);

{

if (d_->state != State::kNone) {

LogWarn("cannot set TLS config after initialization");

return false;

}

if (!config.isValid()) {

LogWarn("invalid TLS config");

return false;

}

//! 替换 factory 和 acceptor

TcpFactory *tls_factory = CreateTlsFactory(TlsRole::kServer, 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_acceptor);

CHECK_DELETE_RESET_OBJ(d_->sp_factory);

d_->sp_factory = tls_factory;

d_->sp_acceptor = d_->sp_factory->createAcceptor(d_->wp_loop);

return true;

{

if (d_->state != State::kNone)

return false;

if (d_->sp_acceptor->initialize(bind_addr, listen_backlog)) {

d_->sp_acceptor->setNewConnectionCallback(std::bind(&TcpServer::onTcpConnected, this, _1));

d_->state = State::kInited;

return true;

}

return false;

{

d_->receive_cb = cb;

d_->receive_threshold = threshold;

{

if (d_->state != State::kInited)

return false;

if (d_->sp_acceptor->start()) {

d_->state = State::kRunning;

return true;

}

return false;

{

if (d_->state != State::kRunning)

return;

d_->conns.foreach(

[](TcpConnection *conn) {

conn->disconnect();

delete conn;

}

);

d_->conns.clear();

d_->sp_acceptor->stop();

d_->state = State::kInited;

{

if (d_->state <= State::kNone)

return;

stop();

d_->sp_acceptor->cleanup();

d_->connected_cb = nullptr;

d_->disconnected_cb = nullptr;

d_->receive_cb = nullptr;

d_->receive_threshold = 0;

d_->send_complete_cb = nullptr;

d_->state = State::kNone;

{

auto conn = d_->conns.at(client);

if (conn != nullptr)

return conn->send(data_ptr, data_size);

return false;

{

auto conn = d_->conns.free(client);

if (conn != nullptr) {

conn->disconnect();

d_->wp_loop->runNext([conn] { delete conn; }, "TcpServer::disconnect, delete");

return true;

}

return false;

{

auto conn = d_->conns.at(client);

if (conn != nullptr)

return conn->shutdown(howto);

return false;

{

auto conn = d_->conns.at(client);

if (conn != nullptr)

return conn->peerAddr();

return SockAddr();

{

auto conn = d_->conns.at(client);

if (conn != nullptr)

conn->setContext(context, std::move(deleter));

{

RECORD_SCOPE();

ConnToken client = d_->conns.alloc(new_conn);

new_conn->setReceiveCallback(std::bind(&TcpServer::onTcpReceived, this, client, _1), d_->receive_threshold);

new_conn->setDisconnectedCallback(std::bind(&TcpServer::onTcpDisconnected, this, client));

new_conn->setSendCompleteCallback(std::bind(&TcpServer::onTcpSendCompleted, this, client));

++d_->cb_level;

if (d_->connected_cb)

d_->connected_cb(client);

--d_->cb_level;

{

RECORD_SCOPE();

++d_->cb_level;

if (d_->disconnected_cb)

d_->disconnected_cb(client);

--d_->cb_level;

TcpConnection *conn = d_->conns.free(client);

d_->wp_loop->runNext(

[conn] { CHECK_DELETE_OBJ(conn); },

"TcpServer::onTcpDisconnected, delete conn"

);

//! 为什么先回调，再访问后面？是为了在回调中还能访问到TcpConnection对象

{

RECORD_SCOPE();

++d_->cb_level;

if (d_->receive_cb)

d_->receive_cb(client, buff);

--d_->cb_level;

{

RECORD_SCOPE();

++d_->cb_level;

if (d_->send_complete_cb)

d_->send_complete_cb(client);

--d_->cb_level;