static int luv_tcp_simultaneous_accepts(lua_State* L) {
uv_tcp_t* handle = luv_check_tcp(L, 1);
int ret, enable;
luaL_checktype(L, 2, LUA_TBOOLEAN);
enable = lua_toboolean(L, 2);
ret = uv_tcp_simultaneous_accepts(handle, enable);
if (ret < 0) return luv_error(L, ret);
lua_pushinteger(L, ret);
return 1;
}
static int lluv_tcp_simultaneous_accepts(lua_State *L){
lluv_handle_t *handle = lluv_check_tcp(L, 1, LLUV_FLAG_OPEN);
int enable = lua_toboolean(L, 2);
int err = uv_tcp_simultaneous_accepts(LLUV_H(handle, uv_tcp_t), enable);
lua_settop(L, 1);
if(err < 0){
return lluv_fail(L, handle->flags, LLUV_ERR_UV, err, NULL);
}
return 1;
}
static void
on_connection(uv_stream_t* server, int status) {
uv_stream_t* stream;
int r;
if (status != 0) {
fprintf(stderr, "Connect error: %s: %s\n", uv_err_name(status), uv_strerror(status));
return;
}
stream = malloc(sizeof(uv_tcp_t));
if (stream == NULL) {
fprintf(stderr, "Allocate error: %s\n", strerror(errno));
return;
}
r = uv_tcp_init(loop, (uv_tcp_t*) stream);
if (r) {
fprintf(stderr, "Socket creation error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return;
}
r = uv_tcp_simultaneous_accepts((uv_tcp_t*) stream, 1);
if (r) {
fprintf(stderr, "Flag error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return;
}
r = uv_accept(server, stream);
if (r) {
fprintf(stderr, "Accept error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return;
}
r = uv_tcp_nodelay((uv_tcp_t*) stream, 1);
if (r) {
fprintf(stderr, "Flag error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return;
}
r = uv_read_start(stream, on_alloc, on_read);
if (r) {
fprintf(stderr, "Read error: %s: %s\n", uv_err_name(r), uv_strerror(r));
uv_close((uv_handle_t*) stream, on_close);
}
}
static PyObject *
TCP_func_simultaneous_accepts(TCP *self, PyObject *args)
{
int r;
PyObject *enable;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
if (!PyArg_ParseTuple(args, "O!:simultaneous_accepts", &PyBool_Type, &enable)) {
return NULL;
}
r = uv_tcp_simultaneous_accepts(&self->tcp_h, (enable == Py_True) ? 1 : 0);
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError);
return NULL;
}
Py_RETURN_NONE;
}
void TCPSocket::setSimultaneousAccepts(bool enable)
{
init();
int r = uv_tcp_simultaneous_accepts(ptr<uv_tcp_t>(), enable ? 1 : 0);
if (r) setUVError("TCP socket error", r);
}
int
main(int argc, char* argv[]) {
char* ipaddr = "0.0.0.0";
int port = 7000;
int i;
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-a")) {
if (i == argc-1) usage(argv[0]);
ipaddr = argv[++i];
} else
if (!strcmp(argv[i], "-p")) {
if (i == argc-1) usage(argv[0]);
char* e = NULL;
port = strtol(argv[++i], &e, 10);
if ((e && *e) || port < 0 || port > 65535) usage(argv[0]);
} else
if (!strcmp(argv[i], "-d")) {
if (i == argc-1) usage(argv[0]);
static_dir = argv[++i];
} else
usage(argv[0]);
}
static_dir_len = strlen(static_dir);
struct sockaddr_in addr;
int r;
mime_type = kh_init(mime_type);
add_mime_type(".jpg", "image/jpeg");
add_mime_type(".png", "image/png");
add_mime_type(".gif", "image/gif");
add_mime_type(".html", "text/html");
add_mime_type(".txt", "text/plain");
r = uv_ip4_addr(ipaddr, port, &addr);
if (r) {
fprintf(stderr, "Address error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return 1;
}
loop = uv_default_loop();
uv_tcp_t server;
r = uv_tcp_init(loop, &server);
if (r) {
fprintf(stderr, "Socket creation error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return 1;
}
r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0);
if (r) {
fprintf(stderr, "Bind error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return 1;
}
r = uv_tcp_simultaneous_accepts((uv_tcp_t*) &server, 1);
if (r) {
fprintf(stderr, "Accept error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return 1;
}
fprintf(stderr, "Listening %s:%d\n", ipaddr, port);
r = uv_listen((uv_stream_t*)&server, SOMAXCONN, on_connection);
if (r) {
fprintf(stderr, "Listen error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return 1;
}
uv_signal_t sig;
r = uv_signal_init(loop, &sig);
if (r) {
fprintf(stderr, "Signal error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return 1;
}
sig.data = loop;
r = uv_signal_start(&sig, on_signal, SIGINT);
if (r) {
fprintf(stderr, "Signal error: %s: %s\n", uv_err_name(r), uv_strerror(r));
return 1;
}
return uv_run(loop, UV_RUN_DEFAULT);
}
bool simultanious_accepts(bool enable) { return uv_tcp_simultaneous_accepts(get<uv_tcp_t>(), enable ? 1 : 0) == 0; }
int UvTcpSocket::simultaneousAccept(bool enable)
{
return uv_tcp_simultaneous_accepts(m_uv_tcp,enable?1:0);
}
int uvplus_tcp::simultaneous_accepts(int enable) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_simultaneous_accepts(tcp, enable);
}
extern "C" int
rust_uv_tcp_simultaneous_accepts
(uv_tcp_t* handle, int enable) {
return uv_tcp_simultaneous_accepts(handle, enable);
}
/**
* @brief Enables/Disables simultaneous asynchronous accept requests.
*
* Enables/Disables simultaneous asynchronous accept requests that are
* queued by the operating system when listening for new TCP
* connections.<br/>
* This setting is used to tune a TCP server for the desired performance.
* Having simultaneous accepts can significantly improve the rate of
* accepting connections (which is why it is enabled by default) but may
* lead to uneven load distribution in multi-process setups.
*
* @param enable True to enable it, false otherwise.
* @return True in case of success, false otherwise.
*/
bool simultaneousAccepts(bool enable = true) {
return (0 == uv_tcp_simultaneous_accepts(get(), enable));
}
