int handle_socket(CURL *easy, curl_socket_t s, int action, void *userp,
void *socketp)
{
curl_context_t *curl_context;
if (action == CURL_POLL_IN || action == CURL_POLL_OUT) {
if (socketp) {
curl_context = (curl_context_t*) socketp;
}
else {
curl_context = create_curl_context(s);
}
curl_multi_assign(curl_handle, s, (void *) curl_context);
}
switch (action) {
case CURL_POLL_IN:
uv_poll_start(&curl_context->poll_handle, UV_READABLE, curl_perform);
break;
case CURL_POLL_OUT:
uv_poll_start(&curl_context->poll_handle, UV_WRITABLE, curl_perform);
break;
case CURL_POLL_REMOVE:
if (socketp) {
uv_poll_stop(&((curl_context_t*)socketp)->poll_handle);
destroy_curl_context((curl_context_t*) socketp);
curl_multi_assign(curl_handle, s, NULL);
}
break;
default:
abort();
}
return 0;
}
int handle_socket(CURL *easy, curl_socket_t s, int action, void *userp,
void *socketp)
{
(void)easy; //unused
bear_stream_t *stream = (bear_stream_t*) userp;
if(action == CURL_POLL_IN || action == CURL_POLL_OUT) {
if(socketp) {
}
else {
create_curl_context(stream,s);
}
}
switch(action) {
case CURL_POLL_IN:
uv_poll_start(&stream->poll_handle, UV_READABLE, curl_perform);
break;
case CURL_POLL_OUT:
uv_poll_start(&stream->poll_handle, UV_WRITABLE, curl_perform);
break;
case CURL_POLL_REMOVE:
if(socketp) {
uv_poll_stop(&stream->poll_handle);
}
break;
default:
abort();
}
return 0;
}
void
lws_libuv_io(struct lws *wsi, int flags)
{
struct lws_context *context = lws_get_context(wsi);
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
#if defined(WIN32) || defined(_WIN32)
int current_events = wsi->w_read.uv_watcher.events &
(UV_READABLE | UV_WRITABLE);
#else
int current_events = wsi->w_read.uv_watcher.io_watcher.pevents &
(UV_READABLE | UV_WRITABLE);
#endif
struct lws_io_watcher *w = &wsi->w_read;
if (!LWS_LIBUV_ENABLED(context))
return;
// lwsl_notice("%s: wsi: %p, flags:0x%x\n", __func__, wsi, flags);
// w->context is set after the loop is initialized
if (!pt->io_loop_uv || !w->context) {
lwsl_info("%s: no io loop yet\n", __func__);
return;
}
if (!((flags & (LWS_EV_START | LWS_EV_STOP)) &&
(flags & (LWS_EV_READ | LWS_EV_WRITE)))) {
lwsl_err("%s: assert: flags %d", __func__, flags);
assert(0);
}
if (flags & LWS_EV_START) {
if (flags & LWS_EV_WRITE)
current_events |= UV_WRITABLE;
if (flags & LWS_EV_READ)
current_events |= UV_READABLE;
uv_poll_start(&w->uv_watcher, current_events, lws_io_cb);
} else {
if (flags & LWS_EV_WRITE)
current_events &= ~UV_WRITABLE;
if (flags & LWS_EV_READ)
current_events &= ~UV_READABLE;
if (!(current_events & (UV_READABLE | UV_WRITABLE)))
uv_poll_stop(&w->uv_watcher);
else
uv_poll_start(&w->uv_watcher, current_events,
lws_io_cb);
}
}
static void
elops_io_uv(struct lws *wsi, int flags)
{
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
struct lws_io_watcher *w = &wsi->w_read;
int current_events = w->actual_events & (UV_READABLE | UV_WRITABLE);
lwsl_debug("%s: %p: %d\n", __func__, wsi, flags);
/* w->context is set after the loop is initialized */
if (!pt->uv.io_loop || !w->context) {
lwsl_info("%s: no io loop yet\n", __func__);
return;
}
if (!((flags & (LWS_EV_START | LWS_EV_STOP)) &&
(flags & (LWS_EV_READ | LWS_EV_WRITE)))) {
lwsl_err("%s: assert: flags %d", __func__, flags);
assert(0);
}
if (!w->uv.pwatcher || wsi->told_event_loop_closed) {
lwsl_err("%s: no watcher\n", __func__);
return;
}
if (flags & LWS_EV_START) {
if (flags & LWS_EV_WRITE)
current_events |= UV_WRITABLE;
if (flags & LWS_EV_READ)
current_events |= UV_READABLE;
uv_poll_start(w->uv.pwatcher, current_events, lws_io_cb);
} else {
if (flags & LWS_EV_WRITE)
current_events &= ~UV_WRITABLE;
if (flags & LWS_EV_READ)
current_events &= ~UV_READABLE;
if (!(current_events & (UV_READABLE | UV_WRITABLE)))
uv_poll_stop(w->uv.pwatcher);
else
uv_poll_start(w->uv.pwatcher, current_events,
lws_io_cb);
}
w->actual_events = current_events;
}
static void *add_io(void *glue_data, int fd, iot_io_event_t events,
void (*cb)(void *glue_data, void *id, int fd,
iot_io_event_t events, void *user_data),
void *user_data)
{
uv_glue_t *uv = (uv_glue_t *)glue_data;
int mask = 0;
io_t *io;
io = iot_allocz(sizeof(*io));
if (io == NULL)
return NULL;
if (events & IOT_IO_EVENT_IN)
mask |= UV_READABLE;
if (events & IOT_IO_EVENT_OUT)
mask |= UV_WRITABLE;
uv_poll_init_socket(uv->uv, &io->uv_poll, fd);
io->uv_poll.data = io;
uv_poll_start(&io->uv_poll, mask, io_cb);
io->mask = events;
io->cb = cb;
io->user_data = user_data;
io->glue_data = glue_data;
return io;
}
static int handle_socket(CURL *easy, curl_socket_t s, int action, void *userp,
void *socketp)
{
curl_context_t *curl_context;
int events = 0;
switch(action) {
case CURL_POLL_IN:
case CURL_POLL_OUT:
case CURL_POLL_INOUT:
curl_context = socketp ?
(curl_context_t *) socketp : create_curl_context(s);
curl_multi_assign(curl_handle, s, (void *) curl_context);
if(action != CURL_POLL_IN)
events |= UV_WRITABLE;
if(action != CURL_POLL_OUT)
events |= UV_READABLE;
uv_poll_start(&curl_context->poll_handle, events, curl_perform);
break;
case CURL_POLL_REMOVE:
if(socketp) {
uv_poll_stop(&((curl_context_t*)socketp)->poll_handle);
destroy_curl_context((curl_context_t*) socketp);
curl_multi_assign(curl_handle, s, NULL);
}
break;
default:
abort();
}
return 0;
}
static void server_poll_cb(uv_poll_t* handle, int status, int events) {
server_context_t* server_context = (server_context_t*)
handle->data;
connection_context_t* connection_context;
struct sockaddr_in addr;
socklen_t addr_len;
uv_os_sock_t sock;
int r;
addr_len = sizeof addr;
sock = accept(server_context->sock, (struct sockaddr*) &addr, &addr_len);
#ifdef _WIN32
ASSERT(sock != INVALID_SOCKET);
#else
ASSERT(sock >= 0);
#endif
connection_context = create_connection_context(sock, 1);
connection_context->events = UV_READABLE | UV_WRITABLE | UV_DISCONNECT;
r = uv_poll_start(&connection_context->poll_handle,
UV_READABLE | UV_WRITABLE | UV_DISCONNECT,
connection_poll_cb);
ASSERT(r == 0);
if (++server_context->connections == NUM_CLIENTS) {
close_socket(server_context->sock);
destroy_server_context(server_context);
}
}
void
connection_start_read(Client *client)
{
if(client == NULL)
{
return;
}
if(client->TlsContext != NULL)
{
uv_os_fd_t fd;
uv_poll_t *handle = Malloc(sizeof(uv_poll_t));
handle->data = client;
uv_fileno((uv_handle_t *)client->handle, &fd);
uv_poll_init(serverstate_get_event_loop(), handle, fd);
if(uv_poll_start(handle, UV_READABLE, connection_poll_callback) < 0)
{
client_free(client);
}
}
else
{
if(uv_read_start((uv_stream_t *)client->handle,
connection_allocate_buffer_callback,
connection_on_read_callback) < 0)
{
client_free(client);
}
}
}
static int lluv_poll_start(lua_State *L){
static const lluv_uv_const_t FLAGS[] = {
{ UV_READABLE, "readable" },
{ UV_WRITABLE, "writable" },
#if LLUV_UV_VER_GE(1,9,0)
{ UV_DISCONNECT, "disconnect" },
#endif
{ 0, NULL }
};
lluv_handle_t *handle = lluv_check_poll(L, 1, LLUV_FLAG_OPEN);
int events = UV_READABLE;
int err;
if(!lua_isfunction(L, 2))
events = lluv_opt_flags_ui(L, 2, UV_READABLE, FLAGS);
lluv_check_args_with_cb(L, 3);
LLUV_START_CB(handle) = luaL_ref(L, LLUV_LUA_REGISTRY);
err = uv_poll_start(LLUV_H(handle, uv_poll_t), events, lluv_on_poll_start);
if(err >= 0) lluv_handle_lock(L, handle, LLUV_LOCK_START);
return lluv_return(L, handle, LLUV_START_CB(handle), err);
}
int
udprelay_start(uv_loop_t *loop, struct server_context *server) {
int rc, yes = 1;
if (setsockopt(server->udp_fd, SOL_IP, IP_TRANSPARENT, &yes, sizeof(int))) {
logger_stderr("setsockopt IP_TRANSPARENT error: %s", strerror(errno));
}
if (setsockopt(server->udp_fd, IPPROTO_IP, IP_RECVORIGDSTADDR, &yes, sizeof(int))) {
logger_stderr("setsockopt IP_RECVORIGDSTADDR error: %s", strerror(errno));
}
uv_udp_init(loop, &server->udp);
if ((rc = uv_udp_open(&server->udp, server->udp_fd))) {
logger_stderr("udp open error: %s", uv_strerror(rc));
return 1;
}
if ((rc = uv_udp_bind(&server->udp, server->local_addr, UV_UDP_REUSEADDR))) {
logger_stderr("udp bind error: %s", uv_strerror(rc));
return 1;
}
uv_poll_init_socket(loop, &server->watcher, server->udp_fd);
uv_poll_start(&server->watcher, UV_READABLE, poll_cb);
return 0;
}
void iotjs_uart_open_worker(uv_work_t* work_req) {
UART_WORKER_INIT;
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_uart_t, uart);
int fd = open(iotjs_string_data(&_this->device_path),
O_RDWR | O_NOCTTY | O_NDELAY);
if (fd < 0) {
req_data->result = false;
return;
}
struct termios options;
tcgetattr(fd, &options);
options.c_cflag = CLOCAL | CREAD;
options.c_cflag |= baud_to_constant(_this->baud_rate);
options.c_cflag |= databits_to_constant(_this->data_bits);
options.c_iflag = IGNPAR;
options.c_oflag = 0;
options.c_lflag = 0;
tcflush(fd, TCIFLUSH);
tcsetattr(fd, TCSANOW, &options);
_this->device_fd = fd;
uv_poll_t* poll_handle = &_this->poll_handle;
uv_loop_t* loop = iotjs_environment_loop(iotjs_environment_get());
uv_poll_init(loop, poll_handle, fd);
poll_handle->data = uart;
uv_poll_start(poll_handle, UV_READABLE, iotjs_uart_read_cb);
req_data->result = true;
}
static void(io_start)(void* io, int fd, int action)
{
struct LwqqAsyncIo_* io_ = (struct LwqqAsyncIo_*)io;
io_->h.data = io;
uv_poll_init(loop, &io_->h, fd);
uv_poll_start(&io_->h, action, io_cb_wrap);
}
void EventServer::start_poll(int desc, int events) {
CHECK_EQ(std::this_thread::get_id(), thread_id_);
auto es_handle = poll_handles_[desc];
CHECK_EQ(0, uv_poll_start(&es_handle->uv_handle, events,
&EventServer::uv_poll_cb));
}
static getdns_return_t
getdns_libuv_schedule(getdns_eventloop *loop,
int fd, uint64_t timeout, getdns_eventloop_event *el_ev)
{
getdns_libuv *ext = (getdns_libuv *)loop;
poll_timer *my_ev;
uv_poll_t *my_poll;
uv_timer_t *my_timer;
assert(el_ev);
assert(!(el_ev->read_cb || el_ev->write_cb) || fd >= 0);
assert( el_ev->read_cb || el_ev->write_cb || el_ev->timeout_cb);
DEBUG_UV("enter libuv_schedule(el_ev = %p, el_ev->ev = %p)\n"
, el_ev, el_ev->ev);
if (!(my_ev = GETDNS_MALLOC(ext->mf, poll_timer)))
return GETDNS_RETURN_MEMORY_ERROR;
my_ev->to_close = 0;
my_ev->mf = ext->mf;
el_ev->ev = my_ev;
if (el_ev->read_cb) {
my_poll = &my_ev->read;
my_poll->data = el_ev;
uv_poll_init(ext->loop, my_poll, fd);
uv_poll_start(my_poll, UV_READABLE, getdns_libuv_read_cb);
}
if (el_ev->write_cb) {
my_poll = &my_ev->write;
my_poll->data = el_ev;
uv_poll_init(ext->loop, my_poll, fd);
uv_poll_start(my_poll, UV_WRITABLE, getdns_libuv_write_cb);
}
if (el_ev->timeout_cb) {
my_timer = &my_ev->timer;
my_timer->data = el_ev;
uv_timer_init(ext->loop, my_timer);
uv_timer_start(my_timer, getdns_libuv_timeout_cb, timeout, 0);
}
DEBUG_UV("exit libuv_schedule(el_ev = %p, el_ev->ev = %p)\n"
, el_ev, el_ev->ev);
return GETDNS_RETURN_GOOD;
}
// Events can be UV_READABLE | UV_WRITABLE | UV_DISCONNECT
void Poller::poll(int events) {
// fprintf(stdout, "Poller:poll for %d\n", events);
this->events = this->events | events;
int status = uv_poll_start(poll_handle, events, Poller::onData);
if (0 != status) {
Nan::ThrowTypeError(uv_strerror(status));
return;
}
}
void input_init(void)
{
log_msg("INIT", "INPUT");
tk = termkey_new(0,0);
termkey_set_flags(tk, TERMKEY_FLAG_UTF8 | TERMKEY_CANON_DELBS);
uv_poll_init(eventloop(), &poll_handle, 0);
uv_poll_start(&poll_handle, UV_READABLE, input_check);
}
void
lws_libuv_io(struct lws *wsi, int flags)
{
struct lws_context *context = lws_get_context(wsi);
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
int current_events = wsi->w_read.uv_watcher.io_watcher.pevents &
(UV_READABLE | UV_WRITABLE);
struct lws_io_watcher *w = &wsi->w_read;
if (!LWS_LIBUV_ENABLED(context))
return;
lwsl_debug("%s: wsi: %p, flags:%d\n", __func__, wsi, flags);
if (!pt->io_loop_uv) {
lwsl_info("%s: no io loop yet\n", __func__);
return;
}
assert((flags & (LWS_EV_START | LWS_EV_STOP)) &&
(flags & (LWS_EV_READ | LWS_EV_WRITE)));
if (flags & LWS_EV_START) {
if (flags & LWS_EV_WRITE)
current_events |= UV_WRITABLE;
if (flags & LWS_EV_READ)
current_events |= UV_READABLE;
uv_poll_start(&w->uv_watcher, current_events, lws_accept_cb);
} else {
if (flags & LWS_EV_WRITE)
current_events &= ~UV_WRITABLE;
if (flags & LWS_EV_READ)
current_events &= ~UV_READABLE;
if (!(current_events & (UV_READABLE | UV_WRITABLE)))
uv_poll_stop(&w->uv_watcher);
else
uv_poll_start(&w->uv_watcher, current_events,
lws_accept_cb);
}
}
static void
request_count_changed(uint32_t request_count, struct getdns_libuv_data *uv_data) {
if (request_count > 0 && uv_data->polling == 0) {
uv_poll_start(uv_data->poll_handle, UV_READABLE, getdns_libuv_cb);
uv_data->polling = 1;
} else if (request_count == 0 && uv_data->polling == 1) {
uv_poll_stop(uv_data->poll_handle);
uv_data->polling = 0;
}
}
static
void broker_server_new_client(uv_poll_t *poll,
int status, int events) {
(void) status;
(void) events;
Server *server = poll->data;
Client *client = dslink_calloc(1, sizeof(Client));
if (!client) {
goto fail;
}
client->server = server;
client->sock = dslink_socket_init(0);
if (!client->sock) {
dslink_free(client);
goto fail;
}
if (mbedtls_net_accept(&server->srv, &client->sock->socket_ctx,
NULL, 0, NULL) != 0) {
log_warn("Failed to accept a client connection\n");
goto fail_poll_setup;
}
uv_poll_t *clientPoll = dslink_malloc(sizeof(uv_poll_t));
if (!clientPoll) {
goto fail_poll_setup;
}
uv_loop_t *loop = poll->loop;
if (uv_poll_init(loop, clientPoll,
client->sock->socket_ctx.fd) != 0) {
dslink_free(clientPoll);
goto fail_poll_setup;
}
clientPoll->data = client;
client->poll = clientPoll;
uv_poll_start(clientPoll, UV_READABLE, broker_server_client_ready);
log_debug("Accepted a client connection\n");
return;
fail:
{
mbedtls_net_context tmp;
mbedtls_net_init(&tmp);
mbedtls_net_accept(&server->srv, &tmp, NULL, 0, NULL);
mbedtls_net_free(&tmp);
}
return;
fail_poll_setup:
dslink_socket_free(client->sock);
dslink_free(client);
}
/* _term_ef_poll(): update poll flags.
*/
static void
_term_ef_poll(u2_utty* uty_u)
{
if ( u2_no == u2_Host.ops_u.dem ) {
c3_i evt_i = ( ((u2_yes == u2_Host.ops_u.dem) ? 0 : UV_READABLE)
| ((0 == uty_u->out_u) ? 0 : UV_WRITABLE));
// fprintf(stderr, "ef_poll out_u %p\r\n", uty_u->out_u);
uv_poll_start(&(uty_u->wax_u), evt_i, _term_poll_cb);
}
}
int handle_socket(CURL *easy, curl_socket_t s, int action, void *userp, void *socketp) {
Socket_Info *si = 0;
Mathilda *m = (Mathilda *) userp;
if(action == CURL_POLL_IN || action == CURL_POLL_OUT || action == CURL_POLL_INOUT) {
if(socketp) {
si = (Socket_Info *) socketp;
} else {
si = new Socket_Info(s, m);
curl_multi_assign(m->multi_handle, s, (void *) si);
}
}
switch(action) {
case CURL_POLL_IN:
uv_poll_start(&si->poll_handle, UV_READABLE, curl_perform);
break;
case CURL_POLL_OUT:
uv_poll_start(&si->poll_handle, UV_WRITABLE, curl_perform);
break;
case CURL_POLL_INOUT:
uv_poll_start(&si->poll_handle, UV_READABLE | UV_WRITABLE, curl_perform);
break;
case CURL_POLL_REMOVE:
if(socketp) {
si = (Socket_Info *) socketp;
uv_poll_stop(&si->poll_handle);
uv_close((uv_handle_t *) &si->poll_handle, curl_close_cb);
curl_multi_assign(m->multi_handle, s, NULL);
}
break;
default:
fprintf(stderr, "[Mathilda (%d)] Unknown libcurl action (%d). Aborting!\n", m->proc_num, action);
abort();
}
return 0;
}
static void poll_cb(uv_poll_t* h, int status, int events) {
int r;
ASSERT(status == 0);
ASSERT(h == &handle);
r = uv_poll_start(&handle, UV_READABLE, poll_cb);
ASSERT(r == 0);
closesocket(sock);
uv_close((uv_handle_t*) &handle, close_cb);
}
static void
_log(const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
log_buf_pos += vsnprintf(log_buf + log_buf_pos,
sizeof(log_buf) - log_buf_pos, fmt, ap);
va_end(ap);
log_buf_nul_term();
uv_poll_start(&stdout_watcher, UV_WRITABLE, stdout_cb); // turn on writeable check
}
void NodeData::asyncCallback(uv_async_t *async)
{
NodeData *nodeData = (NodeData *) async->data;
nodeData->asyncMutex->lock();
for (TransferData transferData : nodeData->transferQueue) {
uv_poll_init_socket(nodeData->loop, transferData.p, transferData.fd);
transferData.p->data = transferData.socketData;
transferData.socketData->nodeData = nodeData;
uv_poll_start(transferData.p, transferData.socketData->poll, transferData.pollCb);
transferData.cb(transferData.p);
}
for (uv_poll_t *p : nodeData->changePollQueue) {
SocketData *socketData = (SocketData *) p->data;
uv_poll_start(p, socketData->poll, /*p->poll_cb*/ Socket(p).getPollCallback());
}
nodeData->changePollQueue.clear();
nodeData->transferQueue.clear();
nodeData->asyncMutex->unlock();
}
// Pass Curl events on its fd sockets
int iotjs_https_curl_socket_callback(CURL* easy, curl_socket_t sockfd,
int action, void* userp, void* socketp) {
iotjs_https_t* https_data = (iotjs_https_t*)userp;
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_https_t, https_data);
if (action == CURL_POLL_IN || action == CURL_POLL_OUT ||
action == CURL_POLL_INOUT) {
iotjs_https_poll_t* poll_data = NULL;
if (!socketp) {
poll_data = iotjs_https_poll_create(_this->loop, sockfd, https_data);
curl_multi_assign(_this->curl_multi_handle, sockfd, (void*)poll_data);
_this->closing_handles = _this->closing_handles + 1;
if (_this->poll_data == NULL)
_this->poll_data = poll_data;
else
iotjs_https_poll_append(_this->poll_data, poll_data);
} else
poll_data = (iotjs_https_poll_t*)socketp;
if (action == CURL_POLL_IN)
uv_poll_start(iotjs_https_poll_get_poll_handle(poll_data), UV_READABLE,
iotjs_https_uv_poll_callback);
else if (action == CURL_POLL_OUT)
uv_poll_start(iotjs_https_poll_get_poll_handle(poll_data), UV_WRITABLE,
iotjs_https_uv_poll_callback);
else if (action == CURL_POLL_INOUT)
uv_poll_start(iotjs_https_poll_get_poll_handle(poll_data),
UV_READABLE | UV_WRITABLE, iotjs_https_uv_poll_callback);
} else {
if (socketp) {
iotjs_https_poll_t* poll_data = (iotjs_https_poll_t*)socketp;
iotjs_https_poll_close(poll_data);
curl_multi_assign(_this->curl_multi_handle, sockfd, NULL);
}
}
return 0;
}
int _socket_function(void * clientp, http_server_socket_t sock, int flags, void * socketp)
{
client_context * ctx = socketp;
if (!ctx)
{
fprintf(stderr, "create new context for %d\n", sock);
ctx = create_client_context(sock);
http_server_assign(&srv, sock, ctx);
}
assert(ctx);
if (flags & HTTP_SERVER_POLL_IN)
{
uv_poll_start(&ctx->poll_handle, UV_READABLE, http_perform);
}
if (flags & HTTP_SERVER_POLL_OUT)
{
uv_poll_start(&ctx->poll_handle, UV_WRITABLE, http_perform);
}
if (flags & HTTP_SERVER_POLL_REMOVE)
{
destroy_http_context((client_context*) socketp);
}
return HTTP_SERVER_OK;
}
int
main(int argc, const char* const* argv)
{
printf("GIMME YOUR INPUTS!\n");
// set stdin/out to nonblocking
set_non_blocking(STDIN_FILENO);
set_non_blocking(STDOUT_FILENO);
loop = uv_default_loop();
uv_poll_init(loop, &stdin_watcher, STDIN_FILENO);
uv_poll_init(loop, &stdout_watcher, STDOUT_FILENO);
uv_poll_start(&stdin_watcher, UV_READABLE, stdin_cb);
uv_run(loop, 0);
return 0;
}
static
int start_http_server(Server *server, const char *host,
const char *port, uv_loop_t *loop,
uv_poll_t *poll) {
if (mbedtls_net_bind(&server->srv, host, port, MBEDTLS_NET_PROTO_TCP) != 0) {
log_fatal("Failed to bind to %s:%s\n", host, port);
return 0;
} else {
log_info("HTTP server bound to %s:%s\n", host, port);
}
uv_poll_init(loop, poll, server->srv.fd);
poll->data = server;
uv_poll_start(poll, UV_READABLE, broker_server_new_client);
return 1;
}
static void start_server(void) {
server_context_t* context;
struct sockaddr_in addr;
uv_os_sock_t sock;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
sock = create_bound_socket(addr);
context = create_server_context(sock);
r = listen(sock, 100);
ASSERT(r == 0);
r = uv_poll_start(&context->poll_handle, UV_READABLE, server_poll_cb);
ASSERT(r == 0);
}
int CANWrap::doPoll()
{
if (m_closed)
{
return -1;
}
if (m_pollEvents)
{
return uv_poll_start(&m_uvHandle, m_pollEvents, uvPollCallback);
}
else
{
return uv_poll_stop(&m_uvHandle);
}
}
