2 * libwebsockets - small server side websockets and web server implementation
4 * Copyright (C) 2010-2016 Andy Green <andy@warmcat.com>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation:
9 * version 2.1 of the License.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
22 #include "private-libwebsockets.h"
25 lws_feature_status_libuv(struct lws_context_creation_info *info)
27 if (lws_check_opt(info->options, LWS_SERVER_OPTION_LIBUV))
28 lwsl_notice("libuv support compiled in and enabled\n");
30 lwsl_notice("libuv support compiled in but disabled\n");
34 lws_uv_idle(uv_idle_t *handle
35 #if UV_VERSION_MAJOR == 0
40 struct lws_context_per_thread *pt = lws_container_of(handle,
41 struct lws_context_per_thread, uv_idle);
43 lwsl_debug("%s\n", __func__);
46 * is there anybody with pending stuff that needs service forcing?
48 if (!lws_service_adjust_timeout(pt->context, 1, pt->tid)) {
49 /* -1 timeout means just do forced service */
50 _lws_plat_service_tsi(pt->context, -1, pt->tid);
51 /* still somebody left who wants forced service? */
52 if (!lws_service_adjust_timeout(pt->context, 1, pt->tid))
53 /* yes... come back again later */
54 lwsl_debug("%s: done again\n", __func__);
58 /* there is nobody who needs service forcing, shut down idle */
61 lwsl_debug("%s: done stop\n", __func__);
65 lws_io_cb(uv_poll_t *watcher, int status, int revents)
67 struct lws_io_watcher *lws_io = lws_container_of(watcher,
68 struct lws_io_watcher, uv_watcher);
69 struct lws *wsi = lws_container_of(lws_io, struct lws, w_read);
70 struct lws_context *context = lws_io->context;
71 struct lws_pollfd eventfd;
73 #if defined(WIN32) || defined(_WIN32)
74 eventfd.fd = watcher->socket;
76 eventfd.fd = watcher->io_watcher.fd;
82 /* at this point status will be an UV error, like UV_EBADF,
83 we treat all errors as LWS_POLLHUP */
85 /* you might want to return; instead of servicing the fd in some cases */
86 if (status == UV_EAGAIN)
89 eventfd.events |= LWS_POLLHUP;
90 eventfd.revents |= LWS_POLLHUP;
92 if (revents & UV_READABLE) {
93 eventfd.events |= LWS_POLLIN;
94 eventfd.revents |= LWS_POLLIN;
96 if (revents & UV_WRITABLE) {
97 eventfd.events |= LWS_POLLOUT;
98 eventfd.revents |= LWS_POLLOUT;
101 lws_service_fd(context, &eventfd);
103 uv_idle_start(&context->pt[(int)wsi->tsi].uv_idle, lws_uv_idle);
107 lws_uv_sigint_cb(uv_signal_t *watcher, int signum)
109 lwsl_err("internal signal handler caught signal %d\n", signum);
110 lws_libuv_stop(watcher->data);
114 lws_uv_sigint_cfg(struct lws_context *context, int use_uv_sigint,
117 context->use_ev_sigint = use_uv_sigint;
119 context->lws_uv_sigint_cb = cb;
121 context->lws_uv_sigint_cb = &lws_uv_sigint_cb;
127 lws_uv_timeout_cb(uv_timer_t *timer
128 #if UV_VERSION_MAJOR == 0
133 struct lws_context_per_thread *pt = lws_container_of(timer,
134 struct lws_context_per_thread, uv_timeout_watcher);
136 if (pt->context->requested_kill)
139 lwsl_debug("%s\n", __func__);
141 lws_service_fd_tsi(pt->context, NULL, pt->tid);
144 static const int sigs[] = { SIGINT, SIGTERM, SIGSEGV, SIGFPE };
147 lws_uv_initloop(struct lws_context *context, uv_loop_t *loop, int tsi)
149 struct lws_context_per_thread *pt = &context->pt[tsi];
150 struct lws_vhost *vh = context->vhost_list;
151 int status = 0, n, ns;
154 loop = lws_malloc(sizeof(*loop));
159 #if UV_VERSION_MAJOR > 0
162 lwsl_err("This libuv is too old to work...\n");
165 pt->ev_loop_foreign = 0;
167 lwsl_notice(" Using foreign event loop...\n");
168 pt->ev_loop_foreign = 1;
171 pt->io_loop_uv = loop;
172 uv_idle_init(loop, &pt->uv_idle);
174 ns = ARRAY_SIZE(sigs);
175 if (lws_check_opt(context->options, LWS_SERVER_OPTION_UV_NO_SIGSEGV_SIGFPE_SPIN))
178 if (pt->context->use_ev_sigint) {
179 assert(ns <= ARRAY_SIZE(pt->signals));
180 for (n = 0; n < ns; n++) {
181 uv_signal_init(loop, &pt->signals[n]);
182 pt->signals[n].data = pt->context;
183 uv_signal_start(&pt->signals[n],
184 context->lws_uv_sigint_cb, sigs[n]);
189 * Initialize the accept wsi read watcher with all the listening sockets
190 * and register a callback for read operations
192 * We have to do it here because the uv loop(s) are not
193 * initialized until after context creation.
197 vh->lserv_wsi->w_read.context = context;
198 n = uv_poll_init_socket(pt->io_loop_uv,
199 &vh->lserv_wsi->w_read.uv_watcher,
200 vh->lserv_wsi->sock);
202 lwsl_err("uv_poll_init failed %d, sockfd=%p\n",
203 n, (void *)(long)vh->lserv_wsi->sock);
207 lws_libuv_io(vh->lserv_wsi, LWS_EV_START | LWS_EV_READ);
212 uv_timer_init(pt->io_loop_uv, &pt->uv_timeout_watcher);
213 uv_timer_start(&pt->uv_timeout_watcher, lws_uv_timeout_cb, 10, 1000);
218 static void lws_uv_close_cb(uv_handle_t *handle)
220 //lwsl_err("%s: handle %p\n", __func__, handle);
223 static void lws_uv_walk_cb(uv_handle_t *handle, void *arg)
225 uv_close(handle, lws_uv_close_cb);
229 lws_libuv_destroyloop(struct lws_context *context, int tsi)
231 struct lws_context_per_thread *pt = &context->pt[tsi];
232 int m, budget = 100, ns;
234 if (!lws_check_opt(context->options, LWS_SERVER_OPTION_LIBUV))
240 if (context->use_ev_sigint) {
241 uv_signal_stop(&pt->w_sigint.uv_watcher);
243 ns = ARRAY_SIZE(sigs);
244 if (lws_check_opt(context->options, LWS_SERVER_OPTION_UV_NO_SIGSEGV_SIGFPE_SPIN))
247 for (m = 0; m < ns; m++) {
248 uv_signal_stop(&pt->signals[m]);
249 uv_close((uv_handle_t *)&pt->signals[m], lws_uv_close_cb);
253 uv_timer_stop(&pt->uv_timeout_watcher);
254 uv_close((uv_handle_t *)&pt->uv_timeout_watcher, lws_uv_close_cb);
256 uv_idle_stop(&pt->uv_idle);
257 uv_close((uv_handle_t *)&pt->uv_idle, lws_uv_close_cb);
259 while (budget-- && uv_run(pt->io_loop_uv, UV_RUN_NOWAIT))
262 if (pt->ev_loop_foreign)
265 uv_stop(pt->io_loop_uv);
267 uv_walk(pt->io_loop_uv, lws_uv_walk_cb, NULL);
269 while (uv_run(pt->io_loop_uv, UV_RUN_NOWAIT))
271 #if UV_VERSION_MAJOR > 0
272 m = uv_loop_close(pt->io_loop_uv);
274 lwsl_err("%s: uv_loop_close: UV_EBUSY\n", __func__);
276 lws_free(pt->io_loop_uv);
280 lws_libuv_accept(struct lws *wsi, lws_sockfd_type accept_fd)
282 struct lws_context *context = lws_get_context(wsi);
283 struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
285 if (!LWS_LIBUV_ENABLED(context))
288 lwsl_debug("%s: new wsi %p\n", __func__, wsi);
290 wsi->w_read.context = context;
292 uv_poll_init_socket(pt->io_loop_uv, &wsi->w_read.uv_watcher, accept_fd);
296 lws_libuv_io(struct lws *wsi, int flags)
298 struct lws_context *context = lws_get_context(wsi);
299 struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
300 #if defined(WIN32) || defined(_WIN32)
301 int current_events = wsi->w_read.uv_watcher.events &
302 (UV_READABLE | UV_WRITABLE);
304 int current_events = wsi->w_read.uv_watcher.io_watcher.pevents &
305 (UV_READABLE | UV_WRITABLE);
307 struct lws_io_watcher *w = &wsi->w_read;
309 if (!LWS_LIBUV_ENABLED(context))
312 // lwsl_notice("%s: wsi: %p, flags:0x%x\n", __func__, wsi, flags);
314 if (!pt->io_loop_uv) {
315 lwsl_info("%s: no io loop yet\n", __func__);
319 if (!((flags & (LWS_EV_START | LWS_EV_STOP)) &&
320 (flags & (LWS_EV_READ | LWS_EV_WRITE)))) {
321 lwsl_err("%s: assert: flags %d", __func__, flags);
325 if (flags & LWS_EV_START) {
326 if (flags & LWS_EV_WRITE)
327 current_events |= UV_WRITABLE;
329 if (flags & LWS_EV_READ)
330 current_events |= UV_READABLE;
332 uv_poll_start(&w->uv_watcher, current_events, lws_io_cb);
334 if (flags & LWS_EV_WRITE)
335 current_events &= ~UV_WRITABLE;
337 if (flags & LWS_EV_READ)
338 current_events &= ~UV_READABLE;
340 if (!(current_events & (UV_READABLE | UV_WRITABLE)))
341 uv_poll_stop(&w->uv_watcher);
343 uv_poll_start(&w->uv_watcher, current_events,
349 lws_libuv_init_fd_table(struct lws_context *context)
353 if (!LWS_LIBUV_ENABLED(context))
356 for (n = 0; n < context->count_threads; n++)
357 context->pt[n].w_sigint.context = context;
363 lws_libuv_run(const struct lws_context *context, int tsi)
365 if (context->pt[tsi].io_loop_uv && LWS_LIBUV_ENABLED(context))
366 uv_run(context->pt[tsi].io_loop_uv, 0);
370 lws_libuv_kill(const struct lws_context *context)
374 for (n = 0; n < context->count_threads; n++)
375 if (context->pt[n].io_loop_uv &&
376 LWS_LIBUV_ENABLED(context) &&
377 !context->pt[n].ev_loop_foreign)
378 uv_stop(context->pt[n].io_loop_uv);
382 * This does not actually stop the event loop. The reason is we have to pass
383 * libuv handle closures through its event loop. So this tries to close all
384 * wsi, and set a flag; when all the wsi closures are finalized then we
385 * actually stop the libuv event loops.
389 lws_libuv_stop(struct lws_context *context)
391 struct lws_context_per_thread *pt;
394 if (context->requested_kill)
397 context->requested_kill = 1;
399 m = context->count_threads;
400 context->being_destroyed = 1;
403 pt = &context->pt[m];
405 for (n = 0; (unsigned int)n < context->pt[m].fds_count; n++) {
406 struct lws *wsi = wsi_from_fd(context, pt->fds[n].fd);
410 lws_close_free_wsi(wsi,
411 LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY
412 /* no protocol close */);
417 lwsl_info("%s: feels everything closed\n", __func__);
418 if (context->count_wsi_allocated == 0)
419 lws_libuv_kill(context);
422 LWS_VISIBLE uv_loop_t *
423 lws_uv_getloop(struct lws_context *context, int tsi)
425 if (context->pt[tsi].io_loop_uv && LWS_LIBUV_ENABLED(context))
426 return context->pt[tsi].io_loop_uv;
432 lws_libuv_closewsi(uv_handle_t* handle)
434 struct lws *n = NULL, *wsi = (struct lws *)(((char *)handle) -
435 (char *)(&n->w_read.uv_watcher));
436 struct lws_context *context = lws_get_context(wsi);
438 lws_close_free_wsi_final(wsi);
440 if (context->requested_kill && context->count_wsi_allocated == 0)
441 lws_libuv_kill(context);
445 lws_libuv_closehandle(struct lws *wsi)
447 struct lws_context *context = lws_get_context(wsi);
449 /* required to defer actual deletion until libuv has processed it */
451 uv_close((uv_handle_t*)&wsi->w_read.uv_watcher, lws_libuv_closewsi);
453 if (context->requested_kill && context->count_wsi_allocated == 0)
454 lws_libuv_kill(context);
457 #if defined(LWS_WITH_PLUGINS) && (UV_VERSION_MAJOR > 0)
460 lws_plat_plugins_init(struct lws_context * context, const char * const *d)
462 struct lws_plugin_capability lcaps;
463 struct lws_plugin *plugin;
464 lws_plugin_init_func initfunc;
478 lwsl_notice(" Plugins:\n");
482 lwsl_notice(" Scanning %s\n", *d);
483 m =uv_fs_scandir(&loop, &req, *d, 0, NULL);
485 lwsl_err("Scandir on %s failed\n", *d);
489 while (uv_fs_scandir_next(&req, &dent) != UV_EOF) {
490 if (strlen(dent.name) < 7)
493 lwsl_notice(" %s\n", dent.name);
495 lws_snprintf(path, sizeof(path) - 1, "%s/%s", *d, dent.name);
496 if (uv_dlopen(path, &lib)) {
498 lwsl_err("Error loading DSO: %s\n", lib.errmsg);
501 /* we could open it, can we get his init function? */
503 m = lws_snprintf(path, sizeof(path) - 1, "init_%s",
504 dent.name + 3 /* snip lib... */);
505 path[m - 3] = '\0'; /* snip the .so */
507 m = lws_snprintf(path, sizeof(path) - 1, "init_%s",
509 path[m - 4] = '\0'; /* snip the .dll */
511 if (uv_dlsym(&lib, path, &v)) {
513 lwsl_err("Failed to get init on %s: %s",
514 dent.name, lib.errmsg);
517 initfunc = (lws_plugin_init_func)v;
518 lcaps.api_magic = LWS_PLUGIN_API_MAGIC;
519 m = initfunc(context, &lcaps);
521 lwsl_err("Initializing %s failed %d\n", dent.name, m);
525 plugin = lws_malloc(sizeof(*plugin));
530 plugin->list = context->plugin_list;
531 context->plugin_list = plugin;
532 strncpy(plugin->name, dent.name, sizeof(plugin->name) - 1);
533 plugin->name[sizeof(plugin->name) - 1] = '\0';
535 plugin->caps = lcaps;
536 context->plugin_protocol_count += lcaps.count_protocols;
537 context->plugin_extension_count += lcaps.count_extensions;
545 uv_fs_req_cleanup(&req);
549 uv_loop_close(&loop);
556 lws_plat_plugins_destroy(struct lws_context * context)
558 struct lws_plugin *plugin = context->plugin_list, *p;
559 lws_plugin_destroy_func func;
567 // lwsl_notice("%s\n", __func__);
572 m = lws_snprintf(path, sizeof(path) - 1, "destroy_%s", plugin->name + 3);
575 m = lws_snprintf(path, sizeof(path) - 1, "destroy_%s", plugin->name);
579 if (uv_dlsym(&plugin->lib, path, &v)) {
580 uv_dlerror(&plugin->lib);
581 lwsl_err("Failed to get init on %s: %s",
582 plugin->name, plugin->lib.errmsg);
584 func = (lws_plugin_destroy_func)v;
587 lwsl_err("Destroying %s failed %d\n",
597 context->plugin_list = NULL;