void
source_accept_cb(uv_stream_t *server, int status) {
struct source_context *source = new_source();
struct target_context *target = new_target();
source->target = target;
target->source = source;
uv_tcp_init(server->loop, &source->handle.tcp);
uv_tcp_init(server->loop, &target->handle.tcp);
uv_tcp_nodelay(&source->handle.tcp, 0);
uv_tcp_nodelay(&target->handle.tcp, 0);
uv_tcp_keepalive(&source->handle.tcp, 1, 60);
uv_tcp_keepalive(&target->handle.tcp, 1, 60);
int rc = uv_accept(server, &source->handle.stream);
if (rc == 0) {
connect_to_target(target);
} else {
logger_log(LOG_ERR, "accept error: %s", uv_strerror(rc));
close_source(source);
close_target(target);
}
}
static int tcp_keepalive(lua_State *l)
{
tcp_udata_t *udata = connection_udata(l);
ls_tcp_t *handle = udata->handle;
int enable;
int delay = 0;
if (handle == NULL)
return ls_error_return(l, LS_ERRCODE_EOF, "tcp connection closed");
enable = lua_toboolean(l, 2);
if (enable)
{
delay = luaL_checkint(l, 3);
luaL_argcheck(l, delay>0, 3, "delay should be > 0");
}
if (uv_tcp_keepalive(&handle->handle, enable, (unsigned int)delay))
{
return ls_error_return(l, LS_ERRCODE_ERROR, "set keepalive failed.");
}
lua_pushboolean(l, 1);
return 1;
}
bool TCPClient::SetKeepAlive(int enable, unsigned int delay)
{
int iret = uv_tcp_keepalive(&client_handle_->tcphandle, enable , delay);
if (iret) {
errmsg_ = GetUVError(iret);
LOG(ERROR)<<(errmsg_);
return false;
}
return true;
}
int luv_tcp_keepalive (lua_State* L) {
uv_tcp_t* handle = (uv_tcp_t*)luv_checkudata(L, 1, "tcp");
int enable = lua_toboolean(L, 2);
int delay = lua_tointeger(L, 3);
if (uv_tcp_keepalive(handle, enable, delay)) {
uv_err_t err = uv_last_error(luv_get_loop(L));
return luaL_error(L, "tcp_keepalive: %s", uv_strerror(err));
}
return 0;
}
static int luv_tcp_keepalive(lua_State* L) {
uv_tcp_t* handle = luv_check_tcp(L, 1);
int ret, enable;
unsigned int delay = 0;
luaL_checktype(L, 2, LUA_TBOOLEAN);
enable = lua_toboolean(L, 2);
if (enable) {
delay = luaL_checkinteger(L, 3);
}
ret = uv_tcp_keepalive(handle, enable, delay);
if (ret < 0) return luv_error(L, ret);
lua_pushinteger(L, ret);
return 1;
}
static int lluv_tcp_keepalive(lua_State *L){
lluv_handle_t *handle = lluv_check_tcp(L, 1, LLUV_FLAG_OPEN);
int enable = lua_toboolean(L, 2);
unsigned int delay = 0; int err;
if(enable) delay = (unsigned int)luaL_checkint(L, 3);
err = uv_tcp_keepalive(LLUV_H(handle, uv_tcp_t), enable, delay);
lua_settop(L, 1);
if(err < 0){
return lluv_fail(L, handle->flags, LLUV_ERR_UV, err, NULL);
}
return 1;
}
Connection::Connection(uv_loop_t* loop,
const Config& config,
Metrics* metrics,
const Address& address,
const std::string& keyspace,
int protocol_version,
Listener* listener)
: state_(CONNECTION_STATE_NEW)
, is_defunct_(false)
, is_invalid_protocol_(false)
, is_registered_for_events_(false)
, is_available_(false)
, ssl_error_code_(CASS_OK)
, pending_writes_size_(0)
, loop_(loop)
, config_(config)
, metrics_(metrics)
, address_(address)
, addr_string_(address.to_string())
, keyspace_(keyspace)
, protocol_version_(protocol_version)
, listener_(listener)
, response_(new ResponseMessage())
, version_("3.0.0")
, connect_timer_(NULL)
, ssl_session_(NULL) {
socket_.data = this;
uv_tcp_init(loop_, &socket_);
if (uv_tcp_nodelay(&socket_,
config.tcp_nodelay_enable() ? 1 : 0) != 0) {
LOG_WARN("Unable to set tcp nodelay");
}
if (uv_tcp_keepalive(&socket_,
config.tcp_keepalive_enable() ? 1 : 0,
config.tcp_keepalive_delay_secs()) != 0) {
LOG_WARN("Unable to set tcp keepalive");
}
SslContext* ssl_context = config_.ssl_context();
if (ssl_context != NULL) {
ssl_session_.reset(ssl_context->create_session(address_));
}
}
static void connect_cb(uv_stream_t* listener, int status)
{
int n;
if (status) {
SHOW_UV_ERROR(listener->loop);
return;
}
server_ctx *ctx = calloc(1, sizeof(server_ctx));
ctx->handshake_buffer = calloc(1, HANDSHAKE_BUFFER_SIZE);
if (!ctx || !ctx->handshake_buffer)
FATAL("malloc() failed!");
ctx->client.data = ctx;
ctx->remote.data = ctx;
make_encryptor(&crypto, &ctx->encoder, 0, NULL);
n = uv_tcp_init(listener->loop, &ctx->client);
if (n)
SHOW_UV_ERROR_AND_EXIT(listener->loop);
n = uv_accept(listener, (uv_stream_t *)(void *)&ctx->client);
if (n)
SHOW_UV_ERROR_AND_EXIT(listener->loop);
n = uv_tcp_nodelay(&ctx->client, 1);
if (n)
SHOW_UV_ERROR_AND_EXIT(listener->loop);
#ifdef KEEPALIVE_TIMEOUT
n = uv_tcp_keepalive(&ctx->client, 1, KEEPALIVE_TIMEOUT);
if (n)
SHOW_UV_ERROR_AND_EXIT(listener->loop);
#endif /* KEEPALIVE_TIMEOUT */
n = uv_read_start((uv_stream_t *)(void *)&ctx->client, client_handshake_alloc_cb, client_handshake_read_cb);
if (n)
SHOW_UV_ERROR_AND_EXIT(listener->loop);
LOGCONN(&ctx->client, "Accepted connection from %s");
}
Connection::Connection(uv_loop_t* loop,
const Config& config,
Metrics* metrics,
const Host::ConstPtr& host,
const std::string& keyspace,
int protocol_version,
Listener* listener)
: state_(CONNECTION_STATE_NEW)
, error_code_(CONNECTION_OK)
, ssl_error_code_(CASS_OK)
, pending_writes_size_(0)
, loop_(loop)
, config_(config)
, metrics_(metrics)
, host_(host)
, keyspace_(keyspace)
, protocol_version_(protocol_version)
, listener_(listener)
, response_(new ResponseMessage())
, stream_manager_(protocol_version)
, ssl_session_(NULL)
, heartbeat_outstanding_(false) {
socket_.data = this;
uv_tcp_init(loop_, &socket_);
if (uv_tcp_nodelay(&socket_,
config.tcp_nodelay_enable() ? 1 : 0) != 0) {
LOG_WARN("Unable to set tcp nodelay");
}
if (uv_tcp_keepalive(&socket_,
config.tcp_keepalive_enable() ? 1 : 0,
config.tcp_keepalive_delay_secs()) != 0) {
LOG_WARN("Unable to set tcp keepalive");
}
SslContext* ssl_context = config_.ssl_context();
if (ssl_context != NULL) {
ssl_session_.reset(ssl_context->create_session(host));
}
}
void Client::connect(sockaddr *addr)
{
setState(ConnectingState);
reinterpret_cast<struct sockaddr_in*>(addr)->sin_port = htons(m_url.port());
delete m_socket;
uv_connect_t *req = new uv_connect_t;
req->data = this;
m_socket = new uv_tcp_t;
m_socket->data = this;
uv_tcp_init(uv_default_loop(), m_socket);
uv_tcp_nodelay(m_socket, 1);
# ifndef WIN32
uv_tcp_keepalive(m_socket, 1, 60);
# endif
uv_tcp_connect(req, m_socket, reinterpret_cast<const sockaddr*>(addr), Client::onConnect);
}
void timer_cb(uv_timer_t *handle) {
size_t i,j;
static size_t fail_count = 0;
for(i = (size_t)handle->data,j = 0;i < CONN_NUM && j < 10;i++,j++) {
uv_ip4_addr(addr_str, 1024+i, &addr);
uv_tcp_bind(&c[i].ts, (const struct sockaddr*)&addr, 0);
uv_tcp_keepalive(&c[i].ts,1,30);
c[i].cs.data = (void*)0;
if (0 != uv_tcp_connect(&c[i].cs,&c[i].ts,(struct sockaddr*)&addr1,connect_cb)) {
perror("connect_rt");
sleep(1);
fail_count++;
printf("failcount: %d\n",fail_count);
}
}
handle->data = (void*)i;
if(i == CONN_NUM || fail_count >= 20){
uv_timer_stop(handle);
//timer for 100 secs
uv_timer_start(handle, timer_cb1, WRITE_INTERVAL, WRITE_INTERVAL);
}
}
static PyObject *
TCP_func_keepalive(TCP *self, PyObject *args)
{
int r;
unsigned int delay;
PyObject *enable;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
if (!PyArg_ParseTuple(args, "O!I:keepalive", &PyBool_Type, &enable, &delay)) {
return NULL;
}
r = uv_tcp_keepalive(&self->tcp_h, (enable == Py_True) ? 1 : 0, delay);
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError);
return NULL;
}
Py_RETURN_NONE;
}
static void
accept_cb(uv_stream_t *stream, int status) {
struct tundev_context *ctx = stream->data;
struct client_context *client = new_client(ctx->tun->mtu);
uv_tcp_init(stream->loop, &client->handle.tcp);
int rc = uv_accept(stream, &client->handle.stream);
if (rc == 0) {
int len = sizeof(struct sockaddr);
uv_tcp_getpeername(&client->handle.tcp, &client->addr, &len);
client->handle.stream.data = ctx;
uv_tcp_nodelay(&client->handle.tcp, 1);
uv_tcp_keepalive(&client->handle.tcp, 1, 60);
client->packet.size = 512;
ctx->connect = AUTHING;
uv_read_start(&client->handle.stream, alloc_cb, recv_cb);
} else {
logger_log(LOG_ERR, "accept error: %s", uv_strerror(rc));
close_client(client);
}
}
void TCPSocket::setKeepAlive(int enable, unsigned int delay)
{
init();
int r = uv_tcp_keepalive(ptr<uv_tcp_t>(), enable, delay);
if (r) setUVError("TCP socket error", r);
}
void bud_client_create(bud_config_t* config, uv_stream_t* stream) {
int r;
bud_client_t* client;
bud_client_error_t cerr;
BIO* enc_in;
BIO* enc_out;
#ifdef SSL_MODE_RELEASE_BUFFERS
long mode;
#endif /* SSL_MODE_RELEASE_BUFFERS */
client = malloc(sizeof(*client));
if (client == NULL)
return;
client->config = config;
client->ssl = NULL;
client->last_handshake = 0;
client->handshakes = 0;
client->connect = kBudProgressNone;
client->close = kBudProgressNone;
client->cycle = kBudProgressNone;
client->recycle = 0;
client->destroy_waiting = 0;
client->id = bud_config_get_client_id(config);
client->async_hello = kBudProgressDone;
if (config->sni.enabled || config->stapling.enabled)
client->async_hello = kBudProgressNone;
/* SNI */
client->sni_req = NULL;
client->sni_ctx.ctx = NULL;
/* Stapling */
client->stapling_cache_req = NULL;
client->stapling_req = NULL;
client->stapling_ocsp_resp = NULL;
/* Availability */
client->retry = kBudProgressNone;
client->retry_count = 0;
client->retry_timer.data = client;
client->backend_list = NULL;
client->selected_backend = NULL;
/* Proxyline */
client->proxyline_waiting = 2;
/* X-Forward */
client->xforward.skip = 0;
client->xforward.crlf = 0;
r = uv_timer_init(config->loop, &client->retry_timer);
if (r != 0)
goto failed_timer_init;
client->destroy_waiting++;
/* Initialize buffers */
bud_client_side_init(&client->frontend, kBudFrontend, client);
bud_client_side_init(&client->backend, kBudBackend, client);
/**
* Accept client on frontend
*/
r = uv_tcp_init(config->loop, &client->frontend.tcp);
if (r != 0)
goto failed_tcp_in_init;
client->destroy_waiting++;
r = uv_accept(stream, (uv_stream_t*) &client->frontend.tcp);
if (r != 0)
goto failed_accept;
cerr = bud_client_read_start(client, &client->frontend);
if (!bud_is_ok(cerr.err))
goto failed_accept;
client->frontend.reading = kBudProgressRunning;
/* Fill hosts */
cerr = bud_client_fill_host(client, &client->local);
if (!bud_is_ok(cerr.err))
goto failed_accept;
cerr = bud_client_fill_host(client, &client->remote);
if (!bud_is_ok(cerr.err))
goto failed_accept;
/*
* Select a backend and connect to it, or wait for a backend to become
* alive again.
*/
/* SNI backend comes from `backend` or sni callback */
client->backend_list = &config->contexts[0].backend;
client->balance = config->balance_e;
if (client->balance == kBudBalanceSNI) {
client->selected_backend = NULL;
client->connect = kBudProgressRunning;
} else {
client->selected_backend = bud_select_backend(client);
}
/* No backend can be selected yet, wait for SNI */
if (client->selected_backend == NULL) {
client->backend.close = kBudProgressDone;
cerr = bud_client_ok(&client->backend);
/* No backend alive, try reconnecting */
} else if (client->selected_backend->dead) {
DBG_LN(&client->backend, "all backends dead, scheduling reconnection");
cerr = bud_client_retry(client);
/* Backend alive - connect immediately */
} else {
cerr = bud_client_connect(client);
}
if (!bud_is_ok(cerr.err))
goto failed_accept;
/* Adjust sockets */
r = uv_tcp_nodelay(&client->frontend.tcp, 1);
if (r == 0 && config->frontend.keepalive > 0)
r = uv_tcp_keepalive(&client->frontend.tcp, 1, config->frontend.keepalive);
if (r != 0)
goto failed_connect;
/* Initialize SSL */
/* First context is always default */
client->ssl = SSL_new(config->contexts[0].ctx);
if (client->ssl == NULL)
goto failed_connect;
if (!SSL_set_ex_data(client->ssl, kBudSSLClientIndex, client))
goto failed_connect;
SSL_set_cert_cb(client->ssl, bud_client_ssl_cert_cb, client);
SSL_set_info_callback(client->ssl, bud_client_ssl_info_cb);
enc_in = bud_bio_new(&client->frontend.input);
if (enc_in == NULL)
goto failed_connect;
enc_out = bud_bio_new(&client->frontend.output);
if (enc_out == NULL) {
BIO_free_all(enc_in);
goto failed_connect;
}
SSL_set_bio(client->ssl, enc_in, enc_out);
#ifdef SSL_MODE_RELEASE_BUFFERS
mode = SSL_get_mode(client->ssl);
SSL_set_mode(client->ssl, mode | SSL_MODE_RELEASE_BUFFERS);
#endif /* SSL_MODE_RELEASE_BUFFERS */
SSL_set_accept_state(client->ssl);
bud_trace_frontend_accept(client);
DBG_LN(&client->frontend, "new");
return;
failed_connect:
client->connect = kBudProgressDone;
client->close = kBudProgressDone;
uv_close((uv_handle_t*) &client->backend.tcp, bud_client_close_cb);
failed_accept:
uv_close((uv_handle_t*) &client->frontend.tcp, bud_client_close_cb);
failed_tcp_in_init:
uv_close((uv_handle_t*) &client->retry_timer, bud_client_close_cb);
return;
failed_timer_init:
free(client);
}
/**
* @brief Enables/Disables TCP keep-alive.
* @param enable True to enable it, false otherwise.
* @param time Initial delay in seconds (use
* `std::chrono::duration<unsigned int>`).
* @return True in case of success, false otherwise.
*/
bool keepAlive(bool enable = false, Time time = Time{0}) {
return (0 == uv_tcp_keepalive(get(), enable, time.count()));
}
bool keepalive(bool enable, unsigned int delay) {
return uv_tcp_keepalive(get<uv_tcp_t>(), enable ? 1 : 0, delay) == 0;
}
extern "C" int
rust_uv_tcp_keepalive
(uv_tcp_t* handle, int enable, unsigned int delay) {
return uv_tcp_keepalive(handle, enable, delay);
}
int UvTcpSocket::keepAlive(bool enable, unsigned int value)
{
return uv_tcp_keepalive(m_uv_tcp,enable?1:0,value);
}
int uvplus_tcp::keepalive(int enable, unsigned int delay) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_keepalive(tcp, enable, delay);
}
