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_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));
+ if (!pt->io_loop_uv) {
if (!loop) {
- lwsl_err("OOM\n");
- return -1;
+ 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 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);
- 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;
- 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;
- }
- lws_libuv_io(vh->lserv_wsi, LWS_EV_START | LWS_EV_READ);
- }
+ 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, 10, 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;
}
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, budget = 100;
+// 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;
+ 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++) {
+ 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_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))
;
- if (pt->ev_loop_foreign)
- return;
+ lwsl_notice("%s: closing all loop handles context %p\n", __func__, context);
uv_stop(pt->io_loop_uv);
}
void
-lws_libuv_accept(struct lws *wsi, lws_sockfd_type 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_socket(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
// 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;
}
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) &&
- !context->pt[n].ev_loop_foreign)
+ LWS_LIBUV_ENABLED(context) )//&&
+ //!context->pt[n].ev_loop_foreign)
uv_stop(context->pt[n].io_loop_uv);
}
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)
+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;
lwsl_notice(" %s\n", dent.name);
- snprintf(path, sizeof(path) - 1, "%s/%s", *d, 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)
- m = snprintf(path, sizeof(path) - 1, "init_%s",
- dent.name + 3 /* snip lib... */);
+
+#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 = snprintf(path, sizeof(path) - 1, "init_%s",
- dent.name);
+ 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 init on %s: %s",
+ lwsl_err("Failed to get %s on %s: %s", path,
dent.name, lib.errmsg);
goto bail;
}
d++;
}
+ 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;
while (plugin) {
p = plugin;
-#if !defined(WIN32)
- 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 = snprintf(path, sizeof(path) - 1, "destroy_%s", plugin->name);
+ 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