You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
655 lines
17 KiB
655 lines
17 KiB
/*
|
|
* libwebsockets-test-server - libwebsockets test implementation
|
|
*
|
|
* Written in 2010-2019 by 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 <libwebsockets.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#if defined(LWS_HAS_GETOPT_LONG) || defined(WIN32)
|
|
#include <getopt.h>
|
|
#endif
|
|
#include <signal.h>
|
|
|
|
#if defined(WIN32) || defined(_WIN32)
|
|
#else
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
int close_testing;
|
|
int max_poll_elements;
|
|
int debug_level = LLL_USER | 7;
|
|
|
|
#if defined(LWS_WITH_EXTERNAL_POLL)
|
|
struct lws_pollfd *pollfds;
|
|
int *fd_lookup;
|
|
int count_pollfds;
|
|
#endif
|
|
volatile int force_exit = 0, dynamic_vhost_enable = 0;
|
|
struct lws_vhost *dynamic_vhost;
|
|
struct lws_context *context;
|
|
struct lws_plat_file_ops fops_plat;
|
|
static int test_options;
|
|
|
|
/* http server gets files from this path */
|
|
#define LOCAL_RESOURCE_PATH INSTALL_DATADIR"/libwebsockets-test-server"
|
|
char *resource_path = LOCAL_RESOURCE_PATH;
|
|
#if defined(LWS_WITH_TLS) && defined(LWS_HAVE_SSL_CTX_set1_param)
|
|
char crl_path[1024] = "";
|
|
#endif
|
|
|
|
/*
|
|
* This demonstrates how to use the clean protocol service separation of
|
|
* plugins, but with static inclusion instead of runtime dynamic loading
|
|
* (which requires libuv).
|
|
*
|
|
* dumb-increment doesn't use the plugin, both to demonstrate how to
|
|
* do the protocols directly, and because it wants libuv for a timer.
|
|
*
|
|
* Please consider using test-server-v2.0.c instead of this: it has the
|
|
* same functionality but
|
|
*
|
|
* 1) uses lws built-in http handling so you don't need to deal with it in
|
|
* your callback
|
|
*
|
|
* 2) Links with libuv and uses the plugins at runtime
|
|
*
|
|
* 3) Uses advanced lws features like mounts to bind parts of the filesystem
|
|
* to the served URL space
|
|
*
|
|
* Another option is lwsws, this operates like test-server-v2,0.c but is
|
|
* configured using JSON, do you do not need to provide any code for the
|
|
* serving action at all, just implement your protocols in plugins.
|
|
*/
|
|
|
|
#define LWS_PLUGIN_STATIC
|
|
#if defined(LWS_ROLE_WS)
|
|
#include "../plugins/protocol_lws_mirror.c"
|
|
#include "../plugins/protocol_lws_status.c"
|
|
#include "../plugins/protocol_dumb_increment.c"
|
|
#endif
|
|
#include "../plugins/protocol_post_demo.c"
|
|
|
|
static int
|
|
lws_callback_http(struct lws *wsi, enum lws_callback_reasons reason, void *user,
|
|
void *in, size_t len)
|
|
{
|
|
const unsigned char *c;
|
|
char buf[1024];
|
|
int n = 0, hlen;
|
|
|
|
switch (reason) {
|
|
case LWS_CALLBACK_HTTP:
|
|
|
|
/* non-mount-handled accesses will turn up here */
|
|
|
|
/* dump the headers */
|
|
|
|
do {
|
|
c = lws_token_to_string(n);
|
|
if (!c) {
|
|
n++;
|
|
continue;
|
|
}
|
|
|
|
hlen = lws_hdr_total_length(wsi, n);
|
|
if (!hlen || hlen > (int)sizeof(buf) - 1) {
|
|
n++;
|
|
continue;
|
|
}
|
|
|
|
if (lws_hdr_copy(wsi, buf, sizeof buf, n) < 0)
|
|
fprintf(stderr, " %s (too big)\n", (char *)c);
|
|
else {
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
|
|
fprintf(stderr, " %s = %s\n", (char *)c, buf);
|
|
}
|
|
n++;
|
|
} while (c);
|
|
|
|
/* dump the individual URI Arg parameters */
|
|
|
|
n = 0;
|
|
while (lws_hdr_copy_fragment(wsi, buf, sizeof(buf),
|
|
WSI_TOKEN_HTTP_URI_ARGS, n) > 0) {
|
|
lwsl_notice("URI Arg %d: %s\n", ++n, buf);
|
|
}
|
|
|
|
if (lws_return_http_status(wsi, HTTP_STATUS_NOT_FOUND, NULL))
|
|
return -1;
|
|
|
|
if (lws_http_transaction_completed(wsi))
|
|
return -1;
|
|
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return lws_callback_http_dummy(wsi, reason, user, in, len);
|
|
}
|
|
|
|
/* list of supported protocols and callbacks */
|
|
|
|
static struct lws_protocols protocols[] = {
|
|
/* first protocol must always be HTTP handler */
|
|
|
|
{ "http-only", lws_callback_http, 0, 0, },
|
|
#if defined(LWS_ROLE_WS)
|
|
LWS_PLUGIN_PROTOCOL_DUMB_INCREMENT,
|
|
LWS_PLUGIN_PROTOCOL_MIRROR,
|
|
LWS_PLUGIN_PROTOCOL_LWS_STATUS,
|
|
#endif
|
|
LWS_PLUGIN_PROTOCOL_POST_DEMO,
|
|
{ NULL, NULL, 0, 0 } /* terminator */
|
|
};
|
|
|
|
|
|
/* this shows how to override the lws file operations. You don't need
|
|
* to do any of this unless you have a reason (eg, want to serve
|
|
* compressed files without decompressing the whole archive)
|
|
*/
|
|
static lws_fop_fd_t
|
|
test_server_fops_open(const struct lws_plat_file_ops *fops,
|
|
const char *vfs_path, const char *vpath,
|
|
lws_fop_flags_t *flags)
|
|
{
|
|
lws_fop_fd_t fop_fd;
|
|
|
|
/* call through to original platform implementation */
|
|
fop_fd = fops_plat.open(fops, vfs_path, vpath, flags);
|
|
|
|
if (fop_fd)
|
|
lwsl_info("%s: opening %s, ret %p, len %lu\n", __func__,
|
|
vfs_path, fop_fd,
|
|
(long)lws_vfs_get_length(fop_fd));
|
|
else
|
|
lwsl_info("%s: open %s failed\n", __func__, vfs_path);
|
|
|
|
return fop_fd;
|
|
}
|
|
|
|
void sighandler(int sig)
|
|
{
|
|
#if !defined(WIN32) && !defined(_WIN32)
|
|
/* because windows is too dumb to have SIGUSR1... */
|
|
if (sig == SIGUSR1) {
|
|
/*
|
|
* For testing, you can fire a SIGUSR1 at the test server
|
|
* to toggle the existence of an identical server on
|
|
* port + 1
|
|
*/
|
|
dynamic_vhost_enable ^= 1;
|
|
lws_cancel_service(context);
|
|
lwsl_notice("SIGUSR1: dynamic_vhost_enable: %d\n",
|
|
dynamic_vhost_enable);
|
|
return;
|
|
}
|
|
#endif
|
|
force_exit = 1;
|
|
lws_cancel_service(context);
|
|
}
|
|
|
|
static const struct lws_extension exts[] = {
|
|
{
|
|
"permessage-deflate",
|
|
lws_extension_callback_pm_deflate,
|
|
"permessage-deflate"
|
|
},
|
|
{ NULL, NULL, NULL /* terminator */ }
|
|
};
|
|
|
|
/*
|
|
* mount handlers for sections of the URL space
|
|
*/
|
|
|
|
static const struct lws_http_mount mount_ziptest = {
|
|
NULL, /* linked-list pointer to next*/
|
|
"/ziptest", /* mountpoint in URL namespace on this vhost */
|
|
LOCAL_RESOURCE_PATH"/candide.zip", /* handler */
|
|
NULL, /* default filename if none given */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
LWSMPRO_FILE, /* origin points to a callback */
|
|
8, /* strlen("/ziptest"), ie length of the mountpoint */
|
|
NULL,
|
|
|
|
{ NULL, NULL } // sentinel
|
|
};
|
|
|
|
static const struct lws_http_mount mount_post = {
|
|
(struct lws_http_mount *)&mount_ziptest, /* linked-list pointer to next*/
|
|
"/formtest", /* mountpoint in URL namespace on this vhost */
|
|
"protocol-post-demo", /* handler */
|
|
NULL, /* default filename if none given */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
LWSMPRO_CALLBACK, /* origin points to a callback */
|
|
9, /* strlen("/formtest"), ie length of the mountpoint */
|
|
NULL,
|
|
|
|
{ NULL, NULL } // sentinel
|
|
};
|
|
|
|
/*
|
|
* mount a filesystem directory into the URL space at /
|
|
* point it to our /usr/share directory with our assets in
|
|
* stuff from here is autoserved by the library
|
|
*/
|
|
|
|
static const struct lws_http_mount mount = {
|
|
(struct lws_http_mount *)&mount_post, /* linked-list pointer to next*/
|
|
"/", /* mountpoint in URL namespace on this vhost */
|
|
LOCAL_RESOURCE_PATH, /* where to go on the filesystem for that */
|
|
"test.html", /* default filename if none given */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
LWSMPRO_FILE, /* mount type is a directory in a filesystem */
|
|
1, /* strlen("/"), ie length of the mountpoint */
|
|
NULL,
|
|
|
|
{ NULL, NULL } // sentinel
|
|
};
|
|
|
|
static const struct lws_protocol_vhost_options pvo_options = {
|
|
NULL,
|
|
NULL,
|
|
"options", /* pvo name */
|
|
(void *)&test_options /* pvo value */
|
|
};
|
|
|
|
static const struct lws_protocol_vhost_options pvo = {
|
|
NULL, /* "next" pvo linked-list */
|
|
&pvo_options, /* "child" pvo linked-list */
|
|
"dumb-increment-protocol", /* protocol name we belong to on this vhost */
|
|
"" /* ignored */
|
|
};
|
|
|
|
#if defined(LWS_HAS_GETOPT_LONG) || defined(WIN32)
|
|
static struct option options[] = {
|
|
{ "help", no_argument, NULL, 'h' },
|
|
{ "debug", required_argument, NULL, 'd' },
|
|
{ "port", required_argument, NULL, 'p' },
|
|
{ "ssl", no_argument, NULL, 's' },
|
|
{ "allow-non-ssl", no_argument, NULL, 'a' },
|
|
{ "interface", required_argument, NULL, 'i' },
|
|
{ "closetest", no_argument, NULL, 'c' },
|
|
{ "ssl-cert", required_argument, NULL, 'C' },
|
|
{ "ssl-key", required_argument, NULL, 'K' },
|
|
{ "ssl-ca", required_argument, NULL, 'A' },
|
|
#if defined(LWS_WITH_TLS)
|
|
{ "ssl-verify-client", no_argument, NULL, 'v' },
|
|
#if defined(LWS_HAVE_SSL_CTX_set1_param)
|
|
{ "ssl-crl", required_argument, NULL, 'R' },
|
|
#endif
|
|
#endif
|
|
{ "libev", no_argument, NULL, 'e' },
|
|
{ "unix-socket", required_argument, NULL, 'U' },
|
|
#ifndef LWS_NO_DAEMONIZE
|
|
{ "daemonize", no_argument, NULL, 'D' },
|
|
#endif
|
|
{ "pingpong-secs", required_argument, NULL, 'P' },
|
|
{ NULL, 0, 0, 0 }
|
|
};
|
|
#endif
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
struct lws_context_creation_info info;
|
|
struct lws_vhost *vhost;
|
|
char interface_name[128] = "";
|
|
const char *iface = NULL;
|
|
char cert_path[1024] = "";
|
|
char key_path[1024] = "";
|
|
char ca_path[1024] = "";
|
|
int uid = -1, gid = -1;
|
|
int use_ssl = 0;
|
|
int pp_secs = 0;
|
|
int opts = 0;
|
|
int n = 0;
|
|
#ifndef LWS_NO_DAEMONIZE
|
|
int daemonize = 0;
|
|
#endif
|
|
|
|
/*
|
|
* take care to zero down the info struct, he contains random garbaage
|
|
* from the stack otherwise
|
|
*/
|
|
memset(&info, 0, sizeof info);
|
|
info.port = 7681;
|
|
|
|
while (n >= 0) {
|
|
#if defined(LWS_HAS_GETOPT_LONG) || defined(WIN32)
|
|
n = getopt_long(argc, argv, "eci:hsap:d:DC:K:A:R:vu:g:P:kU:n", options, NULL);
|
|
#else
|
|
n = getopt(argc, argv, "eci:hsap:d:DC:K:A:R:vu:g:P:kU:n");
|
|
#endif
|
|
if (n < 0)
|
|
continue;
|
|
switch (n) {
|
|
case 'e':
|
|
opts |= LWS_SERVER_OPTION_LIBEV;
|
|
break;
|
|
#ifndef LWS_NO_DAEMONIZE
|
|
case 'D':
|
|
daemonize = 1;
|
|
break;
|
|
#endif
|
|
case 'u':
|
|
uid = atoi(optarg);
|
|
break;
|
|
case 'g':
|
|
gid = atoi(optarg);
|
|
break;
|
|
case 'd':
|
|
debug_level = atoi(optarg);
|
|
break;
|
|
case 'n':
|
|
/* no dumb increment send */
|
|
test_options |= 1;
|
|
break;
|
|
case 's':
|
|
use_ssl = 1;
|
|
opts |= LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
|
|
break;
|
|
case 'a':
|
|
opts |= LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT;
|
|
break;
|
|
case 'p':
|
|
info.port = atoi(optarg);
|
|
break;
|
|
case 'i':
|
|
lws_strncpy(interface_name, optarg, sizeof interface_name);
|
|
iface = interface_name;
|
|
break;
|
|
case 'U':
|
|
lws_strncpy(interface_name, optarg, sizeof interface_name);
|
|
iface = interface_name;
|
|
opts |= LWS_SERVER_OPTION_UNIX_SOCK;
|
|
break;
|
|
case 'k':
|
|
info.bind_iface = 1;
|
|
#if defined(LWS_HAVE_SYS_CAPABILITY_H) && defined(LWS_HAVE_LIBCAP)
|
|
info.caps[0] = CAP_NET_RAW;
|
|
info.count_caps = 1;
|
|
#endif
|
|
break;
|
|
case 'c':
|
|
close_testing = 1;
|
|
fprintf(stderr, " Close testing mode -- closes on "
|
|
"client after 50 dumb increments"
|
|
"and suppresses lws_mirror spam\n");
|
|
break;
|
|
case 'C':
|
|
lws_strncpy(cert_path, optarg, sizeof(cert_path));
|
|
break;
|
|
case 'K':
|
|
lws_strncpy(key_path, optarg, sizeof(key_path));
|
|
break;
|
|
case 'A':
|
|
lws_strncpy(ca_path, optarg, sizeof(ca_path));
|
|
break;
|
|
case 'P':
|
|
pp_secs = atoi(optarg);
|
|
lwsl_notice("Setting pingpong interval to %d\n", pp_secs);
|
|
break;
|
|
#if defined(LWS_WITH_TLS)
|
|
case 'v':
|
|
use_ssl = 1;
|
|
opts |= LWS_SERVER_OPTION_REQUIRE_VALID_OPENSSL_CLIENT_CERT;
|
|
break;
|
|
|
|
#if defined(LWS_HAVE_SSL_CTX_set1_param)
|
|
case 'R':
|
|
lws_strncpy(crl_path, optarg, sizeof(crl_path));
|
|
break;
|
|
#endif
|
|
#endif
|
|
case 'h':
|
|
fprintf(stderr, "Usage: test-server "
|
|
"[--port=<p>] [--ssl] "
|
|
"[-d <log bitfield>]\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
#if !defined(LWS_NO_DAEMONIZE) && !defined(WIN32)
|
|
/*
|
|
* normally lock path would be /var/lock/lwsts or similar, to
|
|
* simplify getting started without having to take care about
|
|
* permissions or running as root, set to /tmp/.lwsts-lock
|
|
*/
|
|
if (daemonize && lws_daemonize("/tmp/.lwsts-lock")) {
|
|
fprintf(stderr, "Failed to daemonize\n");
|
|
return 10;
|
|
}
|
|
#endif
|
|
|
|
signal(SIGINT, sighandler);
|
|
#if !defined(WIN32) && !defined(_WIN32)
|
|
/* because windows is too dumb to have SIGUSR1... */
|
|
/* dynamic vhost create / destroy toggle (on port + 1) */
|
|
signal(SIGUSR1, sighandler);
|
|
#endif
|
|
|
|
/* tell the library what debug level to emit and to send it to stderr */
|
|
lws_set_log_level(debug_level, NULL);
|
|
|
|
lwsl_notice("libwebsockets test server - license MIT\n");
|
|
lwsl_notice("(C) Copyright 2010-2018 Andy Green <andy@warmcat.com>\n");
|
|
|
|
printf("Using resource path \"%s\"\n", resource_path);
|
|
#if defined(LWS_WITH_EXTERNAL_POLL)
|
|
#if !defined(WIN32) && !defined(_WIN32) && !defined(__ANDROID__)
|
|
max_poll_elements = getdtablesize();
|
|
#else
|
|
max_poll_elements = sysconf(_SC_OPEN_MAX);
|
|
#endif
|
|
pollfds = malloc(max_poll_elements * sizeof (struct lws_pollfd));
|
|
fd_lookup = malloc(max_poll_elements * sizeof (int));
|
|
if (pollfds == NULL || fd_lookup == NULL) {
|
|
lwsl_err("Out of memory pollfds=%d\n", max_poll_elements);
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
info.iface = iface;
|
|
info.protocols = protocols;
|
|
info.ssl_cert_filepath = NULL;
|
|
info.ssl_private_key_filepath = NULL;
|
|
info.ws_ping_pong_interval = pp_secs;
|
|
|
|
if (use_ssl) {
|
|
if (strlen(resource_path) > sizeof(cert_path) - 32) {
|
|
lwsl_err("resource path too long\n");
|
|
return -1;
|
|
}
|
|
if (!cert_path[0])
|
|
sprintf(cert_path, "%s/libwebsockets-test-server.pem",
|
|
resource_path);
|
|
if (strlen(resource_path) > sizeof(key_path) - 32) {
|
|
lwsl_err("resource path too long\n");
|
|
return -1;
|
|
}
|
|
if (!key_path[0])
|
|
sprintf(key_path, "%s/libwebsockets-test-server.key.pem",
|
|
resource_path);
|
|
|
|
info.ssl_cert_filepath = cert_path;
|
|
info.ssl_private_key_filepath = key_path;
|
|
if (ca_path[0])
|
|
info.ssl_ca_filepath = ca_path;
|
|
}
|
|
info.gid = gid;
|
|
info.uid = uid;
|
|
info.options = opts | LWS_SERVER_OPTION_VALIDATE_UTF8 | LWS_SERVER_OPTION_EXPLICIT_VHOSTS;
|
|
info.extensions = exts;
|
|
info.timeout_secs = 5;
|
|
info.ssl_cipher_list = "ECDHE-ECDSA-AES256-GCM-SHA384:"
|
|
"ECDHE-RSA-AES256-GCM-SHA384:"
|
|
"DHE-RSA-AES256-GCM-SHA384:"
|
|
"ECDHE-RSA-AES256-SHA384:"
|
|
"HIGH:!aNULL:!eNULL:!EXPORT:"
|
|
"!DES:!MD5:!PSK:!RC4:!HMAC_SHA1:"
|
|
"!SHA1:!DHE-RSA-AES128-GCM-SHA256:"
|
|
"!DHE-RSA-AES128-SHA256:"
|
|
"!AES128-GCM-SHA256:"
|
|
"!AES128-SHA256:"
|
|
"!DHE-RSA-AES256-SHA256:"
|
|
"!AES256-GCM-SHA384:"
|
|
"!AES256-SHA256";
|
|
info.mounts = &mount;
|
|
info.ip_limit_ah = 24; /* for testing */
|
|
info.ip_limit_wsi = 400; /* for testing */
|
|
|
|
if (use_ssl)
|
|
/* redirect guys coming on http */
|
|
info.options |= LWS_SERVER_OPTION_REDIRECT_HTTP_TO_HTTPS;
|
|
|
|
context = lws_create_context(&info);
|
|
if (context == NULL) {
|
|
lwsl_err("libwebsocket init failed\n");
|
|
return -1;
|
|
}
|
|
|
|
info.pvo = &pvo;
|
|
|
|
vhost = lws_create_vhost(context, &info);
|
|
if (!vhost) {
|
|
lwsl_err("vhost creation failed\n");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* For testing dynamic vhost create / destroy later, we use port + 1
|
|
* Normally if you were creating more vhosts, you would set info.name
|
|
* for each to be the hostname external clients use to reach it
|
|
*/
|
|
|
|
info.port++;
|
|
|
|
#if defined(LWS_WITH_CLIENT) && defined(LWS_WITH_TLS)
|
|
lws_init_vhost_client_ssl(&info, vhost);
|
|
#endif
|
|
|
|
/* this shows how to override the lws file operations. You don't need
|
|
* to do any of this unless you have a reason (eg, want to serve
|
|
* compressed files without decompressing the whole archive)
|
|
*/
|
|
/* stash original platform fops */
|
|
fops_plat = *(lws_get_fops(context));
|
|
/* override the active fops */
|
|
lws_get_fops(context)->open = test_server_fops_open;
|
|
|
|
n = 0;
|
|
while (n >= 0 && !force_exit) {
|
|
struct timeval tv;
|
|
|
|
gettimeofday(&tv, NULL);
|
|
|
|
/*
|
|
* This provokes the LWS_CALLBACK_SERVER_WRITEABLE for every
|
|
* live websocket connection using the DUMB_INCREMENT protocol,
|
|
* as soon as it can take more packets (usually immediately)
|
|
*/
|
|
|
|
#if defined(LWS_WITH_EXTERNAL_POLL)
|
|
/*
|
|
* this represents an existing server's single poll action
|
|
* which also includes libwebsocket sockets
|
|
*/
|
|
n = poll(pollfds, count_pollfds, 50);
|
|
if (n < 0)
|
|
continue;
|
|
|
|
if (n) {
|
|
for (n = 0; n < count_pollfds; n++)
|
|
if (pollfds[n].revents)
|
|
/*
|
|
* returns immediately if the fd does not
|
|
* match anything under libwebsockets
|
|
* control
|
|
*/
|
|
if (lws_service_fd(context,
|
|
&pollfds[n]) < 0)
|
|
goto done;
|
|
|
|
/* if needed, force-service wsis that may not have read all input */
|
|
while (!lws_service_adjust_timeout(context, 1, 0)) {
|
|
lwsl_notice("extpoll doing forced service!\n");
|
|
lws_service_tsi(context, -1, 0);
|
|
}
|
|
}
|
|
#else
|
|
/*
|
|
* If libwebsockets sockets are all we care about,
|
|
* you can use this api which takes care of the poll()
|
|
* and looping through finding who needed service.
|
|
*/
|
|
|
|
n = lws_service(context, 0);
|
|
#endif
|
|
|
|
if (dynamic_vhost_enable && !dynamic_vhost) {
|
|
lwsl_notice("creating dynamic vhost...\n");
|
|
dynamic_vhost = lws_create_vhost(context, &info);
|
|
} else
|
|
if (!dynamic_vhost_enable && dynamic_vhost) {
|
|
lwsl_notice("destroying dynamic vhost...\n");
|
|
lws_vhost_destroy(dynamic_vhost);
|
|
dynamic_vhost = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
#if defined(LWS_WITH_EXTERNAL_POLL)
|
|
done:
|
|
#endif
|
|
|
|
lws_context_destroy(context);
|
|
|
|
lwsl_notice("libwebsockets-test-server exited cleanly\n");
|
|
|
|
return 0;
|
|
}
|