
Adds a new api lws_vhost_destroy(struct lws_vhost *) which allows dynamic removal of vhosts. The external api calls two parts of internal helpers that get reused for context destroy. The second part is called deferred by 5s... this is to ensure that event library objects composed into structs owned by the vhost all have a chance to complete their close asynchronously. That should happen immediately, but it requires us to return to the event loop first. The vhost being removed is deleted from the context vhost list by the first part, and does not block further removals or creation during the delay for the deferred freeing of the vhost memory. Part 1: - if the vhost owned a listen socket needed by other vhosts listening on same iface + port, the listen socket is first handed off to another vhost so it stays alive - all wsi still open on the vhost are forcibly closed (including any listen socket still attached) - inform all active protocols on the vhost they should destroy themselves - remove vhost from context vhost list (can no longer be found by incoming connections) - add to a "being destroyed" context list and schedule the second part to be called in 5s Part 2: - remove us from the being destroyed list - free all allocations owned by the vhost - zero down the vhost and free the vhost itself In libwebsockets-test-server, you can send it a SIGUSR1 to have it toggle the creation and destruction of a second vhost on port + 1.
323 lines
6.9 KiB
C
323 lines
6.9 KiB
C
/*
|
|
* libwebsockets web server application
|
|
*
|
|
* Copyright (C) 2010-2016 Andy Green <andy@warmcat.com>
|
|
*
|
|
* This file is made available under the Creative Commons CC0 1.0
|
|
* Universal Public Domain Dedication.
|
|
*
|
|
* The person who associated a work with this deed has dedicated
|
|
* the work to the public domain by waiving all of his or her rights
|
|
* to the work worldwide under copyright law, including all related
|
|
* and neighboring rights, to the extent allowed by law. You can copy,
|
|
* modify, distribute and perform the work, even for commercial purposes,
|
|
* all without asking permission.
|
|
*
|
|
* The test apps are intended to be adapted for use in your code, which
|
|
* may be proprietary. So unlike the library itself, they are licensed
|
|
* Public Domain.
|
|
*/
|
|
#include "lws_config.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <getopt.h>
|
|
#include <signal.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <assert.h>
|
|
#ifndef _WIN32
|
|
#include <dirent.h>
|
|
#include <syslog.h>
|
|
#include <sys/time.h>
|
|
#include <unistd.h>
|
|
#include <sys/wait.h>
|
|
#else
|
|
#include <io.h>
|
|
#include "gettimeofday.h"
|
|
|
|
int fork(void)
|
|
{
|
|
fprintf(stderr, "Sorry Windows doesn't support fork().\n");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#include "../lib/libwebsockets.h"
|
|
|
|
#include <uv.h>
|
|
|
|
static struct lws_context *context;
|
|
static char config_dir[128];
|
|
static int opts = 0, do_reload = 1;
|
|
static uv_loop_t loop;
|
|
static uv_signal_t signal_outer;
|
|
static int pids[32];
|
|
|
|
#define LWSWS_CONFIG_STRING_SIZE (32 * 1024)
|
|
|
|
static const struct lws_extension exts[] = {
|
|
{
|
|
"permessage-deflate",
|
|
lws_extension_callback_pm_deflate,
|
|
"permessage-deflate"
|
|
},
|
|
{ NULL, NULL, NULL /* terminator */ }
|
|
};
|
|
|
|
static const char * const plugin_dirs[] = {
|
|
INSTALL_DATADIR"/libwebsockets-test-server/plugins/",
|
|
NULL
|
|
};
|
|
|
|
static struct option options[] = {
|
|
{ "help", no_argument, NULL, 'h' },
|
|
{ "debug", required_argument, NULL, 'd' },
|
|
{ "configdir", required_argument, NULL, 'c' },
|
|
{ NULL, 0, 0, 0 }
|
|
};
|
|
|
|
void signal_cb(uv_signal_t *watcher, int signum)
|
|
{
|
|
switch (watcher->signum) {
|
|
case SIGTERM:
|
|
case SIGINT:
|
|
break;
|
|
|
|
case SIGHUP:
|
|
if (lws_context_is_deprecated(context))
|
|
return;
|
|
lwsl_notice("Dropping listen sockets\n");
|
|
lws_context_deprecate(context, NULL);
|
|
return;
|
|
|
|
default:
|
|
signal(SIGABRT, SIG_DFL);
|
|
abort();
|
|
break;
|
|
}
|
|
lwsl_err("Signal %d caught\n", watcher->signum);
|
|
lws_libuv_stop(context);
|
|
}
|
|
|
|
static int
|
|
context_creation(void)
|
|
{
|
|
int cs_len = LWSWS_CONFIG_STRING_SIZE - 1;
|
|
struct lws_context_creation_info info;
|
|
char *cs, *config_strings;
|
|
|
|
cs = config_strings = malloc(LWSWS_CONFIG_STRING_SIZE);
|
|
if (!config_strings) {
|
|
lwsl_err("Unable to allocate config strings heap\n");
|
|
return -1;
|
|
}
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
info.external_baggage_free_on_destroy = config_strings;
|
|
info.max_http_header_pool = 16;
|
|
info.options = opts | LWS_SERVER_OPTION_VALIDATE_UTF8 |
|
|
LWS_SERVER_OPTION_EXPLICIT_VHOSTS |
|
|
LWS_SERVER_OPTION_LIBUV;
|
|
|
|
info.plugin_dirs = plugin_dirs;
|
|
lwsl_notice("Using config dir: \"%s\"\n", config_dir);
|
|
|
|
/*
|
|
* first go through the config for creating the outer context
|
|
*/
|
|
if (lwsws_get_config_globals(&info, config_dir, &cs, &cs_len))
|
|
goto init_failed;
|
|
|
|
context = lws_create_context(&info);
|
|
if (context == NULL) {
|
|
lwsl_err("libwebsocket init failed\n");
|
|
goto init_failed;
|
|
}
|
|
|
|
lws_uv_sigint_cfg(context, 1, signal_cb);
|
|
lws_uv_initloop(context, &loop, 0);
|
|
|
|
/*
|
|
* then create the vhosts... protocols are entirely coming from
|
|
* plugins, so we leave it NULL
|
|
*/
|
|
|
|
info.extensions = exts;
|
|
|
|
if (lwsws_get_config_vhosts(context, &info, config_dir,
|
|
&cs, &cs_len))
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
init_failed:
|
|
free(config_strings);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
* root-level sighup handler
|
|
*/
|
|
|
|
static void
|
|
reload_handler(int signum)
|
|
{
|
|
#ifndef _WIN32
|
|
int m;
|
|
|
|
switch (signum) {
|
|
|
|
case SIGHUP: /* reload */
|
|
fprintf(stderr, "root process receives reload\n");
|
|
if (!do_reload) {
|
|
fprintf(stderr, "passing HUP to child processes\n");
|
|
for (m = 0; m < ARRAY_SIZE(pids); m++)
|
|
if (pids[m])
|
|
kill(pids[m], SIGHUP);
|
|
sleep(1);
|
|
}
|
|
do_reload = 1;
|
|
break;
|
|
case SIGINT:
|
|
case SIGTERM:
|
|
case SIGKILL:
|
|
fprintf(stderr, "killing service processes\n");
|
|
for (m = 0; m < ARRAY_SIZE(pids); m++)
|
|
if (pids[m])
|
|
kill(pids[m], SIGTERM);
|
|
exit(0);
|
|
}
|
|
#else
|
|
// kill() implementation needed for WIN32
|
|
#endif
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int n = 0, debug_level = 7;
|
|
#ifndef _WIN32
|
|
int m;
|
|
int status, syslog_options = LOG_PID | LOG_PERROR;
|
|
#endif
|
|
|
|
strcpy(config_dir, "/etc/lwsws");
|
|
while (n >= 0) {
|
|
n = getopt_long(argc, argv, "hd:c:", options, NULL);
|
|
if (n < 0)
|
|
continue;
|
|
switch (n) {
|
|
case 'd':
|
|
debug_level = atoi(optarg);
|
|
break;
|
|
case 'c':
|
|
strncpy(config_dir, optarg, sizeof(config_dir) - 1);
|
|
config_dir[sizeof(config_dir) - 1] = '\0';
|
|
break;
|
|
case 'h':
|
|
fprintf(stderr, "Usage: lwsws [-c <config dir>] "
|
|
"[-d <log bitfield>] [-D] [--help]\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
#ifndef _WIN32
|
|
/*
|
|
* We leave our original process up permanently, because that
|
|
* suits systemd.
|
|
*
|
|
* Otherwise we get into problems when reload spawns new processes and
|
|
* the original one dies randomly.
|
|
*/
|
|
|
|
signal(SIGHUP, reload_handler);
|
|
signal(SIGINT, reload_handler);
|
|
|
|
fprintf(stderr, "Root process is %u\n", getpid());
|
|
|
|
while (1) {
|
|
if (do_reload) {
|
|
do_reload = 0;
|
|
n = fork();
|
|
if (n == 0) /* new */
|
|
break;
|
|
/* old */
|
|
if (n > 0)
|
|
for (m = 0; m < ARRAY_SIZE(pids); m++)
|
|
if (!pids[m]) {
|
|
// fprintf(stderr, "added child pid %d\n", n);
|
|
pids[m] = n;
|
|
break;
|
|
}
|
|
}
|
|
#ifndef _WIN32
|
|
sleep(2);
|
|
|
|
n = waitpid(-1, &status, WNOHANG);
|
|
if (n > 0)
|
|
for (m = 0; m < ARRAY_SIZE(pids); m++)
|
|
if (pids[m] == n) {
|
|
// fprintf(stderr, "reaped child pid %d\n", pids[m]);
|
|
pids[m] = 0;
|
|
break;
|
|
}
|
|
#else
|
|
// !!! implemenation needed
|
|
#endif
|
|
}
|
|
#endif
|
|
/* child process */
|
|
|
|
#ifndef _WIN32
|
|
/* we will only try to log things according to our debug_level */
|
|
setlogmask(LOG_UPTO (LOG_DEBUG));
|
|
openlog("lwsws", syslog_options, LOG_DAEMON);
|
|
#endif
|
|
|
|
lws_set_log_level(debug_level, lwsl_emit_syslog);
|
|
|
|
lwsl_notice("lwsws libwebsockets web server - license CC0 + LGPL2.1\n");
|
|
lwsl_notice("(C) Copyright 2010-2016 Andy Green <andy@warmcat.com>\n");
|
|
|
|
#if (UV_VERSION_MAJOR > 0) // Travis...
|
|
uv_loop_init(&loop);
|
|
#else
|
|
fprintf(stderr, "Your libuv is too old!\n");
|
|
return 0;
|
|
#endif
|
|
uv_signal_init(&loop, &signal_outer);
|
|
uv_signal_start(&signal_outer, signal_cb, SIGINT);
|
|
uv_signal_start(&signal_outer, signal_cb, SIGHUP);
|
|
|
|
if (context_creation()) {
|
|
lwsl_err("Context creation failed\n");
|
|
return 1;
|
|
}
|
|
|
|
lws_libuv_run(context, 0);
|
|
|
|
uv_signal_stop(&signal_outer);
|
|
lws_context_destroy(context);
|
|
|
|
#if (UV_VERSION_MAJOR > 0) // Travis...
|
|
lws_close_all_handles_in_loop(&loop);
|
|
n = 0;
|
|
while (n++ < 4096 && uv_loop_close(&loop))
|
|
uv_run(&loop, UV_RUN_NOWAIT);
|
|
#endif
|
|
|
|
lws_context_destroy2(context);
|
|
|
|
fprintf(stderr, "lwsws exited cleanly\n");
|
|
|
|
#ifndef _WIN32
|
|
closelog();
|
|
#endif
|
|
|
|
context = NULL;
|
|
|
|
return 0;
|
|
}
|