struct lws_context_per_thread *pt = lws_container_of(handle,
struct lws_context_per_thread, uv_idle);
- lwsl_debug("%s\n", __func__);
+// 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);
+ _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;
+// 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__);
+ //lwsl_debug("%s: done stop\n", __func__);
}
static void
struct lws_io_watcher *lws_io = lws_container_of(watcher,
struct lws_io_watcher, uv_watcher);
struct lws *wsi = lws_container_of(lws_io, struct lws, w_read);
- struct lws_context *context = lws_io->context;
+ struct lws_context *context = wsi->context;
struct lws_pollfd eventfd;
#if defined(WIN32) || defined(_WIN32)
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);
}
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__);
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 *)(long)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));
-#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
- pt->ev_loop_foreign = 1;
-
- pt->io_loop_uv = loop;
- uv_idle_init(loop, &pt->uv_idle);
-
- 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]);
+ 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;
}
- }
+
+ 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;
- n = uv_poll_init_socket(pt->io_loop_uv,
- &vh->lserv_wsi->w_read.uv_watcher,
- vh->lserv_wsi->sock);
- if (n) {
- lwsl_err("uv_poll_init failed %d, sockfd=%p\n",
- n, (void *)(long)vh->lserv_wsi->sock);
-
- return -1;
- }
- 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);
}
-void lws_uv_walk_cb(uv_handle_t *handle, void *arg)
+static void lws_uv_walk_cb(uv_handle_t *handle, void *arg)
{
- uv_close(handle, lws_uv_close_cb);
+ if (!uv_is_closing(handle))
+ uv_close(handle, lws_uv_close_cb);
}
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));
+
+ 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_debug("%s: uv_loop_close: UV_EBUSY\n", __func__);
+ 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);
- }
+ 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
if (!LWS_LIBUV_ENABLED(context))
return;
- lwsl_debug("%s: wsi: %p, flags:0x%x\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)
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;
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)(long long)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 *)(long long)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 *d)
+lws_plat_plugins_init(struct lws_context *context, const char * const *d)
{
struct lws_plugin_capability lcaps;
struct lws_plugin *plugin;
char path[256];
uv_loop_t loop;
uv_lib_t lib;
+ int pofs = 0;
+
+#if defined(__MINGW32__) || !defined(WIN32)
+ pofs = 3;
+#endif
lib.errmsg = NULL;
lib.handle = NULL;
uv_loop_init(&loop);
- if (!uv_fs_scandir(&loop, &req, d, 0, NULL)) {
- lwsl_err("Scandir on %s failed\n", d);
- return 1;
- }
-
lwsl_notice(" Plugins:\n");
- while (uv_fs_scandir_next(&req, &dent) != UV_EOF) {
- if (strlen(dent.name) < 7)
- continue;
-
- lwsl_notice(" %s\n", dent.name);
+ while (d && *d) {
- 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? */
- m = snprintf(path, sizeof(path) - 1, "init_%s",
- dent.name + 3 /* snip lib... */);
- path[m - 3] = '\0'; /* snip the .so */
- if (uv_dlsym(&lib, path, &v)) {
- uv_dlerror(&lib);
- lwsl_err("Failed to get init on %s: %s",
- dent.name, lib.errmsg);
- 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;
+ lwsl_notice(" Scanning %s\n", *d);
+ m =uv_fs_scandir(&loop, &req, *d, 0, NULL);
+ if (m < 1) {
+ lwsl_err("Scandir on %s failed\n", *d);
+ return 1;
}
- plugin = lws_malloc(sizeof(*plugin));
- if (!plugin) {
- 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;
+ 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);
+ 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;
+ }
- continue;
+ plugin = lws_malloc(sizeof(*plugin));
+ if (!plugin) {
+ 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);
+ uv_dlclose(&lib);
+ }
+bail:
+ uv_fs_req_cleanup(&req);
+ d++;
}
-bail:
- uv_fs_req_cleanup(&req);
+ uv_run(&loop, UV_RUN_NOWAIT);
uv_loop_close(&loop);
return ret;
}
LWS_VISIBLE int
-lws_plat_plugins_destroy(struct lws_context * context)
+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__);
+ // lwsl_notice("%s\n", __func__);
while (plugin) {
p = plugin;
- m = snprintf(path, sizeof(path) - 1, "destroy_%s", plugin->name + 3);
+
+#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 init on %s: %s",
+ lwsl_err("Failed to get %s on %s: %s", path,
plugin->name, plugin->lib.errmsg);
} else {
func = (lws_plugin_destroy_func)v;
projects / platform / upstream / libwebsockets.git / blobdiff