diff --git a/CMakeLists.txt b/CMakeLists.txt index 721f17ee..1af6085b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -481,7 +481,7 @@ if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) set(VISIBILITY_FLAG -fvisibility=hidden) endif() if (UNIX) - set(CMAKE_C_FLAGS "-Wall -Werror ${VISIBILITY_FLAG} ${CMAKE_C_FLAGS}" ) + set(CMAKE_C_FLAGS "-Wall -Werror ${VISIBILITY_FLAG} ${CMAKE_C_FLAGS} -pthread" ) else(UNIX) set(CMAKE_C_FLAGS "-Wall ${VISIBILITY_FLAG} ${CMAKE_C_FLAGS}" ) endif(UNIX) @@ -755,6 +755,9 @@ if (NOT LWS_WITHOUT_TESTAPPS) # if (NOT LWS_WITHOUT_TEST_SERVER) create_test_app(test-server "test-server/test-server.c" "test-server/test-server-http.c" "test-server/test-server-dumb-increment.c" "test-server/test-server-mirror.c") + if (UNIX) + create_test_app(test-server-pthreads "test-server/test-server-pthreads.c" "test-server/test-server-http.c" "test-server/test-server-dumb-increment.c" "test-server/test-server-mirror.c") + endif() endif() # diff --git a/test-server/test-server-http.c b/test-server/test-server-http.c index dacd8e8d..9c72e58e 100644 --- a/test-server/test-server-http.c +++ b/test-server/test-server-http.c @@ -397,7 +397,6 @@ bail: /* if we returned non-zero from here, we kill the connection */ break; -#ifdef EXTERNAL_POLL /* * callbacks for managing the external poll() array appear in * protocol 0 callback @@ -407,16 +406,21 @@ bail: /* * lock mutex to protect pollfd state * called before any other POLL related callback + * if protecting wsi lifecycle change, len == 1 */ + test_server_lock(len); break; case LWS_CALLBACK_UNLOCK_POLL: /* * unlock mutex to protect pollfd state when * called after any other POLL related callback + * if protecting wsi lifecycle change, len == 1 */ + test_server_unlock(len); break; +#ifdef EXTERNAL_POLL case LWS_CALLBACK_ADD_POLL_FD: if (count_pollfds >= max_poll_elements) { diff --git a/test-server/test-server-pthreads.c b/test-server/test-server-pthreads.c new file mode 100644 index 00000000..bd756f8f --- /dev/null +++ b/test-server/test-server-pthreads.c @@ -0,0 +1,342 @@ +/* + * libwebsockets-test-server - libwebsockets test implementation + * + * Copyright (C) 2010-2015 Andy Green + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation: + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301 USA + */ + +#include "test-server.h" +#include + +int close_testing; +int max_poll_elements; + +#ifdef EXTERNAL_POLL +struct libwebsocket_pollfd *pollfds; +int *fd_lookup; +int count_pollfds; +#endif +volatile int force_exit = 0; +struct libwebsocket_context *context; + +/* + * This mutex lock protects code that changes or relies on wsi list outside of + * the service thread. The service thread will acquire it when changing the + * wsi list and other threads should acquire it while dereferencing wsis or + * calling apis like libwebsocket_callback_on_writable_all_protocol() which + * use the wsi list and wsis from a different thread context. + */ +pthread_mutex_t lock_established_conns; + +/* http server gets files from this path */ +#define LOCAL_RESOURCE_PATH INSTALL_DATADIR"/libwebsockets-test-server" +char *resource_path = LOCAL_RESOURCE_PATH; + +/* + * multithreaded version - protect wsi lifecycle changes in the library + * these are called from protocol 0 callbacks + */ + +void test_server_lock(int care) +{ + if (care) + pthread_mutex_lock(&lock_established_conns); +} +void test_server_unlock(int care) +{ + if (care) + pthread_mutex_unlock(&lock_established_conns); +} + +/* + * This demo server shows how to use libwebsockets for one or more + * websocket protocols in the same server + * + * It defines the following websocket protocols: + * + * dumb-increment-protocol: once the socket is opened, an incrementing + * ascii string is sent down it every 50ms. + * If you send "reset\n" on the websocket, then + * the incrementing number is reset to 0. + * + * lws-mirror-protocol: copies any received packet to every connection also + * using this protocol, including the sender + */ + +enum demo_protocols { + /* always first */ + PROTOCOL_HTTP = 0, + + PROTOCOL_DUMB_INCREMENT, + PROTOCOL_LWS_MIRROR, + + /* always last */ + DEMO_PROTOCOL_COUNT +}; + +/* list of supported protocols and callbacks */ + +static struct libwebsocket_protocols protocols[] = { + /* first protocol must always be HTTP handler */ + + { + "http-only", /* name */ + callback_http, /* callback */ + sizeof (struct per_session_data__http), /* per_session_data_size */ + 0, /* max frame size / rx buffer */ + }, + { + "dumb-increment-protocol", + callback_dumb_increment, + sizeof(struct per_session_data__dumb_increment), + 10, + }, + { + "lws-mirror-protocol", + callback_lws_mirror, + sizeof(struct per_session_data__lws_mirror), + 128, + }, + { NULL, NULL, 0, 0 } /* terminator */ +}; + +void *thread_dumb_increment(void *threadid) +{ + while (!force_exit) { + /* + * this lock means wsi in the active list cannot + * disappear underneath us, because the code to add and remove + * them is protected by the same lock + */ + pthread_mutex_lock(&lock_established_conns); + libwebsocket_callback_on_writable_all_protocol( + &protocols[PROTOCOL_DUMB_INCREMENT]); + pthread_mutex_unlock(&lock_established_conns); + usleep(100000); + } + + pthread_exit(NULL); +} + +void sighandler(int sig) +{ + force_exit = 1; + libwebsocket_cancel_service(context); +} + +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' }, + { "libev", no_argument, NULL, 'e' }, +#ifndef LWS_NO_DAEMONIZE + { "daemonize", no_argument, NULL, 'D' }, +#endif + { "resource_path", required_argument, NULL, 'r' }, + { NULL, 0, 0, 0 } +}; + +int main(int argc, char **argv) +{ + struct lws_context_creation_info info; + char interface_name[128] = ""; + const char *iface = NULL; + pthread_t pthread_dumb; + char cert_path[1024]; + char key_path[1024]; + int debug_level = 7; + int use_ssl = 0; + void *retval; + int opts = 0; + int n = 0; +#ifndef _WIN32 + int syslog_options = LOG_PID | LOG_PERROR; +#endif +#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; + + pthread_mutex_init(&lock_established_conns, NULL); + + while (n >= 0) { + n = getopt_long(argc, argv, "eci:hsap:d:Dr:", options, NULL); + if (n < 0) + continue; + switch (n) { + case 'e': + opts |= LWS_SERVER_OPTION_LIBEV; + break; +#ifndef LWS_NO_DAEMONIZE + case 'D': + daemonize = 1; + #ifndef _WIN32 + syslog_options &= ~LOG_PERROR; + #endif + break; +#endif + case 'd': + debug_level = atoi(optarg); + break; + case 's': + use_ssl = 1; + break; + case 'a': + opts |= LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT; + break; + case 'p': + info.port = atoi(optarg); + break; + case 'i': + strncpy(interface_name, optarg, sizeof interface_name); + interface_name[(sizeof interface_name) - 1] = '\0'; + iface = interface_name; + 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 'r': + resource_path = optarg; + printf("Setting resource path to \"%s\"\n", resource_path); + break; + case 'h': + fprintf(stderr, "Usage: test-server " + "[--port=

] [--ssl] " + "[-d ] " + "[--resource_path ]\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 1; + } +#endif + + signal(SIGINT, sighandler); + +#ifndef _WIN32 + /* we will only try to log things according to our debug_level */ + setlogmask(LOG_UPTO (LOG_DEBUG)); + openlog("lwsts", syslog_options, LOG_DAEMON); +#endif + + /* tell the library what debug level to emit and to send it to syslog */ + lws_set_log_level(debug_level, lwsl_emit_syslog); + + lwsl_notice("libwebsockets test server - " + "(C) Copyright 2010-2015 Andy Green - " + "licensed under LGPL2.1\n"); + + printf("Using resource path \"%s\"\n", resource_path); +#ifdef EXTERNAL_POLL + max_poll_elements = getdtablesize(); + pollfds = malloc(max_poll_elements * sizeof (struct libwebsocket_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; +#ifndef LWS_NO_EXTENSIONS + info.extensions = libwebsocket_get_internal_extensions(); +#endif + + info.ssl_cert_filepath = NULL; + info.ssl_private_key_filepath = NULL; + + if (use_ssl) { + if (strlen(resource_path) > sizeof(cert_path) - 32) { + lwsl_err("resource path too long\n"); + return -1; + } + 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; + } + sprintf(key_path, "%s/libwebsockets-test-server.key.pem", + resource_path); + + info.ssl_cert_filepath = cert_path; + info.ssl_private_key_filepath = key_path; + } + info.gid = -1; + info.uid = -1; + info.options = opts; + + context = libwebsocket_create_context(&info); + if (context == NULL) { + lwsl_err("libwebsocket init failed\n"); + return -1; + } + + /* start the dumb increment thread */ + + n = pthread_create(&pthread_dumb, NULL, thread_dumb_increment, 0); + if (n) { + lwsl_err("Unable to create dumb thread\n"); + goto done; + } + + /* this is our service thread */ + + n = 0; + while (n >= 0 && !force_exit) { + n = libwebsocket_service(context, 50); + } + + /* wait for pthread_dumb to exit */ + pthread_join(pthread_dumb, &retval); + +done: + libwebsocket_context_destroy(context); + pthread_mutex_destroy(&lock_established_conns); + + + lwsl_notice("libwebsockets-test-server exited cleanly\n"); + +#ifndef _WIN32 + closelog(); +#endif + + return 0; +} diff --git a/test-server/test-server.c b/test-server/test-server.c index 8949dfd2..050f73b1 100644 --- a/test-server/test-server.c +++ b/test-server/test-server.c @@ -36,6 +36,15 @@ struct libwebsocket_context *context; #define LOCAL_RESOURCE_PATH INSTALL_DATADIR"/libwebsockets-test-server" char *resource_path = LOCAL_RESOURCE_PATH; +/* singlethreaded version --> no locks */ + +void test_server_lock(int care) +{ +} +void test_server_unlock(int care) +{ +} + /* * This demo server shows how to use libwebsockets for one or more * websocket protocols in the same server diff --git a/test-server/test-server.h b/test-server/test-server.h index 73805eb8..52effab1 100644 --- a/test-server/test-server.h +++ b/test-server/test-server.h @@ -35,6 +35,9 @@ extern volatile int force_exit; extern struct libwebsocket_context *context; extern char *resource_path; +extern void test_server_lock(int care); +extern void test_server_unlock(int care); + #ifndef __func__ #define __func__ __FUNCTION__ #endif