}
static void
+lws_uv_idle(uv_idle_t *handle
+#if UV_VERSION_MAJOR == 0
+ , int status
+#endif
+)
+{
+ struct lws_context_per_thread *pt = lws_container_of(handle,
+ struct lws_context_per_thread, uv_idle);
+
+// lwsl_debug("%s\n", __func__);
+
+ /*
+ * is there anybody with pending stuff that needs service forcing?
+ */
+ if (!lws_service_adjust_timeout(pt->context, 1, pt->tid)) {
+ /* -1 timeout means just do forced service */
+ _lws_plat_service_tsi(pt->context, -1, pt->tid);
+ /* still somebody left who wants forced service? */
+ if (!lws_service_adjust_timeout(pt->context, 1, pt->tid))
+ /* yes... come back again later */
+// lwsl_debug("%s: done again\n", __func__);
+ return;
+ }
+
+ /* there is nobody who needs service forcing, shut down idle */
+ uv_idle_stop(handle);
+
+ //lwsl_debug("%s: done stop\n", __func__);
+}
+
+static void
lws_io_cb(uv_poll_t *watcher, int status, int revents)
{
- struct lws_io_watcher *lws_io = container_of(watcher,
+ struct lws_io_watcher *lws_io = lws_container_of(watcher,
struct lws_io_watcher, uv_watcher);
- struct lws_context *context = lws_io->context;
+ struct lws *wsi = lws_container_of(lws_io, struct lws, w_read);
+ struct lws_context *context = wsi->context;
struct lws_pollfd eventfd;
+#if defined(WIN32) || defined(_WIN32)
+ eventfd.fd = watcher->socket;
+#else
eventfd.fd = watcher->io_watcher.fd;
+#endif
eventfd.events = 0;
eventfd.revents = 0;
}
}
lws_service_fd(context, &eventfd);
+
+ uv_idle_start(&context->pt[(int)wsi->tsi].uv_idle, lws_uv_idle);
}
LWS_VISIBLE void
lws_uv_sigint_cb(uv_signal_t *watcher, int signum)
{
- lwsl_info("internal signal handler caught signal %d\n", signum);
+ lwsl_err("internal signal handler caught signal %d\n", signum);
lws_libuv_stop(watcher->data);
}
}
static void
-lws_uv_timeout_cb(uv_timer_t *timer)
+lws_uv_timeout_cb(uv_timer_t *timer
+#if UV_VERSION_MAJOR == 0
+ , int status
+#endif
+)
{
- struct lws_context_per_thread *pt = container_of(timer,
+ struct lws_context_per_thread *pt = lws_container_of(timer,
struct lws_context_per_thread, uv_timeout_watcher);
+ if (pt->context->requested_kill)
+ return;
+
lwsl_debug("%s\n", __func__);
- /* do timeout check only */
+
lws_service_fd_tsi(pt->context, NULL, pt->tid);
}
-static const int sigs[] = { SIGINT, SIGTERM, SIGSEGV, SIGFPE };
+static const int sigs[] = { SIGINT, SIGTERM, SIGSEGV, SIGFPE, SIGHUP };
+
+int
+lws_uv_initvhost(struct lws_vhost* vh, struct lws* wsi)
+{
+ struct lws_context_per_thread *pt;
+ int n;
+
+ if (!LWS_LIBUV_ENABLED(vh->context))
+ return 0;
+ if (!wsi)
+ wsi = vh->lserv_wsi;
+ if (!wsi)
+ return 0;
+ if (wsi->w_read.context)
+ return 0;
+
+ pt = &vh->context->pt[(int)wsi->tsi];
+ if (!pt->io_loop_uv)
+ return 0;
+
+ wsi->w_read.context = vh->context;
+ n = uv_poll_init_socket(pt->io_loop_uv,
+ &wsi->w_read.uv_watcher, wsi->desc.sockfd);
+ if (n) {
+ lwsl_err("uv_poll_init failed %d, sockfd=%p\n",
+ n, (void *)(lws_intptr_t)wsi->desc.sockfd);
+
+ return -1;
+ }
+ lws_libuv_io(wsi, LWS_EV_START | LWS_EV_READ);
+
+ return 0;
+}
+
+/*
+ * This needs to be called after vhosts have been defined.
+ *
+ * If later, after server start, another vhost is added, this must be
+ * called again to bind the vhost
+ */
LWS_VISIBLE int
lws_uv_initloop(struct lws_context *context, uv_loop_t *loop, int tsi)
{
struct lws_context_per_thread *pt = &context->pt[tsi];
struct lws_vhost *vh = context->vhost_list;
- int status = 0, n;
+ int status = 0, n, ns, first = 1;
- if (!loop) {
- loop = lws_malloc(sizeof(*loop));
- uv_loop_init(loop);
- pt->ev_loop_foreign = 0;
- } else
- pt->ev_loop_foreign = 1;
-
- pt->io_loop_uv = loop;
+ if (!pt->io_loop_uv) {
+ if (!loop) {
+ loop = lws_malloc(sizeof(*loop));
+ if (!loop) {
+ lwsl_err("OOM\n");
+ return -1;
+ }
+ #if UV_VERSION_MAJOR > 0
+ uv_loop_init(loop);
+ #else
+ lwsl_err("This libuv is too old to work...\n");
+ return 1;
+ #endif
+ pt->ev_loop_foreign = 0;
+ } else {
+ lwsl_notice(" Using foreign event loop...\n");
+ pt->ev_loop_foreign = 1;
+ }
- if (pt->context->use_ev_sigint) {
- assert(ARRAY_SIZE(sigs) <= ARRAY_SIZE(pt->signals));
- for (n = 0; n < ARRAY_SIZE(sigs); n++) {
- uv_signal_init(loop, &pt->signals[n]);
- pt->signals[n].data = pt->context;
- uv_signal_start(&pt->signals[n],
- context->lws_uv_sigint_cb, sigs[n]);
+ pt->io_loop_uv = loop;
+ uv_idle_init(loop, &pt->uv_idle);
+
+ ns = ARRAY_SIZE(sigs);
+ if (lws_check_opt(context->options,
+ LWS_SERVER_OPTION_UV_NO_SIGSEGV_SIGFPE_SPIN))
+ ns = 2;
+
+ if (pt->context->use_ev_sigint) {
+ assert(ns <= ARRAY_SIZE(pt->signals));
+ for (n = 0; n < ns; n++) {
+ uv_signal_init(loop, &pt->signals[n]);
+ pt->signals[n].data = pt->context;
+ uv_signal_start(&pt->signals[n],
+ context->lws_uv_sigint_cb, sigs[n]);
+ }
}
- }
+ } else
+ first = 0;
/*
* Initialize the accept wsi read watcher with all the listening sockets
* initialized until after context creation.
*/
while (vh) {
- if (vh->lserv_wsi) {
- vh->lserv_wsi->w_read.context = context;
- uv_poll_init(pt->io_loop_uv,
- &vh->lserv_wsi->w_read.uv_watcher,
- vh->lserv_wsi->sock);
- uv_poll_start(&vh->lserv_wsi->w_read.uv_watcher,
- UV_READABLE, lws_io_cb);
- }
+ if (lws_uv_initvhost(vh, vh->lserv_wsi) == -1)
+ return -1;
vh = vh->vhost_next;
}
- uv_timer_init(pt->io_loop_uv, &pt->uv_timeout_watcher);
- uv_timer_start(&pt->uv_timeout_watcher, lws_uv_timeout_cb, 1000, 1000);
+ if (first) {
+ uv_timer_init(pt->io_loop_uv, &pt->uv_timeout_watcher);
+ uv_timer_start(&pt->uv_timeout_watcher, lws_uv_timeout_cb,
+ 10, 1000);
+ }
return status;
}
-void lws_uv_close_cb(uv_handle_t *handle)
+static void lws_uv_close_cb(uv_handle_t *handle)
{
+ //lwsl_err("%s: handle %p\n", __func__, handle);
+}
+static void lws_uv_walk_cb(uv_handle_t *handle, void *arg)
+{
+ if (!uv_is_closing(handle))
+ uv_close(handle, lws_uv_close_cb);
}
-void lws_uv_walk_cb(uv_handle_t *handle, void *arg)
+LWS_VISIBLE void
+lws_close_all_handles_in_loop(uv_loop_t *loop)
{
- uv_close(handle, lws_uv_close_cb);
+ uv_walk(loop, lws_uv_walk_cb, NULL);
}
void
lws_libuv_destroyloop(struct lws_context *context, int tsi)
{
struct lws_context_per_thread *pt = &context->pt[tsi];
- int m;
+// struct lws_context *ctx;
+ int m, budget = 100, ns;
if (!lws_check_opt(context->options, LWS_SERVER_OPTION_LIBUV))
return;
if (!pt->io_loop_uv)
return;
- if (context->use_ev_sigint)
+ lwsl_notice("%s: closing signals + timers context %p\n", __func__, context);
+
+ if (context->use_ev_sigint) {
uv_signal_stop(&pt->w_sigint.uv_watcher);
- for (m = 0; m < ARRAY_SIZE(sigs); m++)
- uv_signal_stop(&pt->signals[m]);
- if (!pt->ev_loop_foreign) {
- uv_stop(pt->io_loop_uv);
- uv_walk(pt->io_loop_uv, lws_uv_walk_cb, NULL);
- while (uv_run(pt->io_loop_uv, UV_RUN_NOWAIT));
- m = uv_loop_close(pt->io_loop_uv);
- if (m == UV_EBUSY)
- lwsl_debug("%s: uv_loop_close: UV_EBUSY\n", __func__);
- lws_free(pt->io_loop_uv);
+
+ ns = ARRAY_SIZE(sigs);
+ if (lws_check_opt(context->options, LWS_SERVER_OPTION_UV_NO_SIGSEGV_SIGFPE_SPIN))
+ ns = 2;
+
+ for (m = 0; m < ns; m++) {
+ uv_signal_stop(&pt->signals[m]);
+ uv_close((uv_handle_t *)&pt->signals[m], lws_uv_close_cb);
+ }
}
+
+ uv_timer_stop(&pt->uv_timeout_watcher);
+ uv_close((uv_handle_t *)&pt->uv_timeout_watcher, lws_uv_close_cb);
+
+ uv_idle_stop(&pt->uv_idle);
+ uv_close((uv_handle_t *)&pt->uv_idle, lws_uv_close_cb);
+
+ if (pt->ev_loop_foreign)
+ return;
+
+ while (budget-- && uv_run(pt->io_loop_uv, UV_RUN_NOWAIT))
+ ;
+
+ lwsl_notice("%s: closing all loop handles context %p\n", __func__, context);
+
+ uv_stop(pt->io_loop_uv);
+
+ uv_walk(pt->io_loop_uv, lws_uv_walk_cb, NULL);
+
+ while (uv_run(pt->io_loop_uv, UV_RUN_NOWAIT))
+ ;
+#if UV_VERSION_MAJOR > 0
+ m = uv_loop_close(pt->io_loop_uv);
+ if (m == UV_EBUSY)
+ lwsl_err("%s: uv_loop_close: UV_EBUSY\n", __func__);
+#endif
+ lws_free(pt->io_loop_uv);
}
void
-lws_libuv_accept(struct lws *wsi, int accept_fd)
+lws_libuv_accept(struct lws *wsi, lws_sock_file_fd_type desc)
{
struct lws_context *context = lws_get_context(wsi);
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
lwsl_debug("%s: new wsi %p\n", __func__, wsi);
wsi->w_read.context = context;
-
- uv_poll_init(pt->io_loop_uv, &wsi->w_read.uv_watcher, accept_fd);
+ if (wsi->mode == LWSCM_RAW_FILEDESC)
+ uv_poll_init(pt->io_loop_uv, &wsi->w_read.uv_watcher,
+ (int)desc.filefd);
+ else
+ uv_poll_init_socket(pt->io_loop_uv, &wsi->w_read.uv_watcher,
+ desc.sockfd);
}
void
{
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_debug("%s: wsi: %p, flags:%d\n", __func__, wsi, flags);
+ // lwsl_notice("%s: wsi: %p, flags:0x%x\n", __func__, wsi, flags);
- if (!pt->io_loop_uv) {
+ // 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;
}
- assert((flags & (LWS_EV_START | LWS_EV_STOP)) &&
- (flags & (LWS_EV_READ | LWS_EV_WRITE)));
+ 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)
if (!LWS_LIBUV_ENABLED(context))
return 0;
- for (n = 0; n < context->count_threads; n++) {
+ for (n = 0; n < context->count_threads; n++)
context->pt[n].w_sigint.context = context;
- }
return 1;
}
uv_run(context->pt[tsi].io_loop_uv, 0);
}
+LWS_VISIBLE void
+lws_libuv_stop_without_kill(const struct lws_context *context, int tsi)
+{
+ if (context->pt[tsi].io_loop_uv && LWS_LIBUV_ENABLED(context))
+ uv_stop(context->pt[tsi].io_loop_uv);
+}
+
static void
lws_libuv_kill(const struct lws_context *context)
{
int n;
+ lwsl_notice("%s\n", __func__);
+
for (n = 0; n < context->count_threads; n++)
- if (context->pt[n].io_loop_uv && LWS_LIBUV_ENABLED(context))
+ if (context->pt[n].io_loop_uv &&
+ LWS_LIBUV_ENABLED(context) )//&&
+ //!context->pt[n].ev_loop_foreign)
uv_stop(context->pt[n].io_loop_uv);
- // TODO uv_stop check foreign loop? or not?
}
/*
struct lws_context_per_thread *pt;
int n, m;
+ if (context->requested_kill)
+ return;
+
context->requested_kill = 1;
m = context->count_threads;
for (n = 0; (unsigned int)n < context->pt[m].fds_count; n++) {
struct lws *wsi = wsi_from_fd(context, pt->fds[n].fd);
+
if (!wsi)
continue;
-
lws_close_free_wsi(wsi,
LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY
/* no protocol close */);
}
}
+ lwsl_info("%s: feels everything closed\n", __func__);
if (context->count_wsi_allocated == 0)
lws_libuv_kill(context);
}
static void
lws_libuv_closewsi(uv_handle_t* handle)
{
- struct lws *n = NULL, *wsi = (struct lws *)(((void *)handle) -
- (void *)(&n->w_read.uv_watcher));
+ struct lws *n = NULL, *wsi = (struct lws *)(((char *)handle) -
+ (char *)(&n->w_read.uv_watcher));
struct lws_context *context = lws_get_context(wsi);
+ int lspd = 0;
+
+ if (wsi->mode == LWSCM_SERVER_LISTENER &&
+ wsi->context->deprecated) {
+ lspd = 1;
+ context->deprecation_pending_listen_close_count--;
+ if (!context->deprecation_pending_listen_close_count)
+ lspd = 2;
+ }
lws_close_free_wsi_final(wsi);
+ if (lspd == 2 && context->deprecation_cb) {
+ lwsl_notice("calling deprecation callback\n");
+ context->deprecation_cb();
+ }
+
+ //lwsl_notice("%s: ctx %p: wsi left %d\n", __func__, context, context->count_wsi_allocated);
+
if (context->requested_kill && context->count_wsi_allocated == 0)
lws_libuv_kill(context);
}
struct lws_context *context = lws_get_context(wsi);
/* required to defer actual deletion until libuv has processed it */
-
uv_close((uv_handle_t*)&wsi->w_read.uv_watcher, lws_libuv_closewsi);
if (context->requested_kill && context->count_wsi_allocated == 0)
lws_libuv_kill(context);
}
+
+static void
+lws_libuv_closewsi_m(uv_handle_t* handle)
+{
+ lws_sockfd_type sockfd = (lws_sockfd_type)(lws_intptr_t)handle->data;
+
+ compatible_close(sockfd);
+}
+
+void
+lws_libuv_closehandle_manually(struct lws *wsi)
+{
+ uv_handle_t *h = (void *)&wsi->w_read.uv_watcher;
+
+ h->data = (void *)(lws_intptr_t)wsi->desc.sockfd;
+ /* required to defer actual deletion until libuv has processed it */
+ uv_close((uv_handle_t*)&wsi->w_read.uv_watcher, lws_libuv_closewsi_m);
+}
+
+int
+lws_libuv_check_watcher_active(struct lws *wsi)
+{
+ uv_handle_t *h = (void *)&wsi->w_read.uv_watcher;
+
+ return uv_is_active(h);
+}
+
+
+#if defined(LWS_WITH_PLUGINS) && (UV_VERSION_MAJOR > 0)
+
+LWS_VISIBLE int
+lws_plat_plugins_init(struct lws_context *context, const char * const *d)
+{
+ struct lws_plugin_capability lcaps;
+ struct lws_plugin *plugin;
+ lws_plugin_init_func initfunc;
+ int m, ret = 0;
+ void *v;
+ uv_dirent_t dent;
+ uv_fs_t req;
+ char path[256];
+ uv_lib_t lib;
+ int pofs = 0;
+
+#if defined(__MINGW32__) || !defined(WIN32)
+ pofs = 3;
+#endif
+
+ lib.errmsg = NULL;
+ lib.handle = NULL;
+
+ uv_loop_init(&context->pu_loop);
+
+ lwsl_notice(" Plugins:\n");
+
+ while (d && *d) {
+
+ lwsl_notice(" Scanning %s\n", *d);
+ m =uv_fs_scandir(&context->pu_loop, &req, *d, 0, NULL);
+ if (m < 1) {
+ lwsl_err("Scandir on %s failed\n", *d);
+ return 1;
+ }
+
+ while (uv_fs_scandir_next(&req, &dent) != UV_EOF) {
+ if (strlen(dent.name) < 7)
+ continue;
+
+ lwsl_notice(" %s\n", dent.name);
+
+ lws_snprintf(path, sizeof(path) - 1, "%s/%s", *d, dent.name);
+ if (uv_dlopen(path, &lib)) {
+ uv_dlerror(&lib);
+ lwsl_err("Error loading DSO: %s\n", lib.errmsg);
+ goto bail;
+ }
+
+ /* we could open it, can we get his init function? */
+
+#if !defined(WIN32) && !defined(__MINGW32__)
+ m = lws_snprintf(path, sizeof(path) - 1, "init_%s",
+ dent.name + pofs /* snip lib... */);
+ path[m - 3] = '\0'; /* snip the .so */
+#else
+ m = lws_snprintf(path, sizeof(path) - 1, "init_%s",
+ dent.name + pofs);
+ path[m - 4] = '\0'; /* snip the .dll */
+#endif
+ if (uv_dlsym(&lib, path, &v)) {
+ uv_dlerror(&lib);
+ lwsl_err("Failed to get %s on %s: %s", path,
+ dent.name, lib.errmsg);
+ uv_dlclose(&lib);
+ goto bail;
+ }
+ initfunc = (lws_plugin_init_func)v;
+ lcaps.api_magic = LWS_PLUGIN_API_MAGIC;
+ m = initfunc(context, &lcaps);
+ if (m) {
+ lwsl_err("Initializing %s failed %d\n", dent.name, m);
+ goto skip;
+ }
+
+ plugin = lws_malloc(sizeof(*plugin));
+ if (!plugin) {
+ uv_dlclose(&lib);
+ lwsl_err("OOM\n");
+ goto bail;
+ }
+ plugin->list = context->plugin_list;
+ context->plugin_list = plugin;
+ strncpy(plugin->name, dent.name, sizeof(plugin->name) - 1);
+ plugin->name[sizeof(plugin->name) - 1] = '\0';
+ plugin->lib = lib;
+ plugin->caps = lcaps;
+ context->plugin_protocol_count += lcaps.count_protocols;
+ context->plugin_extension_count += lcaps.count_extensions;
+
+ continue;
+
+skip:
+ uv_dlclose(&lib);
+ }
+bail:
+ uv_fs_req_cleanup(&req);
+ d++;
+ }
+
+ return ret;
+}
+
+LWS_VISIBLE int
+lws_plat_plugins_destroy(struct lws_context *context)
+{
+ struct lws_plugin *plugin = context->plugin_list, *p;
+ lws_plugin_destroy_func func;
+ char path[256];
+ void *v;
+ int m;
+ int pofs = 0;
+
+#if defined(__MINGW32__) || !defined(WIN32)
+ pofs = 3;
+#endif
+
+ if (!plugin)
+ return 0;
+
+ // lwsl_notice("%s\n", __func__);
+
+ while (plugin) {
+ p = plugin;
+
+#if !defined(WIN32) && !defined(__MINGW32__)
+ m = lws_snprintf(path, sizeof(path) - 1, "destroy_%s", plugin->name + pofs);
+ path[m - 3] = '\0';
+#else
+ m = lws_snprintf(path, sizeof(path) - 1, "destroy_%s", plugin->name + pofs);
+ path[m - 4] = '\0';
+#endif
+
+ if (uv_dlsym(&plugin->lib, path, &v)) {
+ uv_dlerror(&plugin->lib);
+ lwsl_err("Failed to get %s on %s: %s", path,
+ plugin->name, plugin->lib.errmsg);
+ } else {
+ func = (lws_plugin_destroy_func)v;
+ m = func(context);
+ if (m)
+ lwsl_err("Destroying %s failed %d\n",
+ plugin->name, m);
+ }
+
+ uv_dlclose(&p->lib);
+ plugin = p->list;
+ p->list = NULL;
+ free(p);
+ }
+
+ context->plugin_list = NULL;
+
+ while (uv_loop_close(&context->pu_loop))
+ ;
+
+ return 0;
+}
+
+#endif
+
projects / platform / upstream / libwebsockets.git / blobdiff