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)); }