2010-11-08 20:20:42 +00:00
|
|
|
/*
|
|
|
|
|
* libwebsockets - small server side websockets and web server implementation
|
2010-11-13 10:03:47 +00:00
|
|
|
*
|
2019-01-13 06:58:21 +08:00
|
|
|
* Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
|
2010-11-08 20:20:42 +00:00
|
|
|
*
|
2019-08-14 10:44:14 +01:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
|
* of this software and associated documentation files (the "Software"), to
|
|
|
|
|
* deal in the Software without restriction, including without limitation the
|
|
|
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
|
|
|
* furnished to do so, subject to the following conditions:
|
2010-11-08 20:20:42 +00:00
|
|
|
*
|
2019-08-14 10:44:14 +01:00
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
|
* all copies or substantial portions of the Software.
|
2010-11-08 20:20:42 +00:00
|
|
|
*
|
2019-08-14 10:44:14 +01:00
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
|
* IN THE SOFTWARE.
|
2010-11-08 20:20:42 +00:00
|
|
|
*/
|
2013-02-06 15:30:33 +09:00
|
|
|
|
2019-09-19 10:15:56 +01:00
|
|
|
#if !defined(__LWS_PRIVATE_LIB_CORE_H__)
|
|
|
|
|
#define __LWS_PRIVATE_LIB_CORE_H__
|
|
|
|
|
|
2013-02-06 15:26:58 +09:00
|
|
|
#include "lws_config.h"
|
2015-06-26 11:40:54 +02:00
|
|
|
#include "lws_config_private.h"
|
2014-04-02 21:02:54 +08:00
|
|
|
|
2020-05-14 21:28:48 +01:00
|
|
|
|
2019-06-07 11:11:46 +01:00
|
|
|
#if defined(LWS_WITH_CGI) && defined(LWS_HAVE_VFORK) && \
|
2019-12-22 03:38:05 +00:00
|
|
|
!defined(NO_GNU_SOURCE_THIS_TIME) && !defined(_GNU_SOURCE)
|
2018-04-19 12:53:53 +08:00
|
|
|
#define _GNU_SOURCE
|
2016-02-21 21:25:48 +08:00
|
|
|
#endif
|
|
|
|
|
|
2022-09-15 13:26:38 +03:00
|
|
|
#if defined(LWS_SUPPRESS_DEPRECATED_API_WARNINGS)
|
|
|
|
|
#define OPENSSL_SUPPRESS_DEPRECATED
|
|
|
|
|
#endif
|
|
|
|
|
|
2019-06-07 11:11:46 +01:00
|
|
|
/*
|
|
|
|
|
#if !defined(_POSIX_C_SOURCE)
|
|
|
|
|
#define _POSIX_C_SOURCE 200112L
|
|
|
|
|
#endif
|
|
|
|
|
*/
|
|
|
|
|
|
2021-08-30 10:20:07 +01:00
|
|
|
#ifdef LWS_HAVE_SYS_TYPES_H
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#endif
|
|
|
|
|
#if !defined(PICO_SDK_PATH)
|
|
|
|
|
#ifdef LWS_HAVE_INTTYPES_H
|
|
|
|
|
#include <inttypes.h>
|
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//#include <stddef.h>
|
2010-11-08 20:20:42 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
2014-03-30 10:19:23 +02:00
|
|
|
#include <time.h>
|
2010-11-08 20:20:42 +00:00
|
|
|
#include <ctype.h>
|
2013-01-17 10:08:16 +08:00
|
|
|
#include <limits.h>
|
2011-03-02 22:03:47 +00:00
|
|
|
#include <stdarg.h>
|
2020-05-14 21:28:48 +01:00
|
|
|
#include <errno.h>
|
2019-07-31 16:31:22 +08:00
|
|
|
|
2015-12-04 07:22:44 +08:00
|
|
|
#include <assert.h>
|
2014-04-07 11:28:08 +02:00
|
|
|
|
2019-01-15 06:59:48 +08:00
|
|
|
#if defined(LWS_HAVE_SYS_STAT_H) && !defined(LWS_PLAT_OPTEE)
|
2018-04-19 12:53:53 +08:00
|
|
|
#include <sys/stat.h>
|
2014-09-16 14:05:13 +04:00
|
|
|
#endif
|
|
|
|
|
|
2020-06-24 20:15:46 +01:00
|
|
|
#if LWS_MAX_SMP > 1 || defined(LWS_WITH_SYS_SMD)
|
|
|
|
|
/* https://stackoverflow.com/questions/33557506/timespec-redefinition-error */
|
|
|
|
|
#define HAVE_STRUCT_TIMESPEC
|
2018-06-16 09:37:07 +08:00
|
|
|
#include <pthread.h>
|
2020-06-24 20:15:46 +01:00
|
|
|
#else
|
|
|
|
|
#if !defined(pid_t) && defined(WIN32)
|
|
|
|
|
#define pid_t int
|
|
|
|
|
#endif
|
2015-01-30 10:13:01 +08:00
|
|
|
#endif
|
|
|
|
|
|
2016-01-26 20:56:56 +08:00
|
|
|
#ifndef LWS_DEF_HEADER_LEN
|
2016-07-11 07:48:53 +08:00
|
|
|
#define LWS_DEF_HEADER_LEN 4096
|
2013-01-12 23:42:17 +08:00
|
|
|
#endif
|
2016-01-26 20:56:56 +08:00
|
|
|
#ifndef LWS_DEF_HEADER_POOL
|
2016-07-11 07:48:53 +08:00
|
|
|
#define LWS_DEF_HEADER_POOL 4
|
2015-12-25 12:44:12 +08:00
|
|
|
#endif
|
2013-01-12 23:42:17 +08:00
|
|
|
#ifndef LWS_MAX_PROTOCOLS
|
2013-02-10 16:00:47 +08:00
|
|
|
#define LWS_MAX_PROTOCOLS 5
|
2013-01-12 23:42:17 +08:00
|
|
|
#endif
|
|
|
|
|
#ifndef LWS_MAX_EXTENSIONS_ACTIVE
|
2018-04-20 10:33:23 +08:00
|
|
|
#define LWS_MAX_EXTENSIONS_ACTIVE 1
|
2013-01-12 23:42:17 +08:00
|
|
|
#endif
|
2016-01-11 11:34:01 +08:00
|
|
|
#ifndef LWS_MAX_EXT_OFFERS
|
|
|
|
|
#define LWS_MAX_EXT_OFFERS 8
|
|
|
|
|
#endif
|
2013-01-12 23:42:17 +08:00
|
|
|
#ifndef SPEC_LATEST_SUPPORTED
|
2011-09-25 09:32:54 +01:00
|
|
|
#define SPEC_LATEST_SUPPORTED 13
|
2013-01-12 23:42:17 +08:00
|
|
|
#endif
|
|
|
|
|
#ifndef CIPHERS_LIST_STRING
|
2013-01-10 10:15:19 +08:00
|
|
|
#define CIPHERS_LIST_STRING "DEFAULT"
|
2013-01-12 23:42:17 +08:00
|
|
|
#endif
|
2013-01-15 20:52:29 +08:00
|
|
|
#ifndef LWS_SOMAXCONN
|
|
|
|
|
#define LWS_SOMAXCONN SOMAXCONN
|
|
|
|
|
#endif
|
2010-11-08 20:20:42 +00:00
|
|
|
|
2011-01-18 17:14:03 +00:00
|
|
|
#define MAX_WEBSOCKET_04_KEY_LEN 128
|
2013-01-12 23:42:17 +08:00
|
|
|
|
|
|
|
|
#ifndef SYSTEM_RANDOM_FILEPATH
|
2011-01-22 12:51:57 +00:00
|
|
|
#define SYSTEM_RANDOM_FILEPATH "/dev/urandom"
|
2013-01-12 23:42:17 +08:00
|
|
|
#endif
|
|
|
|
|
|
2018-03-31 11:30:12 +08:00
|
|
|
#define LWS_H2_RX_SCRATCH_SIZE 512
|
|
|
|
|
|
2018-06-16 08:53:48 -07:00
|
|
|
#define lws_socket_is_valid(x) (x != LWS_SOCK_INVALID)
|
2017-10-18 09:41:44 +08:00
|
|
|
|
2018-06-16 09:37:07 +08:00
|
|
|
#ifndef LWS_HAVE_STRERROR
|
|
|
|
|
#define strerror(x) ""
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* ------ private platform defines ------
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
2021-08-30 10:20:07 +01:00
|
|
|
#if defined(LWS_PLAT_FREERTOS)
|
|
|
|
|
#include "private-lib-plat-freertos.h"
|
2018-06-16 09:37:07 +08:00
|
|
|
#else
|
2021-08-30 10:20:07 +01:00
|
|
|
#if defined(WIN32) || defined(_WIN32)
|
|
|
|
|
#include "private-lib-plat-windows.h"
|
2018-06-16 09:37:07 +08:00
|
|
|
#else
|
2021-08-25 09:35:07 +01:00
|
|
|
#if defined(LWS_PLAT_BAREMETAL)
|
2021-08-30 10:20:07 +01:00
|
|
|
#else
|
2021-08-25 09:35:07 +01:00
|
|
|
#if defined(LWS_PLAT_OPTEE)
|
|
|
|
|
#include "private-lib-plat.h"
|
|
|
|
|
#else
|
|
|
|
|
#include "private-lib-plat-unix.h"
|
|
|
|
|
#endif
|
2021-08-30 10:20:07 +01:00
|
|
|
#endif
|
2018-06-16 09:37:07 +08:00
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* ------ public api ------
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "libwebsockets.h"
|
|
|
|
|
|
2021-01-06 15:08:22 +00:00
|
|
|
/*
|
|
|
|
|
* lws_dsh
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
typedef struct lws_dsh_obj_head {
|
|
|
|
|
lws_dll2_owner_t owner;
|
|
|
|
|
size_t total_size; /* for this kind in dsh */
|
|
|
|
|
int kind;
|
|
|
|
|
} lws_dsh_obj_head_t;
|
|
|
|
|
|
|
|
|
|
typedef struct lws_dsh_obj {
|
|
|
|
|
lws_dll2_t list; /* must be first */
|
|
|
|
|
struct lws_dsh *dsh; /* invalid when on free list */
|
|
|
|
|
size_t size; /* invalid when on free list */
|
2021-09-04 05:05:21 +01:00
|
|
|
size_t pos; /* invalid when on free list */
|
2021-01-06 15:08:22 +00:00
|
|
|
size_t asize;
|
|
|
|
|
int kind; /* so we can account at free */
|
|
|
|
|
} lws_dsh_obj_t;
|
|
|
|
|
|
|
|
|
|
typedef struct lws_dsh {
|
|
|
|
|
lws_dll2_t list;
|
|
|
|
|
uint8_t *buf;
|
|
|
|
|
lws_dsh_obj_head_t *oha; /* array of object heads/kind */
|
2021-09-04 05:05:21 +01:00
|
|
|
size_t splitat;
|
2021-01-06 15:08:22 +00:00
|
|
|
size_t buffer_size;
|
|
|
|
|
size_t locally_in_use;
|
|
|
|
|
size_t locally_free;
|
|
|
|
|
int count_kinds;
|
2021-09-04 05:05:21 +01:00
|
|
|
uint32_t flags;
|
2021-01-06 15:08:22 +00:00
|
|
|
uint8_t being_destroyed;
|
|
|
|
|
/*
|
|
|
|
|
* Overallocations at create:
|
|
|
|
|
*
|
|
|
|
|
* - the buffer itself
|
|
|
|
|
* - the object heads array
|
|
|
|
|
*/
|
|
|
|
|
} lws_dsh_t;
|
|
|
|
|
|
2020-12-25 05:54:19 +00:00
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* ------ lifecycle defines ------
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
typedef struct lws_lifecycle_group {
|
|
|
|
|
lws_dll2_owner_t owner; /* active count / list */
|
|
|
|
|
uint64_t ordinal; /* monotonic uid count */
|
|
|
|
|
const char *tag_prefix; /* eg, "wsi" */
|
|
|
|
|
} lws_lifecycle_group_t;
|
|
|
|
|
|
|
|
|
|
typedef struct lws_lifecycle {
|
|
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS_PROXY_API)
|
|
|
|
|
/* we append parent streams on the tag */
|
|
|
|
|
char gutag[96]; /* object unique tag + relationship info */
|
|
|
|
|
#else
|
2021-02-05 13:08:41 +00:00
|
|
|
char gutag[64];
|
2020-12-25 05:54:19 +00:00
|
|
|
#endif
|
|
|
|
|
lws_dll2_t list; /* group list membership */
|
|
|
|
|
uint64_t us_creation; /* creation timestamp */
|
2021-06-26 17:24:19 +01:00
|
|
|
lws_log_cx_t *log_cx;
|
2020-12-25 05:54:19 +00:00
|
|
|
} lws_lifecycle_t;
|
|
|
|
|
|
|
|
|
|
void
|
2021-06-26 17:24:19 +01:00
|
|
|
__lws_lc_tag(struct lws_context *cx, lws_lifecycle_group_t *grp,
|
|
|
|
|
lws_lifecycle_t *lc, const char *format, ...);
|
2020-12-25 05:54:19 +00:00
|
|
|
|
|
|
|
|
void
|
|
|
|
|
__lws_lc_tag_append(lws_lifecycle_t *lc, const char *app);
|
|
|
|
|
|
|
|
|
|
void
|
2021-06-26 17:24:19 +01:00
|
|
|
__lws_lc_untag(struct lws_context *cx, lws_lifecycle_t *lc);
|
2020-12-25 05:54:19 +00:00
|
|
|
|
|
|
|
|
const char *
|
|
|
|
|
lws_lc_tag(lws_lifecycle_t *lc);
|
2020-05-22 16:47:40 +01:00
|
|
|
|
2021-06-26 17:24:19 +01:00
|
|
|
extern lws_log_cx_t log_cx;
|
|
|
|
|
|
2020-01-15 12:07:20 +00:00
|
|
|
/*
|
|
|
|
|
* Generic bidi tx credit management
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
struct lws_tx_credit {
|
|
|
|
|
int32_t tx_cr; /* our credit to write peer */
|
|
|
|
|
int32_t peer_tx_cr_est; /* peer's credit to write us */
|
|
|
|
|
|
|
|
|
|
int32_t manual_initial_tx_credit;
|
|
|
|
|
|
|
|
|
|
uint8_t skint; /* unable to write anything */
|
|
|
|
|
uint8_t manual;
|
|
|
|
|
};
|
|
|
|
|
|
2020-06-05 10:13:17 +01:00
|
|
|
#ifdef LWS_WITH_IPV6
|
|
|
|
|
#if defined(WIN32) || defined(_WIN32)
|
|
|
|
|
#include <iphlpapi.h>
|
|
|
|
|
#else
|
|
|
|
|
#include <net/if.h>
|
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#undef X509_NAME
|
|
|
|
|
|
2020-10-04 07:28:41 +01:00
|
|
|
/*
|
|
|
|
|
* All lws_tls...() functions must return this type, converting the
|
|
|
|
|
* native backend result and doing the extra work to determine which one
|
|
|
|
|
* as needed.
|
|
|
|
|
*
|
|
|
|
|
* Native TLS backend return codes are NOT ALLOWED outside the backend.
|
|
|
|
|
*
|
|
|
|
|
* Non-SSL mode also uses these types.
|
|
|
|
|
*/
|
|
|
|
|
enum lws_ssl_capable_status {
|
|
|
|
|
LWS_SSL_CAPABLE_ERROR = -1, /* it failed */
|
|
|
|
|
LWS_SSL_CAPABLE_DONE = 0, /* it succeeded */
|
|
|
|
|
LWS_SSL_CAPABLE_MORE_SERVICE_READ = -2, /* retry WANT_READ */
|
|
|
|
|
LWS_SSL_CAPABLE_MORE_SERVICE_WRITE = -3, /* retry WANT_WRITE */
|
|
|
|
|
LWS_SSL_CAPABLE_MORE_SERVICE = -4, /* general retry */
|
|
|
|
|
};
|
|
|
|
|
|
2020-11-16 19:32:58 +00:00
|
|
|
enum lws_context_destroy {
|
|
|
|
|
LWSCD_NO_DESTROY, /* running */
|
|
|
|
|
LWSCD_PT_WAS_DEFERRED, /* destroy from inside service */
|
|
|
|
|
LWSCD_PT_WAIT_ALL_DESTROYED, /* libuv ends up here later */
|
|
|
|
|
LWSCD_FINALIZATION /* the final destruction of context */
|
|
|
|
|
};
|
2020-10-04 07:28:41 +01:00
|
|
|
|
2020-05-22 16:47:40 +01:00
|
|
|
#if defined(LWS_WITH_TLS)
|
2019-08-15 10:49:52 +01:00
|
|
|
#include "private-lib-tls.h"
|
2020-05-22 16:47:40 +01:00
|
|
|
#endif
|
2018-06-16 09:37:07 +08:00
|
|
|
|
2018-08-16 19:10:32 +08:00
|
|
|
#if defined(WIN32) || defined(_WIN32)
|
|
|
|
|
// Visual studio older than 2015 and WIN_CE has only _stricmp
|
|
|
|
|
#if (defined(_MSC_VER) && _MSC_VER < 1900) || defined(_WIN32_WCE)
|
|
|
|
|
#define strcasecmp _stricmp
|
2019-05-04 08:23:03 +01:00
|
|
|
#define strncasecmp _strnicmp
|
2018-08-16 19:10:32 +08:00
|
|
|
#elif !defined(__MINGW32__)
|
|
|
|
|
#define strcasecmp stricmp
|
2019-05-04 08:23:03 +01:00
|
|
|
#define strncasecmp strnicmp
|
2018-08-16 19:10:32 +08:00
|
|
|
#endif
|
|
|
|
|
#define getdtablesize() 30000
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef LWS_ARRAY_SIZE
|
|
|
|
|
#define LWS_ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-06-16 09:37:07 +08:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
2017-10-18 09:41:44 +08:00
|
|
|
|
2020-08-14 08:46:31 +01:00
|
|
|
#define lws_safe_modulo(_a, _b) ((_b) ? ((_a) % (_b)) : 0)
|
2017-10-18 09:41:44 +08:00
|
|
|
|
2017-11-12 09:16:46 +08:00
|
|
|
#if defined(__clang__)
|
|
|
|
|
#define lws_memory_barrier() __sync_synchronize()
|
|
|
|
|
#elif defined(__GNUC__)
|
|
|
|
|
#define lws_memory_barrier() __sync_synchronize()
|
|
|
|
|
#else
|
|
|
|
|
#define lws_memory_barrier()
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-11-29 08:47:49 +08:00
|
|
|
|
2017-09-20 10:37:59 +08:00
|
|
|
struct lws_ring {
|
|
|
|
|
void *buf;
|
|
|
|
|
void (*destroy_element)(void *element);
|
2017-10-25 08:00:23 +08:00
|
|
|
uint32_t buflen;
|
|
|
|
|
uint32_t element_len;
|
2017-09-20 10:37:59 +08:00
|
|
|
uint32_t head;
|
|
|
|
|
uint32_t oldest_tail;
|
|
|
|
|
};
|
|
|
|
|
|
2015-12-04 11:08:32 +08:00
|
|
|
struct lws_protocols;
|
|
|
|
|
struct lws;
|
2011-01-19 13:11:55 +00:00
|
|
|
|
2021-08-30 10:20:07 +01:00
|
|
|
#include "private-lib-secure-streams.h"
|
|
|
|
|
|
2020-08-27 15:37:14 +01:00
|
|
|
#if defined(LWS_WITH_NETWORK) /* network */
|
2019-08-15 10:49:52 +01:00
|
|
|
#include "private-lib-event-libs.h"
|
2019-01-13 06:58:21 +08:00
|
|
|
|
2020-06-24 20:15:46 +01:00
|
|
|
#if defined(LWS_WITH_SYS_SMD)
|
|
|
|
|
#include "private-lib-system-smd.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-02-17 10:31:22 +00:00
|
|
|
#if defined(LWS_WITH_SYS_FAULT_INJECTION)
|
|
|
|
|
#include "private-lib-system-fault-injection.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-01-06 15:08:22 +00:00
|
|
|
#include "private-lib-system-metrics.h"
|
|
|
|
|
|
2017-11-12 09:16:46 +08:00
|
|
|
struct lws_foreign_thread_pollfd {
|
|
|
|
|
struct lws_foreign_thread_pollfd *next;
|
|
|
|
|
int fd_index;
|
|
|
|
|
int _and;
|
|
|
|
|
int _or;
|
|
|
|
|
};
|
|
|
|
|
|
2019-08-15 10:49:52 +01:00
|
|
|
#include "private-lib-core-net.h"
|
2021-08-25 09:35:07 +01:00
|
|
|
#endif /* network */
|
2018-04-25 06:53:30 +08:00
|
|
|
|
2020-02-10 09:06:28 +00:00
|
|
|
struct lws_system_blob {
|
2019-12-07 19:41:58 +00:00
|
|
|
union {
|
|
|
|
|
struct lws_buflist *bl;
|
|
|
|
|
struct {
|
|
|
|
|
const uint8_t *ptr;
|
|
|
|
|
size_t len;
|
|
|
|
|
} direct;
|
|
|
|
|
} u;
|
|
|
|
|
char is_direct;
|
2020-02-10 09:06:28 +00:00
|
|
|
};
|
2019-12-07 19:41:58 +00:00
|
|
|
|
2019-12-31 15:24:58 +00:00
|
|
|
|
|
|
|
|
typedef struct lws_attach_item {
|
|
|
|
|
lws_dll2_t list;
|
|
|
|
|
lws_attach_cb_t cb;
|
|
|
|
|
void *opaque;
|
|
|
|
|
lws_system_states_t state;
|
|
|
|
|
} lws_attach_item_t;
|
|
|
|
|
|
2020-12-25 05:54:19 +00:00
|
|
|
/*
|
|
|
|
|
* These are the context's lifecycle group indexes that exist in this build
|
|
|
|
|
* configuration. If you add some, make sure to also add the tag_prefix in
|
|
|
|
|
* context.c context creation with matching preprocessor conditionals.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
LWSLCG_WSI, /* generic wsi, eg, pipe, listen */
|
|
|
|
|
LWSLCG_VHOST,
|
|
|
|
|
|
|
|
|
|
LWSLCG_WSI_SERVER, /* server wsi */
|
2021-01-07 05:25:53 +00:00
|
|
|
|
2021-01-06 15:08:22 +00:00
|
|
|
#if defined(LWS_ROLE_H2) || defined(LWS_ROLE_MQTT)
|
|
|
|
|
LWSLCG_WSI_MUX, /* a mux child wsi */
|
|
|
|
|
#endif
|
|
|
|
|
|
2020-12-25 05:54:19 +00:00
|
|
|
#if defined(LWS_WITH_CLIENT)
|
|
|
|
|
LWSLCG_WSI_CLIENT, /* client wsi */
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS)
|
|
|
|
|
#if defined(LWS_WITH_CLIENT)
|
|
|
|
|
LWSLCG_SS_CLIENT, /* secstream client handle */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
|
|
|
LWSLCG_SS_SERVER, /* secstream server handle */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_CLIENT)
|
|
|
|
|
LWSLCG_WSI_SS_CLIENT, /* wsi bound to ss client handle */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
|
|
|
LWSLCG_WSI_SS_SERVER, /* wsi bound to ss server handle */
|
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS_PROXY_API)
|
|
|
|
|
#if defined(LWS_WITH_CLIENT)
|
|
|
|
|
LWSLCG_SSP_CLIENT, /* SSPC handle client connection to proxy */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
|
|
|
LWSLCG_SSP_ONWARD, /* SS handle at proxy for onward conn */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_CLIENT)
|
|
|
|
|
LWSLCG_WSI_SSP_CLIENT, /* wsi bound to SSPC cli conn to proxy */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
|
|
|
LWSLCG_WSI_SSP_ONWARD, /* wsi bound to Proxy onward connection */
|
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-10-09 10:58:21 +01:00
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
|
|
|
LWSLCG_WSI_SSP_SINK, /* accepted sink conn */
|
|
|
|
|
LWSLCG_WSI_SSP_SOURCE, /* accepted source conn */
|
|
|
|
|
#endif
|
|
|
|
|
|
2020-12-25 05:54:19 +00:00
|
|
|
/* always last */
|
|
|
|
|
LWSLCG_COUNT
|
|
|
|
|
};
|
|
|
|
|
|
2021-10-09 10:58:21 +01:00
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS) && defined(LWS_WITH_SERVER)
|
|
|
|
|
typedef struct lws_ss_sinks {
|
|
|
|
|
lws_dll2_t list;
|
|
|
|
|
lws_ss_info_t info;
|
|
|
|
|
lws_dll2_owner_t accepts;
|
|
|
|
|
} lws_ss_sinks_t;
|
|
|
|
|
#endif
|
|
|
|
|
|
2016-01-19 03:34:24 +08:00
|
|
|
/*
|
|
|
|
|
* the rest is managed per-context, that includes
|
|
|
|
|
*
|
|
|
|
|
* - processwide single fd -> wsi lookup
|
|
|
|
|
* - contextwide headers pool
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
struct lws_context {
|
2019-09-19 06:54:53 +01:00
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
|
|
|
char canonical_hostname[96];
|
|
|
|
|
#endif
|
2021-12-07 08:31:17 +00:00
|
|
|
#if defined(LWS_HAVE_SSL_CTX_set_keylog_callback) && \
|
|
|
|
|
defined(LWS_WITH_TLS) && defined(LWS_WITH_CLIENT)
|
|
|
|
|
char keylog_file[96];
|
|
|
|
|
#endif
|
2019-09-19 06:54:53 +01:00
|
|
|
|
2019-08-18 06:29:34 +01:00
|
|
|
#if defined(LWS_WITH_FILE_OPS)
|
2017-03-03 12:38:10 +08:00
|
|
|
struct lws_plat_file_ops fops_platform;
|
2019-08-18 06:29:34 +01:00
|
|
|
#endif
|
2018-05-01 12:41:42 +08:00
|
|
|
|
2019-09-19 06:54:53 +01:00
|
|
|
#if defined(LWS_WITH_ZIP_FOPS)
|
|
|
|
|
struct lws_plat_file_ops fops_zip;
|
2019-08-18 06:29:34 +01:00
|
|
|
#endif
|
2018-05-01 12:41:42 +08:00
|
|
|
|
2019-12-07 19:41:58 +00:00
|
|
|
lws_system_blob_t system_blobs[LWS_SYSBLOB_TYPE_COUNT];
|
|
|
|
|
|
2020-06-24 20:15:46 +01:00
|
|
|
#if defined(LWS_WITH_SYS_SMD)
|
2020-12-22 14:12:29 +00:00
|
|
|
lws_smd_t smd;
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS)
|
|
|
|
|
struct lws_ss_handle *ss_cpd;
|
2020-06-24 20:15:46 +01:00
|
|
|
#endif
|
2021-01-07 18:48:33 +00:00
|
|
|
lws_sorted_usec_list_t sul_cpd_defer;
|
2020-06-24 20:15:46 +01:00
|
|
|
|
lws_display: add display list / DLO support
This adds optional display list support to lws_display, using DLOs (Display
List Objects). DLOs for rectangle / rounded rectangle (with circle as the
degenerate case), PNGs, JPEG and compressed, antialiased bitmapped fonts
and text primitives are provided.
Logical DLOs are instantiated on heap and listed into an lws_display_list
owner, DLOs handle attributes like position, bounding box, colour +
opacity, and local error diffusion backing buffer.
When the display list is complete, it can be rasterized a line at a time,
with scoped error diffusion resolved, such that no allocation for the
framebuffer is required at any point. DLOs are freed as the rasterization
moves beyond their bounding box.
Adds a platform registry binding names and other metadata to lws_display
fonts / PNGs / JPEGs. Provides registration, destruction and best match
selection apis.
2022-01-04 06:00:55 +00:00
|
|
|
#if defined(LWS_WITH_DLO)
|
|
|
|
|
lws_dll2_owner_t fonts;
|
|
|
|
|
lws_dll2_owner_t dlo_file;
|
|
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS)
|
|
|
|
|
lws_dll2_owner_t active_assets; /* dloss_t */
|
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
2019-09-19 06:54:53 +01:00
|
|
|
#if defined(LWS_WITH_NETWORK)
|
2020-07-18 19:45:51 +01:00
|
|
|
struct lws_context_per_thread pt[LWS_MAX_SMP];
|
|
|
|
|
lws_retry_bo_t default_retry;
|
|
|
|
|
lws_sorted_usec_list_t sul_system_state;
|
2020-12-25 05:54:19 +00:00
|
|
|
|
|
|
|
|
lws_lifecycle_group_t lcg[LWSLCG_COUNT];
|
|
|
|
|
|
2021-05-21 14:32:21 +01:00
|
|
|
const struct lws_protocols *protocols_copy;
|
|
|
|
|
|
2020-10-04 07:28:41 +01:00
|
|
|
#if defined(LWS_WITH_NETLINK)
|
|
|
|
|
lws_sorted_usec_list_t sul_nl_coldplug;
|
2021-03-07 09:44:29 +00:00
|
|
|
/* process can only have one netlink socket, have to do it in ctx */
|
|
|
|
|
lws_dll2_owner_t routing_table;
|
|
|
|
|
struct lws *netlink;
|
2020-10-04 07:28:41 +01:00
|
|
|
#endif
|
2019-03-24 17:54:48 +08:00
|
|
|
|
2021-04-04 06:31:23 +01:00
|
|
|
#if defined(LWS_PLAT_FREERTOS)
|
2020-07-18 19:45:51 +01:00
|
|
|
struct sockaddr_in frt_pipe_si;
|
2020-01-15 08:31:28 +00:00
|
|
|
#endif
|
|
|
|
|
|
2017-10-13 10:33:02 +08:00
|
|
|
#if defined(LWS_WITH_HTTP2)
|
2020-07-18 19:45:51 +01:00
|
|
|
struct http2_settings set;
|
2017-10-13 10:33:02 +08:00
|
|
|
#endif
|
2019-09-19 06:54:53 +01:00
|
|
|
|
|
|
|
|
#if LWS_MAX_SMP > 1
|
2020-07-18 19:45:51 +01:00
|
|
|
struct lws_mutex_refcount mr;
|
2019-09-19 06:54:53 +01:00
|
|
|
#endif
|
|
|
|
|
|
2021-01-06 15:08:22 +00:00
|
|
|
#if defined(LWS_WITH_SYS_METRICS)
|
|
|
|
|
lws_dll2_owner_t owner_mtr_dynpol;
|
|
|
|
|
/**< owner for lws_metric_policy_dyn_t (dynamic part of metric pols) */
|
|
|
|
|
lws_dll2_owner_t owner_mtr_no_pol;
|
|
|
|
|
/**< owner for lws_metric_pub_t with no policy to bind to */
|
|
|
|
|
#endif
|
2020-07-02 15:38:53 +01:00
|
|
|
|
2021-01-06 15:08:22 +00:00
|
|
|
#if defined(LWS_WITH_NETWORK)
|
2020-07-02 15:38:53 +01:00
|
|
|
/*
|
|
|
|
|
* LWS_WITH_NETWORK =====>
|
|
|
|
|
*/
|
|
|
|
|
|
2021-01-22 09:11:22 +00:00
|
|
|
lws_dll2_owner_t owner_vh_being_destroyed;
|
|
|
|
|
|
2021-01-06 15:08:22 +00:00
|
|
|
lws_metric_t *mt_service; /* doing service */
|
|
|
|
|
const lws_metric_policy_t *metrics_policies;
|
|
|
|
|
const char *metrics_prefix;
|
|
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_SYS_METRICS) && defined(LWS_WITH_CLIENT)
|
|
|
|
|
lws_metric_t *mt_conn_tcp; /* client tcp conns */
|
|
|
|
|
lws_metric_t *mt_conn_tls; /* client tcp conns */
|
|
|
|
|
lws_metric_t *mt_conn_dns; /* client dns external lookups */
|
|
|
|
|
lws_metric_t *mth_conn_failures; /* histogram of conn failure reasons */
|
|
|
|
|
#if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2)
|
|
|
|
|
lws_metric_t *mt_http_txn; /* client http transaction */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_SYS_ASYNC_DNS)
|
|
|
|
|
lws_metric_t *mt_adns_cache; /* async dns lookup lat */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS)
|
|
|
|
|
lws_metric_t *mth_ss_conn; /* SS connection outcomes */
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS_PROXY_API)
|
|
|
|
|
lws_metric_t *mt_ss_cliprox_conn; /* SS cli->prox conn */
|
|
|
|
|
lws_metric_t *mt_ss_cliprox_paylat; /* cli->prox payload latency */
|
|
|
|
|
lws_metric_t *mt_ss_proxcli_paylat; /* prox->cli payload latency */
|
|
|
|
|
#endif
|
|
|
|
|
#endif /* client */
|
|
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
|
|
|
lws_metric_t *mth_srv;
|
|
|
|
|
#endif
|
|
|
|
|
|
2020-08-27 15:37:14 +01:00
|
|
|
#if defined(LWS_WITH_EVENT_LIBS)
|
|
|
|
|
struct lws_plugin *evlib_plugin_list;
|
|
|
|
|
void *evlib_ctx; /* overallocated */
|
2020-02-07 11:39:32 +00:00
|
|
|
#endif
|
2020-08-27 15:37:14 +01:00
|
|
|
|
2019-09-19 06:54:53 +01:00
|
|
|
#if defined(LWS_WITH_TLS)
|
2020-08-27 15:37:14 +01:00
|
|
|
struct lws_context_tls tls;
|
2021-05-21 14:32:21 +01:00
|
|
|
#if defined (LWS_WITH_TLS_JIT_TRUST)
|
|
|
|
|
lws_dll2_owner_t jit_inflight;
|
|
|
|
|
/* ongoing sync or async jit trust lookups */
|
|
|
|
|
struct lws_cache_ttl_lru *trust_cache;
|
|
|
|
|
/* caches host -> truncated trust SKID mappings */
|
|
|
|
|
#endif
|
2019-09-19 06:54:53 +01:00
|
|
|
#endif
|
2020-07-02 15:38:53 +01:00
|
|
|
#if defined(LWS_WITH_DRIVERS)
|
|
|
|
|
lws_netdevs_t netdevs;
|
|
|
|
|
#endif
|
2019-09-19 06:54:53 +01:00
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_SYS_ASYNC_DNS)
|
2020-07-02 15:38:53 +01:00
|
|
|
lws_async_dns_t async_dns;
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-02-17 10:31:22 +00:00
|
|
|
#if defined(LWS_WITH_SYS_FAULT_INJECTION)
|
2021-03-16 13:32:05 +00:00
|
|
|
lws_fi_ctx_t fic;
|
2021-02-17 10:31:22 +00:00
|
|
|
/**< Toplevel Fault Injection ctx */
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-07-05 16:41:41 +08:00
|
|
|
#if defined(LWS_WITH_CACHE_NSCOOKIEJAR) && defined(LWS_WITH_CLIENT)
|
|
|
|
|
struct lws_cache_ttl_lru *l1, *nsc;
|
|
|
|
|
#endif
|
2021-02-17 10:31:22 +00:00
|
|
|
|
2020-07-02 15:38:53 +01:00
|
|
|
#if defined(LWS_WITH_SYS_NTPCLIENT)
|
|
|
|
|
void *ntpclient_priv;
|
2019-09-19 06:54:53 +01:00
|
|
|
#endif
|
|
|
|
|
|
2020-07-18 19:45:51 +01:00
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS)
|
2020-06-22 20:05:06 +01:00
|
|
|
struct lws_ss_handle *hss_fetch_policy;
|
2020-02-29 12:37:24 +00:00
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS_SYS_AUTH_API_AMAZON_COM)
|
|
|
|
|
struct lws_ss_handle *hss_auth;
|
|
|
|
|
lws_sorted_usec_list_t sul_api_amazon_com;
|
|
|
|
|
lws_sorted_usec_list_t sul_api_amazon_com_kick;
|
|
|
|
|
#endif
|
2020-07-27 10:03:12 +01:00
|
|
|
#if !defined(LWS_WITH_SECURE_STREAMS_STATIC_POLICY_ONLY)
|
|
|
|
|
struct lws_ss_x509 *server_der_list;
|
|
|
|
|
#endif
|
2020-07-18 19:45:51 +01:00
|
|
|
#endif
|
2020-02-29 12:37:24 +00:00
|
|
|
|
2020-06-23 13:19:30 +01:00
|
|
|
#if defined(LWS_WITH_SYS_STATE)
|
2019-09-19 09:48:17 +01:00
|
|
|
lws_state_manager_t mgr_system;
|
|
|
|
|
lws_state_notify_link_t protocols_notify;
|
2020-06-23 13:19:30 +01:00
|
|
|
#endif
|
2019-09-27 14:32:59 -07:00
|
|
|
#if defined (LWS_WITH_SYS_DHCP_CLIENT)
|
|
|
|
|
lws_dll2_owner_t dhcpc_owner;
|
|
|
|
|
/**< list of ifaces with dhcpc */
|
2019-09-19 09:48:17 +01:00
|
|
|
#endif
|
|
|
|
|
|
2019-09-19 06:54:53 +01:00
|
|
|
/* pointers */
|
|
|
|
|
|
2020-07-18 19:45:51 +01:00
|
|
|
struct lws_vhost *vhost_list;
|
|
|
|
|
struct lws_vhost *no_listener_vhost_list;
|
|
|
|
|
struct lws_vhost *vhost_pending_destruction_list;
|
|
|
|
|
struct lws_vhost *vhost_system;
|
2019-09-19 06:54:53 +01:00
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_SERVER)
|
2020-07-18 19:45:51 +01:00
|
|
|
const char *server_string;
|
2019-09-19 06:54:53 +01:00
|
|
|
#endif
|
|
|
|
|
|
2020-08-27 15:37:14 +01:00
|
|
|
const struct lws_event_loop_ops *event_loop_ops;
|
2019-09-19 06:54:53 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_TLS)
|
2020-07-18 19:45:51 +01:00
|
|
|
const struct lws_tls_ops *tls_ops;
|
2019-09-19 06:54:53 +01:00
|
|
|
#endif
|
2019-08-23 16:10:36 +01:00
|
|
|
|
2019-08-18 06:29:34 +01:00
|
|
|
#if defined(LWS_WITH_PLUGINS)
|
2020-07-18 19:45:51 +01:00
|
|
|
struct lws_plugin *plugin_list;
|
2019-08-18 06:29:34 +01:00
|
|
|
#endif
|
2015-01-30 10:13:01 +08:00
|
|
|
#ifdef _WIN32
|
|
|
|
|
/* different implementation between unix and windows */
|
2015-12-04 09:23:56 +08:00
|
|
|
struct lws_fd_hashtable fd_hashtable[FD_HASHTABLE_MODULUS];
|
2015-01-30 10:13:01 +08:00
|
|
|
#else
|
unix plat: add minimal wsi fd map option
An lws context usually contains a processwide fd -> wsi lookup table.
This allows any possible fd returned by a *nix type OS to be immediately
converted to a wsi just by indexing an array of struct lws * the size of
the highest possible fd, as found by ulimit -n or similar.
This works modestly for Linux type systems where the default ulimit -n for
a process is 1024, it means a 4KB or 8KB lookup table for 32-bit or
64-bit systems.
However in the case your lws usage is much simpler, like one outgoing
client connection and no serving, this represents increasing waste. It's
made much worse if the system has a much larger default ulimit -n, eg 1M,
the table is occupying 4MB or 8MB, of which you will only use one.
Even so, because lws can't be sure the OS won't return a socket fd at any
number up to (ulimit -n - 1), it has to allocate the whole lookup table
at the moment.
This patch looks to see if the context creation info is setting
info->fd_limit_per_thread... if it leaves it at the default 0, then
everything is as it was before this patch. However if finds that
(info->fd_limit_per_thread * actual_number_of_service_threads) where
the default number of service threads is 1, is less than the fd limit
set by ulimit -n, lws switches to a slower lookup table scheme, which
only allocates the requested number of slots. Lookups happen then by
iterating the table and comparing rather than indexing the array
directly, which is obviously somewhat of a performance hit.
However in the case where you know lws will only have a very few wsi
maximum, this method can very usefully trade off speed to be able to
avoid the allocation sized by ulimit -n.
minimal examples for client that can make use of this are also modified
by this patch to use the smaller context allocations.
2019-05-17 01:20:07 +01:00
|
|
|
struct lws **lws_lookup;
|
|
|
|
|
|
2015-01-30 10:13:01 +08:00
|
|
|
#endif
|
2020-07-02 15:38:53 +01:00
|
|
|
|
2022-02-23 08:19:14 +00:00
|
|
|
#if defined(LWS_WITH_OTA)
|
|
|
|
|
lws_sorted_usec_list_t sul_ota_periodic;
|
|
|
|
|
lws_ss_handle_t * ota_ss; /* opaque to platform */
|
|
|
|
|
#endif
|
|
|
|
|
|
2020-07-02 15:38:53 +01:00
|
|
|
/*
|
|
|
|
|
* <====== LWS_WITH_NETWORK end
|
|
|
|
|
*/
|
|
|
|
|
|
2019-09-19 06:54:53 +01:00
|
|
|
#endif /* NETWORK */
|
2019-01-13 06:58:21 +08:00
|
|
|
|
2021-08-25 09:35:07 +01:00
|
|
|
lws_log_cx_t *log_cx;
|
|
|
|
|
const char *name;
|
2021-06-26 17:24:19 +01:00
|
|
|
|
2020-02-29 12:37:24 +00:00
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS_PROXY_API)
|
2021-08-25 09:35:07 +01:00
|
|
|
const char *ss_proxy_bind;
|
|
|
|
|
const char *ss_proxy_address;
|
|
|
|
|
|
|
|
|
|
lws_txp_path_proxy_t txp_ppath;
|
|
|
|
|
lws_txp_path_client_t txp_cpath;
|
|
|
|
|
|
|
|
|
|
const void *txp_ssproxy_info;
|
|
|
|
|
|
2020-02-29 12:37:24 +00:00
|
|
|
#endif
|
|
|
|
|
|
2019-08-23 16:10:36 +01:00
|
|
|
#if defined(LWS_WITH_FILE_OPS)
|
|
|
|
|
const struct lws_plat_file_ops *fops;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
struct lws_context **pcontext_finalize;
|
2020-07-18 19:45:51 +01:00
|
|
|
#if !defined(LWS_PLAT_FREERTOS)
|
2019-08-23 16:10:36 +01:00
|
|
|
const char *username, *groupname;
|
2020-07-18 19:45:51 +01:00
|
|
|
#endif
|
2019-08-23 16:10:36 +01:00
|
|
|
|
2021-07-09 18:04:08 +01:00
|
|
|
#if defined(LWS_WITH_MBEDTLS)
|
2019-08-07 18:58:05 +01:00
|
|
|
mbedtls_entropy_context mec;
|
|
|
|
|
mbedtls_ctr_drbg_context mcdc;
|
|
|
|
|
#endif
|
|
|
|
|
|
2022-04-11 06:42:53 +01:00
|
|
|
#if defined(LWS_WITH_THREADPOOL) && defined(LWS_HAVE_PTHREAD_H)
|
2018-09-02 14:35:37 +08:00
|
|
|
struct lws_threadpool *tp_list_head;
|
|
|
|
|
#endif
|
|
|
|
|
|
2017-09-14 13:14:11 +08:00
|
|
|
#if defined(LWS_WITH_PEER_LIMITS)
|
2020-05-24 19:44:46 +01:00
|
|
|
struct lws_peer **pl_hash_table;
|
|
|
|
|
struct lws_peer *peer_wait_list;
|
|
|
|
|
lws_peer_limits_notify_t pl_notify_cb;
|
|
|
|
|
time_t next_cull;
|
2017-09-14 13:14:11 +08:00
|
|
|
#endif
|
context deprecation
1) This makes lwsws run a parent process with the original permissions.
But this process is only able to respond to SIGHUP, it doesn't do anything
else.
2) You can send this parent process a SIGHUP now to cause it to
- close listening sockets in existing lwsws processes
- mark those processes as to exit when the number of active connections
on the falls to zero
- spawn a fresh child process from scratch, using latest configuration
file content, latest plugins, etc. It can now reopen listening sockets
if it chooses to, or open different listen ports or whatever.
Notes:
1) lws_context_destroy() has been split into two pieces... the reason for
the split is the first part closes the per-vhost protocols, but since
they may have created libuv objects in the per-vhost protocol storage,
these cannot be freed until after the loop has been run.
That's the purpose of the second part of the context destruction,
lws_context_destroy2().
For compatibility, if you are not using libuv, the first part calls the
second part. However if you are using libuv, you must now call the
second part from your own main.c after the first part.
2016-12-16 07:37:43 +08:00
|
|
|
|
2020-07-18 19:45:51 +01:00
|
|
|
const lws_system_ops_t *system_ops;
|
2020-02-29 12:37:24 +00:00
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS)
|
2020-03-26 06:48:34 +00:00
|
|
|
#if !defined(LWS_WITH_SECURE_STREAMS_STATIC_POLICY_ONLY)
|
2020-07-18 19:45:51 +01:00
|
|
|
const char *pss_policies_json;
|
|
|
|
|
struct lwsac *ac_policy;
|
|
|
|
|
void *pol_args;
|
2020-03-26 06:48:34 +00:00
|
|
|
#endif
|
2020-07-18 19:45:51 +01:00
|
|
|
const lws_ss_policy_t *pss_policies;
|
2020-08-19 11:21:58 +01:00
|
|
|
const lws_ss_auth_t *pss_auths;
|
2021-10-09 10:58:21 +01:00
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
|
|
|
lws_dll2_owner_t sinks;
|
|
|
|
|
#endif
|
2020-07-27 10:03:12 +01:00
|
|
|
#if defined(LWS_WITH_SSPLUGINS)
|
2020-07-18 19:45:51 +01:00
|
|
|
const lws_ss_plugin_t **pss_plugins;
|
2020-07-27 10:03:12 +01:00
|
|
|
#endif
|
2020-02-29 12:37:24 +00:00
|
|
|
#endif
|
|
|
|
|
|
2016-12-04 07:34:05 +08:00
|
|
|
void *external_baggage_free_on_destroy;
|
2015-12-26 08:56:58 +08:00
|
|
|
const struct lws_token_limits *token_limits;
|
|
|
|
|
void *user_space;
|
2019-08-18 06:29:34 +01:00
|
|
|
#if defined(LWS_WITH_SERVER)
|
2016-10-13 06:32:57 +08:00
|
|
|
const struct lws_protocol_vhost_options *reject_service_keywords;
|
context deprecation
1) This makes lwsws run a parent process with the original permissions.
But this process is only able to respond to SIGHUP, it doesn't do anything
else.
2) You can send this parent process a SIGHUP now to cause it to
- close listening sockets in existing lwsws processes
- mark those processes as to exit when the number of active connections
on the falls to zero
- spawn a fresh child process from scratch, using latest configuration
file content, latest plugins, etc. It can now reopen listening sockets
if it chooses to, or open different listen ports or whatever.
Notes:
1) lws_context_destroy() has been split into two pieces... the reason for
the split is the first part closes the per-vhost protocols, but since
they may have created libuv objects in the per-vhost protocol storage,
these cannot be freed until after the loop has been run.
That's the purpose of the second part of the context destruction,
lws_context_destroy2().
For compatibility, if you are not using libuv, the first part calls the
second part. However if you are using libuv, you must now call the
second part from your own main.c after the first part.
2016-12-16 07:37:43 +08:00
|
|
|
lws_reload_func deprecation_cb;
|
2019-08-18 06:29:34 +01:00
|
|
|
#endif
|
2020-07-18 19:45:51 +01:00
|
|
|
#if !defined(LWS_PLAT_FREERTOS)
|
2018-04-29 10:44:36 +08:00
|
|
|
void (*eventlib_signal_cb)(void *event_lib_handle, int signum);
|
2020-07-18 19:45:51 +01:00
|
|
|
#endif
|
2016-01-19 04:32:14 +08:00
|
|
|
|
2017-06-07 06:10:02 +08:00
|
|
|
#if defined(LWS_HAVE_SYS_CAPABILITY_H) && defined(LWS_HAVE_LIBCAP)
|
|
|
|
|
cap_value_t caps[4];
|
|
|
|
|
char count_caps;
|
|
|
|
|
#endif
|
|
|
|
|
|
2019-08-23 16:10:36 +01:00
|
|
|
lws_usec_t time_up; /* monotonic */
|
2021-02-15 15:50:16 +00:00
|
|
|
#if defined(LWS_WITH_SYS_SMD)
|
|
|
|
|
lws_usec_t smd_ttl_us;
|
|
|
|
|
#endif
|
2019-09-13 13:12:55 +01:00
|
|
|
uint64_t options;
|
|
|
|
|
|
2019-08-23 16:10:36 +01:00
|
|
|
time_t last_ws_ping_pong_check_s;
|
2021-01-06 15:08:22 +00:00
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS)
|
|
|
|
|
time_t last_policy;
|
|
|
|
|
#endif
|
2019-08-23 16:10:36 +01:00
|
|
|
|
2019-08-18 10:35:43 +01:00
|
|
|
#if defined(LWS_PLAT_FREERTOS)
|
2017-09-11 10:23:30 +08:00
|
|
|
unsigned long time_last_state_dump;
|
|
|
|
|
uint32_t last_free_heap;
|
|
|
|
|
#endif
|
2017-05-07 10:02:03 +08:00
|
|
|
|
2020-12-12 06:21:40 +00:00
|
|
|
unsigned int max_fds;
|
2019-01-23 18:06:32 +08:00
|
|
|
#if !defined(LWS_NO_DAEMONIZE)
|
|
|
|
|
pid_t started_with_parent;
|
|
|
|
|
#endif
|
2013-01-19 13:56:10 +08:00
|
|
|
|
2020-07-18 19:45:51 +01:00
|
|
|
#if !defined(LWS_PLAT_FREERTOS)
|
2020-12-12 06:21:40 +00:00
|
|
|
uid_t uid;
|
|
|
|
|
gid_t gid;
|
2011-02-10 09:32:24 +00:00
|
|
|
int fd_random;
|
2020-07-18 19:45:51 +01:00
|
|
|
int count_cgi_spawned;
|
|
|
|
|
#endif
|
2022-09-03 22:19:14 +02:00
|
|
|
#if defined(WIN32)
|
|
|
|
|
unsigned int win32_connect_check_interval_usec;
|
|
|
|
|
#endif
|
2020-07-18 19:45:51 +01:00
|
|
|
|
2016-01-19 03:34:24 +08:00
|
|
|
unsigned int fd_limit_per_thread;
|
2016-02-15 20:36:02 +08:00
|
|
|
unsigned int timeout_secs;
|
2016-05-19 12:34:35 +08:00
|
|
|
unsigned int pt_serv_buf_size;
|
2020-12-12 06:21:40 +00:00
|
|
|
unsigned int max_http_header_data;
|
|
|
|
|
unsigned int max_http_header_pool;
|
2017-03-16 10:46:31 +08:00
|
|
|
int simultaneous_ssl_restriction;
|
|
|
|
|
int simultaneous_ssl;
|
2021-09-22 09:34:56 +01:00
|
|
|
int simultaneous_ssl_handshake_restriction;
|
|
|
|
|
int simultaneous_ssl_handshake;
|
2021-05-21 14:32:21 +01:00
|
|
|
#if defined(LWS_WITH_TLS_JIT_TRUST)
|
|
|
|
|
int vh_idle_grace_ms;
|
|
|
|
|
#endif
|
2017-09-14 13:14:11 +08:00
|
|
|
#if defined(LWS_WITH_PEER_LIMITS)
|
|
|
|
|
uint32_t pl_hash_elements; /* protected by context->lock */
|
|
|
|
|
uint32_t count_peers; /* protected by context->lock */
|
|
|
|
|
unsigned short ip_limit_ah;
|
|
|
|
|
unsigned short ip_limit_wsi;
|
|
|
|
|
#endif
|
2021-02-15 15:50:16 +00:00
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_SYS_SMD)
|
|
|
|
|
uint16_t smd_queue_depth;
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-08-25 09:35:07 +01:00
|
|
|
#if defined(LWS_WITH_NETLINK) && defined(LWS_WITH_NETWORK)
|
2021-03-07 09:44:29 +00:00
|
|
|
lws_route_uidx_t route_uidx;
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-09-22 09:34:56 +01:00
|
|
|
char tls_gate_accepts;
|
|
|
|
|
|
context deprecation
1) This makes lwsws run a parent process with the original permissions.
But this process is only able to respond to SIGHUP, it doesn't do anything
else.
2) You can send this parent process a SIGHUP now to cause it to
- close listening sockets in existing lwsws processes
- mark those processes as to exit when the number of active connections
on the falls to zero
- spawn a fresh child process from scratch, using latest configuration
file content, latest plugins, etc. It can now reopen listening sockets
if it chooses to, or open different listen ports or whatever.
Notes:
1) lws_context_destroy() has been split into two pieces... the reason for
the split is the first part closes the per-vhost protocols, but since
they may have created libuv objects in the per-vhost protocol storage,
these cannot be freed until after the loop has been run.
That's the purpose of the second part of the context destruction,
lws_context_destroy2().
For compatibility, if you are not using libuv, the first part calls the
second part. However if you are using libuv, you must now call the
second part from your own main.c after the first part.
2016-12-16 07:37:43 +08:00
|
|
|
unsigned int deprecated:1;
|
2021-09-18 09:34:36 +01:00
|
|
|
unsigned int interrupted:1;
|
2020-01-23 11:12:28 +00:00
|
|
|
unsigned int inside_context_destroy:1;
|
context deprecation
1) This makes lwsws run a parent process with the original permissions.
But this process is only able to respond to SIGHUP, it doesn't do anything
else.
2) You can send this parent process a SIGHUP now to cause it to
- close listening sockets in existing lwsws processes
- mark those processes as to exit when the number of active connections
on the falls to zero
- spawn a fresh child process from scratch, using latest configuration
file content, latest plugins, etc. It can now reopen listening sockets
if it chooses to, or open different listen ports or whatever.
Notes:
1) lws_context_destroy() has been split into two pieces... the reason for
the split is the first part closes the per-vhost protocols, but since
they may have created libuv objects in the per-vhost protocol storage,
these cannot be freed until after the loop has been run.
That's the purpose of the second part of the context destruction,
lws_context_destroy2().
For compatibility, if you are not using libuv, the first part calls the
second part. However if you are using libuv, you must now call the
second part from your own main.c after the first part.
2016-12-16 07:37:43 +08:00
|
|
|
unsigned int being_destroyed:1;
|
2020-11-16 19:32:58 +00:00
|
|
|
unsigned int service_no_longer_possible:1;
|
2018-04-30 09:16:04 +08:00
|
|
|
unsigned int being_destroyed2:1;
|
2020-11-16 19:32:58 +00:00
|
|
|
unsigned int requested_stop_internal_loops:1;
|
context deprecation
1) This makes lwsws run a parent process with the original permissions.
But this process is only able to respond to SIGHUP, it doesn't do anything
else.
2) You can send this parent process a SIGHUP now to cause it to
- close listening sockets in existing lwsws processes
- mark those processes as to exit when the number of active connections
on the falls to zero
- spawn a fresh child process from scratch, using latest configuration
file content, latest plugins, etc. It can now reopen listening sockets
if it chooses to, or open different listen ports or whatever.
Notes:
1) lws_context_destroy() has been split into two pieces... the reason for
the split is the first part closes the per-vhost protocols, but since
they may have created libuv objects in the per-vhost protocol storage,
these cannot be freed until after the loop has been run.
That's the purpose of the second part of the context destruction,
lws_context_destroy2().
For compatibility, if you are not using libuv, the first part calls the
second part. However if you are using libuv, you must now call the
second part from your own main.c after the first part.
2016-12-16 07:37:43 +08:00
|
|
|
unsigned int protocol_init_done:1;
|
2018-04-29 10:44:36 +08:00
|
|
|
unsigned int doing_protocol_init:1;
|
|
|
|
|
unsigned int done_protocol_destroy_cb:1;
|
2020-11-16 19:32:58 +00:00
|
|
|
unsigned int evlib_finalize_destroy_after_int_loops_stop:1;
|
unix plat: add minimal wsi fd map option
An lws context usually contains a processwide fd -> wsi lookup table.
This allows any possible fd returned by a *nix type OS to be immediately
converted to a wsi just by indexing an array of struct lws * the size of
the highest possible fd, as found by ulimit -n or similar.
This works modestly for Linux type systems where the default ulimit -n for
a process is 1024, it means a 4KB or 8KB lookup table for 32-bit or
64-bit systems.
However in the case your lws usage is much simpler, like one outgoing
client connection and no serving, this represents increasing waste. It's
made much worse if the system has a much larger default ulimit -n, eg 1M,
the table is occupying 4MB or 8MB, of which you will only use one.
Even so, because lws can't be sure the OS won't return a socket fd at any
number up to (ulimit -n - 1), it has to allocate the whole lookup table
at the moment.
This patch looks to see if the context creation info is setting
info->fd_limit_per_thread... if it leaves it at the default 0, then
everything is as it was before this patch. However if finds that
(info->fd_limit_per_thread * actual_number_of_service_threads) where
the default number of service threads is 1, is less than the fd limit
set by ulimit -n, lws switches to a slower lookup table scheme, which
only allocates the requested number of slots. Lookups happen then by
iterating the table and comparing rather than indexing the array
directly, which is obviously somewhat of a performance hit.
However in the case where you know lws will only have a very few wsi
maximum, this method can very usefully trade off speed to be able to
avoid the allocation sized by ulimit -n.
minimal examples for client that can make use of this are also modified
by this patch to use the smaller context allocations.
2019-05-17 01:20:07 +01:00
|
|
|
unsigned int max_fds_unrelated_to_ulimit:1;
|
2020-02-29 12:37:24 +00:00
|
|
|
unsigned int policy_updated:1;
|
2020-10-04 07:28:41 +01:00
|
|
|
#if defined(LWS_WITH_NETLINK)
|
|
|
|
|
unsigned int nl_initial_done:1;
|
|
|
|
|
#endif
|
2014-03-06 11:57:50 +01:00
|
|
|
|
2020-12-12 06:21:40 +00:00
|
|
|
unsigned short count_threads;
|
|
|
|
|
unsigned short undestroyed_threads;
|
2016-04-06 16:15:40 +08:00
|
|
|
short plugin_protocol_count;
|
|
|
|
|
short plugin_extension_count;
|
2016-04-15 13:33:52 +08:00
|
|
|
short server_string_len;
|
context deprecation
1) This makes lwsws run a parent process with the original permissions.
But this process is only able to respond to SIGHUP, it doesn't do anything
else.
2) You can send this parent process a SIGHUP now to cause it to
- close listening sockets in existing lwsws processes
- mark those processes as to exit when the number of active connections
on the falls to zero
- spawn a fresh child process from scratch, using latest configuration
file content, latest plugins, etc. It can now reopen listening sockets
if it chooses to, or open different listen ports or whatever.
Notes:
1) lws_context_destroy() has been split into two pieces... the reason for
the split is the first part closes the per-vhost protocols, but since
they may have created libuv objects in the per-vhost protocol storage,
these cannot be freed until after the loop has been run.
That's the purpose of the second part of the context destruction,
lws_context_destroy2().
For compatibility, if you are not using libuv, the first part calls the
second part. However if you are using libuv, you must now call the
second part from your own main.c after the first part.
2016-12-16 07:37:43 +08:00
|
|
|
unsigned short deprecation_pending_listen_close_count;
|
2020-02-29 12:37:24 +00:00
|
|
|
#if defined(LWS_WITH_SECURE_STREAMS_PROXY_API)
|
|
|
|
|
uint16_t ss_proxy_port;
|
|
|
|
|
#endif
|
2021-01-17 11:27:59 +00:00
|
|
|
/* 0 if not known, else us resolution of the poll wait */
|
|
|
|
|
uint16_t us_wait_resolution;
|
2017-09-14 13:14:11 +08:00
|
|
|
|
2017-03-03 12:38:10 +08:00
|
|
|
uint8_t max_fi;
|
2020-03-11 12:44:01 +00:00
|
|
|
uint8_t captive_portal_detect;
|
|
|
|
|
uint8_t captive_portal_detect_type;
|
2019-08-10 07:32:32 +01:00
|
|
|
|
2020-11-16 19:32:58 +00:00
|
|
|
uint8_t destroy_state; /* enum lws_context_destroy */
|
2010-12-18 15:13:50 +00:00
|
|
|
};
|
|
|
|
|
|
2016-03-28 10:10:43 +08:00
|
|
|
#define lws_get_context_protocol(ctx, x) ctx->vhost_list->protocols[x]
|
|
|
|
|
#define lws_get_vh_protocol(vh, x) vh->protocols[x]
|
|
|
|
|
|
2017-10-18 19:27:38 +08:00
|
|
|
int
|
|
|
|
|
lws_jws_base64_enc(const char *in, size_t in_len, char *out, size_t out_max);
|
|
|
|
|
|
2018-03-30 20:22:46 +08:00
|
|
|
void
|
|
|
|
|
lws_vhost_destroy1(struct lws_vhost *vh);
|
2016-07-23 14:18:25 +08:00
|
|
|
|
2021-07-05 16:41:41 +08:00
|
|
|
#if defined(LWS_WITH_CACHE_NSCOOKIEJAR) && defined(LWS_WITH_CLIENT)
|
|
|
|
|
int
|
|
|
|
|
lws_parse_set_cookie(struct lws *wsi);
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
lws_cookie_send_cookies(struct lws *wsi, char **pp, char *end);
|
|
|
|
|
#endif
|
2016-02-14 09:27:41 +08:00
|
|
|
|
2019-08-18 10:35:43 +01:00
|
|
|
#if defined(LWS_PLAT_FREERTOS)
|
2020-09-06 11:46:25 +01:00
|
|
|
int
|
2018-11-23 08:47:56 +08:00
|
|
|
lws_find_string_in_file(const char *filename, const char *str, int stringlen);
|
2018-02-24 08:14:17 +08:00
|
|
|
#endif
|
|
|
|
|
|
2016-03-13 16:44:19 +08:00
|
|
|
signed char char_to_hex(const char c);
|
2016-03-09 07:41:59 +08:00
|
|
|
|
2019-12-31 15:24:58 +00:00
|
|
|
#if defined(LWS_WITH_NETWORK)
|
|
|
|
|
int
|
|
|
|
|
lws_system_do_attach(struct lws_context_per_thread *pt);
|
|
|
|
|
#endif
|
2016-04-15 12:00:23 +08:00
|
|
|
|
2018-04-13 16:01:38 +08:00
|
|
|
struct lws_buflist {
|
|
|
|
|
struct lws_buflist *next;
|
|
|
|
|
size_t len;
|
|
|
|
|
size_t pos;
|
|
|
|
|
};
|
|
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
char *
|
2018-05-10 16:13:26 +08:00
|
|
|
lws_strdup(const char *s);
|
|
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
int
|
2011-01-18 15:39:02 +00:00
|
|
|
lws_b64_selftest(void);
|
2011-02-09 08:49:14 +00:00
|
|
|
|
2022-03-01 17:29:24 +00:00
|
|
|
#define FIRST_LENGTH_CODE_INDEX 257
|
|
|
|
|
#define LAST_LENGTH_CODE_INDEX 285
|
|
|
|
|
|
|
|
|
|
/*256 literals, the end code, some length codes, and 2 unused codes */
|
|
|
|
|
#define NUM_DEFLATE_CODE_SYMBOLS 288
|
|
|
|
|
/*the distance codes have their own symbols, 30 used, 2 unused */
|
|
|
|
|
#define NUM_DISTANCE_SYMBOLS 32
|
|
|
|
|
/* The code length codes. 0-15: code lengths, 16: copy previous 3-6 times,
|
|
|
|
|
* 17: 3-10 zeros, 18: 11-138 zeros */
|
|
|
|
|
#define NUM_CODE_LENGTH_CODES 19
|
|
|
|
|
/* largest number of symbols used by any tree type */
|
|
|
|
|
#define MAX_SYMBOLS 288
|
|
|
|
|
|
|
|
|
|
#define DEFLATE_CODE_BITLEN 15
|
|
|
|
|
#define DISTANCE_BITLEN 15
|
|
|
|
|
#define CODE_LENGTH_BITLEN 7
|
|
|
|
|
/* largest bitlen used by any tree type */
|
|
|
|
|
#define MAX_BIT_LENGTH 15
|
|
|
|
|
|
|
|
|
|
#define DEFLATE_CODE_BUFFER_SIZE (NUM_DEFLATE_CODE_SYMBOLS * 2)
|
|
|
|
|
#define DISTANCE_BUFFER_SIZE (NUM_DISTANCE_SYMBOLS * 2)
|
|
|
|
|
#define CODE_LENGTH_BUFFER_SIZE (NUM_DISTANCE_SYMBOLS * 2)
|
|
|
|
|
|
|
|
|
|
typedef uint16_t huff_t;
|
|
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
|
UPNS_ID_BL_GB_DONE,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPEb0,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPEb1,
|
|
|
|
|
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_0,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_1,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2,
|
|
|
|
|
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_0a,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_0b,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_0c,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_0d,
|
|
|
|
|
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2a,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2b,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2c,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2d,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2e,
|
|
|
|
|
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2_16,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2_17,
|
|
|
|
|
UPNS_ID_BL_GB_BTYPE_2_18,
|
|
|
|
|
|
|
|
|
|
UPNS_ID_BL_GB_SPIN,
|
|
|
|
|
|
|
|
|
|
UPNS_ID_BL_GB_SPINa,
|
|
|
|
|
UPNS_ID_BL_GB_SPINb,
|
|
|
|
|
UPNS_ID_BL_GB_SPINc,
|
|
|
|
|
UPNS_ID_BL_GB_SPINd,
|
|
|
|
|
UPNS_ID_BL_GB_SPINe,
|
|
|
|
|
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_ID1,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_ID2,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_METHOD,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_FLAGS,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_EOH,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_SKIP_EXTRA_C1,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_SKIP_EXTRA_C2,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_SKIP_EXTRA,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_SKIP_FILENAME,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_SKIP_COMMENT,
|
|
|
|
|
UPNS_ID_BL_GB_GZIP_SKIP_CRC,
|
|
|
|
|
|
|
|
|
|
} upng_inflate_states_t;
|
|
|
|
|
|
|
|
|
|
typedef struct htree {
|
|
|
|
|
huff_t *tree2d;
|
|
|
|
|
/*maximum number of bits a single code can get */
|
|
|
|
|
uint16_t maxbitlen;
|
|
|
|
|
/*number of symbols in the alphabet = number of codes */
|
|
|
|
|
uint16_t numcodes;
|
|
|
|
|
} htree_t;
|
|
|
|
|
|
|
|
|
|
typedef struct inflator_ctx {
|
|
|
|
|
unsigned int clenc[NUM_CODE_LENGTH_CODES];
|
|
|
|
|
unsigned int bitlen[NUM_DEFLATE_CODE_SYMBOLS];
|
|
|
|
|
unsigned int bitlenD[NUM_DISTANCE_SYMBOLS];
|
|
|
|
|
huff_t clct_buffer[CODE_LENGTH_BUFFER_SIZE];
|
|
|
|
|
huff_t ct_buffer[DEFLATE_CODE_BUFFER_SIZE];
|
|
|
|
|
huff_t ctD_buffer[DISTANCE_BUFFER_SIZE];
|
|
|
|
|
|
|
|
|
|
lws_upng_t *upng;
|
|
|
|
|
|
|
|
|
|
const uint8_t *in;
|
|
|
|
|
uint8_t *out;
|
|
|
|
|
|
|
|
|
|
htree_t clct;
|
|
|
|
|
htree_t ct;
|
|
|
|
|
htree_t ctD;
|
|
|
|
|
|
|
|
|
|
size_t bp;
|
|
|
|
|
size_t inpos;
|
|
|
|
|
size_t inlen;
|
2022-02-23 08:19:14 +00:00
|
|
|
size_t archive_pos;
|
2022-03-01 17:29:24 +00:00
|
|
|
size_t outpos;
|
|
|
|
|
size_t outpos_linear;
|
|
|
|
|
size_t consumed_linear;
|
|
|
|
|
size_t outlen;
|
|
|
|
|
size_t length;
|
|
|
|
|
size_t start;
|
|
|
|
|
size_t forward;
|
|
|
|
|
size_t backward;
|
|
|
|
|
size_t exbits;
|
|
|
|
|
size_t bypl;
|
|
|
|
|
|
|
|
|
|
upng_inflate_states_t state;
|
|
|
|
|
|
|
|
|
|
unsigned int len;
|
|
|
|
|
unsigned int nlen;
|
|
|
|
|
unsigned int n;
|
|
|
|
|
unsigned int hlit;
|
|
|
|
|
unsigned int hdist;
|
|
|
|
|
unsigned int hclen;
|
|
|
|
|
unsigned int i;
|
|
|
|
|
unsigned int t;
|
|
|
|
|
unsigned int codeD;
|
|
|
|
|
unsigned int distance;
|
|
|
|
|
unsigned int exbitsD;
|
|
|
|
|
unsigned int code;
|
|
|
|
|
unsigned int treepos;
|
|
|
|
|
|
|
|
|
|
unsigned int read_bits_shifter;
|
|
|
|
|
unsigned int read_bits_limit;
|
|
|
|
|
unsigned int read_bits_i;
|
|
|
|
|
|
|
|
|
|
unsigned int info_size;
|
|
|
|
|
|
|
|
|
|
uint16_t ctr;
|
|
|
|
|
uint8_t subsequent;
|
|
|
|
|
uint8_t btype;
|
|
|
|
|
uint8_t done;
|
|
|
|
|
uint8_t gz_flags;
|
|
|
|
|
|
|
|
|
|
char read_bits_ongoing;
|
|
|
|
|
} inflator_ctx_t;
|
|
|
|
|
|
|
|
|
|
lws_stateful_ret_t
|
|
|
|
|
_lws_upng_inflate_data(inflator_ctx_t *inf);
|
2011-05-23 10:00:03 +01:00
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
#ifndef LWS_NO_DAEMONIZE
|
2020-09-06 11:46:25 +01:00
|
|
|
pid_t get_daemonize_pid();
|
2014-04-12 10:07:02 +08:00
|
|
|
#else
|
2018-04-19 12:53:53 +08:00
|
|
|
#define get_daemonize_pid() (0)
|
2013-02-11 17:13:32 +08:00
|
|
|
#endif
|
|
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
void lwsl_emit_stderr(int level, const char *line);
|
2014-04-03 23:34:09 +08:00
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
#if !defined(LWS_WITH_TLS)
|
2018-04-19 12:53:53 +08:00
|
|
|
#define LWS_SSL_ENABLED(context) (0)
|
|
|
|
|
#define lws_context_init_server_ssl(_a, _b) (0)
|
|
|
|
|
#define lws_ssl_destroy(_a)
|
|
|
|
|
#define lws_context_init_alpn(_a)
|
|
|
|
|
#define lws_ssl_capable_read lws_ssl_capable_read_no_ssl
|
|
|
|
|
#define lws_ssl_capable_write lws_ssl_capable_write_no_ssl
|
|
|
|
|
#define lws_ssl_pending lws_ssl_pending_no_ssl
|
2020-04-19 08:43:01 +01:00
|
|
|
#define lws_server_socket_service_ssl(_b, _c, _d) (0)
|
2018-04-19 12:53:53 +08:00
|
|
|
#define lws_ssl_close(_a) (0)
|
|
|
|
|
#define lws_ssl_context_destroy(_a)
|
|
|
|
|
#define lws_ssl_SSL_CTX_destroy(_a)
|
|
|
|
|
#define lws_ssl_remove_wsi_from_buffered_list(_a)
|
|
|
|
|
#define __lws_ssl_remove_wsi_from_buffered_list(_a)
|
2021-06-26 17:24:19 +01:00
|
|
|
#define lws_context_init_ssl_library(_a, _b)
|
2019-08-02 09:47:23 +01:00
|
|
|
#define lws_context_deinit_ssl_library(_a)
|
2018-04-19 12:53:53 +08:00
|
|
|
#define lws_tls_check_all_cert_lifetimes(_a)
|
|
|
|
|
#define lws_tls_acme_sni_cert_destroy(_a)
|
2014-04-03 10:17:00 +08:00
|
|
|
#endif
|
2017-10-18 09:41:44 +08:00
|
|
|
|
2014-04-03 07:16:40 +08:00
|
|
|
|
2018-03-02 14:22:49 +08:00
|
|
|
|
2019-01-13 06:58:21 +08:00
|
|
|
#if LWS_MAX_SMP > 1
|
2018-06-27 07:15:39 +08:00
|
|
|
#define lws_context_lock(c, reason) lws_mutex_refcount_lock(&c->mr, reason)
|
|
|
|
|
#define lws_context_unlock(c) lws_mutex_refcount_unlock(&c->mr)
|
2020-12-24 16:06:50 +00:00
|
|
|
#define lws_context_assert_lock_held(c) lws_mutex_refcount_assert_held(&c->mr)
|
2021-04-04 04:06:24 +01:00
|
|
|
#define lws_vhost_assert_lock_held(v) lws_mutex_refcount_assert_held(&v->mr)
|
|
|
|
|
/* enforce context lock held */
|
|
|
|
|
#define lws_vhost_lock(v) lws_mutex_refcount_lock(&v->mr, __func__)
|
|
|
|
|
#define lws_vhost_unlock(v) lws_mutex_refcount_unlock(&v->mr)
|
2018-03-02 15:31:35 +08:00
|
|
|
|
|
|
|
|
|
2016-01-26 20:56:56 +08:00
|
|
|
#else
|
|
|
|
|
#define lws_pt_mutex_init(_a) (void)(_a)
|
2016-05-12 20:22:35 -05:00
|
|
|
#define lws_pt_mutex_destroy(_a) (void)(_a)
|
2018-03-02 14:22:49 +08:00
|
|
|
#define lws_pt_lock(_a, b) (void)(_a)
|
2020-08-31 08:12:16 +01:00
|
|
|
#define lws_pt_assert_lock_held(_a) (void)(_a)
|
2016-01-26 20:56:56 +08:00
|
|
|
#define lws_pt_unlock(_a) (void)(_a)
|
2018-06-27 07:15:39 +08:00
|
|
|
#define lws_context_lock(_a, _b) (void)(_a)
|
2017-09-14 13:14:11 +08:00
|
|
|
#define lws_context_unlock(_a) (void)(_a)
|
2020-12-24 16:06:50 +00:00
|
|
|
#define lws_context_assert_lock_held(_a) (void)(_a)
|
2021-04-04 04:06:24 +01:00
|
|
|
#define lws_vhost_assert_lock_held(_a) (void)(_a)
|
2018-03-02 15:31:35 +08:00
|
|
|
#define lws_vhost_lock(_a) (void)(_a)
|
|
|
|
|
#define lws_vhost_unlock(_a) (void)(_a)
|
2018-03-02 14:22:49 +08:00
|
|
|
#define lws_pt_stats_lock(_a) (void)(_a)
|
|
|
|
|
#define lws_pt_stats_unlock(_a) (void)(_a)
|
2016-01-26 20:56:56 +08:00
|
|
|
#endif
|
|
|
|
|
|
2022-02-23 08:19:14 +00:00
|
|
|
void
|
|
|
|
|
lws_ota_periodic_cb(lws_sorted_usec_list_t *sul);
|
|
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
int LWS_WARN_UNUSED_RESULT
|
2020-12-12 06:21:40 +00:00
|
|
|
lws_ssl_capable_read_no_ssl(struct lws *wsi, unsigned char *buf, size_t len);
|
2014-04-15 18:40:31 +02:00
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
int LWS_WARN_UNUSED_RESULT
|
2020-12-12 06:21:40 +00:00
|
|
|
lws_ssl_capable_write_no_ssl(struct lws *wsi, unsigned char *buf, size_t len);
|
2014-04-15 18:40:31 +02:00
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
int LWS_WARN_UNUSED_RESULT
|
2015-12-04 11:08:32 +08:00
|
|
|
lws_ssl_pending_no_ssl(struct lws *wsi);
|
2015-08-19 16:23:33 +02:00
|
|
|
|
2017-10-26 18:53:34 +08:00
|
|
|
int
|
|
|
|
|
lws_tls_check_cert_lifetime(struct lws_vhost *vhost);
|
|
|
|
|
|
2017-10-18 19:27:38 +08:00
|
|
|
int lws_jws_selftest(void);
|
2018-11-27 08:36:08 +08:00
|
|
|
int lws_jwe_selftest(void);
|
2016-03-20 11:59:53 +08:00
|
|
|
|
2016-04-06 16:15:40 +08:00
|
|
|
int
|
|
|
|
|
lws_protocol_init(struct lws_context *context);
|
|
|
|
|
|
2016-06-18 09:00:04 +08:00
|
|
|
int
|
2018-09-02 14:35:37 +08:00
|
|
|
lws_bind_protocol(struct lws *wsi, const struct lws_protocols *p,
|
|
|
|
|
const char *reason);
|
2016-06-18 09:00:04 +08:00
|
|
|
|
2018-11-28 12:16:01 +08:00
|
|
|
const struct lws_protocol_vhost_options *
|
|
|
|
|
lws_vhost_protocol_options(struct lws_vhost *vh, const char *name);
|
|
|
|
|
|
2016-06-26 06:29:20 +08:00
|
|
|
const struct lws_http_mount *
|
|
|
|
|
lws_find_mount(struct lws *wsi, const char *uri_ptr, int uri_len);
|
|
|
|
|
|
2021-07-05 16:41:41 +08:00
|
|
|
#ifdef LWS_WITH_HTTP2
|
|
|
|
|
int lws_wsi_is_h2(struct lws *wsi);
|
|
|
|
|
#endif
|
2014-12-04 23:15:27 +01:00
|
|
|
/*
|
|
|
|
|
* custom allocator
|
|
|
|
|
*/
|
2020-09-06 11:46:25 +01:00
|
|
|
void *
|
2017-10-04 07:10:39 +08:00
|
|
|
lws_realloc(void *ptr, size_t size, const char *reason);
|
2014-12-04 23:15:27 +01:00
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
void * LWS_WARN_UNUSED_RESULT
|
2017-10-04 07:10:39 +08:00
|
|
|
lws_zalloc(size_t size, const char *reason);
|
2014-12-04 23:15:27 +01:00
|
|
|
|
2017-01-30 15:02:54 +08:00
|
|
|
#ifdef LWS_PLAT_OPTEE
|
2017-10-04 07:10:39 +08:00
|
|
|
void *lws_malloc(size_t size, const char *reason);
|
2017-01-30 15:02:54 +08:00
|
|
|
void lws_free(void *p);
|
|
|
|
|
#define lws_free_set_NULL(P) do { lws_free(P); (P) = NULL; } while(0)
|
|
|
|
|
#else
|
2017-10-04 07:10:39 +08:00
|
|
|
#define lws_malloc(S, R) lws_realloc(NULL, S, R)
|
|
|
|
|
#define lws_free(P) lws_realloc(P, 0, "lws_free")
|
|
|
|
|
#define lws_free_set_NULL(P) do { lws_realloc(P, 0, "free"); (P) = NULL; } while(0)
|
2017-01-30 15:02:54 +08:00
|
|
|
#endif
|
2014-12-04 23:15:27 +01:00
|
|
|
|
2017-10-24 11:59:44 +08:00
|
|
|
int
|
2020-12-24 16:06:50 +00:00
|
|
|
__lws_create_event_pipes(struct lws_context *context);
|
2017-10-24 11:59:44 +08:00
|
|
|
|
2018-08-01 06:52:03 +08:00
|
|
|
int
|
2018-06-23 12:56:21 +08:00
|
|
|
lws_plat_apply_FD_CLOEXEC(int n);
|
|
|
|
|
|
2017-03-03 12:38:10 +08:00
|
|
|
const struct lws_plat_file_ops *
|
|
|
|
|
lws_vfs_select_fops(const struct lws_plat_file_ops *fops, const char *vfs_path,
|
|
|
|
|
const char **vpath);
|
|
|
|
|
|
2015-12-06 09:15:27 +08:00
|
|
|
/* lws_plat_ */
|
2014-04-03 07:16:40 +08:00
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
int
|
2014-04-03 07:16:40 +08:00
|
|
|
lws_plat_context_early_init(void);
|
2020-09-06 11:46:25 +01:00
|
|
|
void
|
2015-12-04 11:08:32 +08:00
|
|
|
lws_plat_context_early_destroy(struct lws_context *context);
|
2020-09-06 11:46:25 +01:00
|
|
|
void
|
2015-12-04 11:08:32 +08:00
|
|
|
lws_plat_context_late_destroy(struct lws_context *context);
|
2018-11-15 16:33:54 +08:00
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
int
|
2015-12-10 07:14:16 +08:00
|
|
|
lws_plat_init(struct lws_context *context,
|
2018-04-27 08:27:16 +08:00
|
|
|
const struct lws_context_creation_info *info);
|
2020-09-06 11:46:25 +01:00
|
|
|
int
|
2019-04-21 19:51:03 +01:00
|
|
|
lws_plat_drop_app_privileges(struct lws_context *context, int actually_drop);
|
2015-11-02 20:34:12 +08:00
|
|
|
|
2020-05-24 13:57:21 +01:00
|
|
|
#if defined(LWS_WITH_UNIX_SOCK) && !defined(WIN32)
|
2019-03-25 08:07:28 +08:00
|
|
|
int
|
|
|
|
|
lws_plat_user_colon_group_to_ids(const char *u_colon_g, uid_t *puid, gid_t *pgid);
|
|
|
|
|
#endif
|
|
|
|
|
|
2020-04-23 22:28:25 +01:00
|
|
|
int
|
|
|
|
|
lws_plat_ntpclient_config(struct lws_context *context);
|
|
|
|
|
|
2019-09-27 14:32:59 -07:00
|
|
|
int
|
|
|
|
|
lws_plat_ifname_to_hwaddr(int fd, const char *ifname, uint8_t *hwaddr, int len);
|
|
|
|
|
|
2021-03-12 11:21:30 +05:30
|
|
|
int
|
|
|
|
|
lws_plat_vhost_tls_client_ctx_init(struct lws_vhost *vhost);
|
|
|
|
|
|
2020-09-06 11:46:25 +01:00
|
|
|
int
|
2018-10-09 10:29:42 +08:00
|
|
|
lws_check_byte_utf8(unsigned char state, unsigned char c);
|
2020-09-06 11:46:25 +01:00
|
|
|
int LWS_WARN_UNUSED_RESULT
|
2015-12-30 11:43:36 +08:00
|
|
|
lws_check_utf8(unsigned char *state, unsigned char *buf, size_t len);
|
2020-09-06 11:46:25 +01:00
|
|
|
int alloc_file(struct lws_context *context, const char *filename,
|
2018-11-23 08:47:56 +08:00
|
|
|
uint8_t **buf, lws_filepos_t *amount);
|
2017-10-18 09:41:44 +08:00
|
|
|
|
2021-07-13 05:18:04 +01:00
|
|
|
int
|
|
|
|
|
lws_lec_scratch(lws_lec_pctx_t *ctx);
|
|
|
|
|
void
|
|
|
|
|
lws_lec_signed(lws_lec_pctx_t *ctx, int64_t num);
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
lws_cose_key_checks(const lws_cose_key_t *key, int64_t kty, int64_t alg,
|
|
|
|
|
int key_op, const char *crv);
|
|
|
|
|
|
2020-06-25 14:44:05 +01:00
|
|
|
void lws_msleep(unsigned int);
|
|
|
|
|
|
2018-04-29 10:44:36 +08:00
|
|
|
void
|
|
|
|
|
lws_context_destroy2(struct lws_context *context);
|
2019-01-13 06:58:21 +08:00
|
|
|
|
2021-08-25 09:35:07 +01:00
|
|
|
/* it's public extern const lws_transport_client_ops_t lws_txp_inside_sspc; */
|
|
|
|
|
|
|
|
|
|
lws_transport_mux_ch_t *
|
|
|
|
|
lws_transport_mux_create_channel(lws_transport_mux_t *tm, lws_mux_ch_idx_t i);
|
|
|
|
|
|
|
|
|
|
lws_transport_mux_ch_t *
|
|
|
|
|
lws_transport_mux_add_channel(lws_transport_mux_t *tm, lws_transport_priv_t priv);
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
lws_transport_mux_destroy_channel(lws_transport_mux_ch_t **_mc);
|
|
|
|
|
|
|
|
|
|
lws_transport_mux_ch_t *
|
|
|
|
|
lws_transport_mux_get_channel(lws_transport_mux_t *tm, lws_mux_ch_idx_t i);
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
lws_transport_mux_next_free(lws_transport_mux_t *tm, lws_mux_ch_idx_t *result);
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
sul_ping_cb(lws_sorted_usec_list_t *sul);
|
|
|
|
|
|
2024-02-09 14:56:10 +05:30
|
|
|
/* Added Declaration of this function to make common for openssl-server */
|
|
|
|
|
#if defined(LWS_HAVE_SSL_CTX_set_keylog_callback) && \
|
|
|
|
|
defined(LWS_WITH_TLS)
|
|
|
|
|
void
|
|
|
|
|
lws_klog_dump(const SSL *ssl, const char *line);
|
|
|
|
|
#endif
|
|
|
|
|
|
2019-08-17 20:46:53 +01:00
|
|
|
#if !defined(PRIu64)
|
|
|
|
|
#define PRIu64 "llu"
|
|
|
|
|
#endif
|
2018-04-20 10:33:23 +08:00
|
|
|
|
2019-07-05 09:38:32 +01:00
|
|
|
#if defined(LWS_WITH_ABSTRACT)
|
|
|
|
|
#include "private-lib-abstract.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-11-02 20:34:12 +08:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
};
|
|
|
|
|
#endif
|
2019-09-19 10:15:56 +01:00
|
|
|
|
|
|
|
|
#endif
|