Mirrors/libwebsockets
1
0
Fork 0
mirror of https://github.com/warmcat/libwebsockets.git synced 2025-03-23 00:00:06 +01:00
Code Issues Releases Wiki Activity
libwebsockets/lib/core-net/private-lib-core-net.h

1593 lines
40 KiB
C
Raw Normal View History

LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/*
* libwebsockets - small server side websockets and web server implementation
*
* Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
*
license: switch LGPLv2.1+SLE parts to MIT
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:
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
*
license: switch LGPLv2.1+SLE parts to MIT
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.
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
*
license: switch LGPLv2.1+SLE parts to MIT
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.
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
*/
#if !defined(__LWS_CORE_NET_PRIVATE_H__)
#define __LWS_CORE_NET_PRIVATE_H__
rtos: clean warnings where uint32_t is an unsigned long
2019-06-07 11:11:46 +01:00
#if !defined(_POSIX_C_SOURCE)
#define _POSIX_C_SOURCE 200112L
#endif
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
/*
* Generic pieces needed to manage muxable stream protocols like h2
*/
struct lws_muxable {
struct lws *parent_wsi;
struct lws *child_list;
struct lws *sibling_list;
unsigned int my_sid;
unsigned int child_count;
client: MQTT Adds client support for MQTT QoS0 and QoS1, compatible with AWS IoT Supports stream binding where independent client connections to the same endpoint can mux on a single tcp + tls connection with topic routing managed internally.
2020-02-25 13:28:25 +00:00
uint32_t highest_sid;
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
uint8_t requested_POLLOUT;
};
private.h: rename to contain dir Having unique private header names is a requirement of a particular platform build system it's desirable to work with
2019-08-15 10:49:52 +01:00
#include "private-lib-roles.h"
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#ifdef __cplusplus
extern "C" {
#endif
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
#define __lws_sul_insert_us(owner, sul, _us) \
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
(sul)->us = lws_now_usecs() + (lws_usec_t)(_us); \
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
__lws_sul_insert(owner, sul)
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/*
*
* ------ roles ------
*
*/
/* null-terminated array of pointers to roles lws built with */
extern const struct lws_role_ops *available_roles[];
#define LWS_FOR_EVERY_AVAILABLE_ROLE_START(xx) { \
const struct lws_role_ops **ppxx = available_roles; \
while (*ppxx) { \
const struct lws_role_ops *xx = *ppxx++;
#define LWS_FOR_EVERY_AVAILABLE_ROLE_END }}
/*
*
* ------ event_loop ops ------
*
*/
/* enums of socks version */
enum socks_version {
SOCKS_VERSION_4 = 4,
SOCKS_VERSION_5 = 5
};
/* enums of subnegotiation version */
enum socks_subnegotiation_version {
SOCKS_SUBNEGOTIATION_VERSION_1 = 1,
};
/* enums of socks commands */
enum socks_command {
SOCKS_COMMAND_CONNECT = 1,
SOCKS_COMMAND_BIND = 2,
SOCKS_COMMAND_UDP_ASSOCIATE = 3
};
/* enums of socks address type */
enum socks_atyp {
SOCKS_ATYP_IPV4 = 1,
SOCKS_ATYP_DOMAINNAME = 3,
SOCKS_ATYP_IPV6 = 4
};
/* enums of socks authentication methods */
enum socks_auth_method {
SOCKS_AUTH_NO_AUTH = 0,
SOCKS_AUTH_GSSAPI = 1,
SOCKS_AUTH_USERNAME_PASSWORD = 2
};
/* enums of subnegotiation status */
enum socks_subnegotiation_status {
SOCKS_SUBNEGOTIATION_STATUS_SUCCESS = 0,
};
/* enums of socks request reply */
enum socks_request_reply {
SOCKS_REQUEST_REPLY_SUCCESS = 0,
SOCKS_REQUEST_REPLY_FAILURE_GENERAL = 1,
SOCKS_REQUEST_REPLY_CONNECTION_NOT_ALLOWED = 2,
SOCKS_REQUEST_REPLY_NETWORK_UNREACHABLE = 3,
SOCKS_REQUEST_REPLY_HOST_UNREACHABLE = 4,
SOCKS_REQUEST_REPLY_CONNECTION_REFUSED = 5,
SOCKS_REQUEST_REPLY_TTL_EXPIRED = 6,
SOCKS_REQUEST_REPLY_COMMAND_NOT_SUPPORTED = 7,
SOCKS_REQUEST_REPLY_ATYP_NOT_SUPPORTED = 8
};
/* enums used to generate socks messages */
enum socks_msg_type {
/* greeting */
SOCKS_MSG_GREETING,
/* credential, user name and password */
SOCKS_MSG_USERNAME_PASSWORD,
/* connect command */
SOCKS_MSG_CONNECT
};
enum {
LWS_RXFLOW_ALLOW = (1 << 0),
LWS_RXFLOW_PENDING_CHANGE = (1 << 1),
};
parsers: use common unaligned accessors
2019-09-11 06:34:52 +01:00
typedef enum lws_parser_return {
LPR_FORBIDDEN = -2,
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
LPR_FAIL = -1,
parsers: use common unaligned accessors
2019-09-11 06:34:52 +01:00
LPR_OK = 0,
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
LPR_DO_FALLBACK = 2,
parsers: use common unaligned accessors
2019-09-11 06:34:52 +01:00
} lws_parser_return_t;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
pmd: split ebufs to track in and out
2019-05-04 13:19:12 +01:00
enum pmd_return {
PMDR_UNKNOWN,
PMDR_DID_NOTHING,
PMDR_HAS_PENDING,
PMDR_EMPTY_NONFINAL,
PMDR_EMPTY_FINAL,
ws: reporting PONG with pmd enabled Add a return code NOTHING_WE_SHOULD_DO indicating that the extension determined by ext-specific means its operation was disabled on this frame. https://github.com/warmcat/libwebsockets/issues/2076
2020-10-08 14:06:43 +01:00
PMDR_NOTHING_WE_SHOULD_DO,
pmd: split ebufs to track in and out
2019-05-04 13:19:12 +01:00
PMDR_FAILED = -1
};
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if defined(LWS_WITH_PEER_LIMITS)
struct lws_peer {
struct lws_peer *next;
struct lws_peer *peer_wait_list;
PEER_LIMITS: modernize to sa46 and add notification cb There are a bunch of sa46-aware lws apis for formatting, etc sa46 in ./include/libwebsockets/lws-network-helper.h
2020-05-24 19:44:46 +01:00
lws_sockaddr46 sa46;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
time_t time_created;
time_t time_closed_all;
uint32_t hash;
uint32_t count_wsi;
uint32_t total_wsi;
#if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2)
struct lws_peer_role_http http;
#endif
};
#endif
enum {
LWS_EV_READ = (1 << 0),
LWS_EV_WRITE = (1 << 1),
LWS_EV_START = (1 << 2),
LWS_EV_STOP = (1 << 3),
LWS_EV_PREPARE_DELETION = (1u << 31),
};
#ifdef LWS_WITH_IPV6
#define LWS_IPV6_ENABLED(vh) \
(!lws_check_opt(vh->context->options, LWS_SERVER_OPTION_DISABLE_IPV6) && \
!lws_check_opt(vh->options, LWS_SERVER_OPTION_DISABLE_IPV6))
#else
#define LWS_IPV6_ENABLED(context) (0)
#endif
#ifdef LWS_WITH_UNIX_SOCK
#define LWS_UNIX_SOCK_ENABLED(vhost) \
(vhost->options & LWS_SERVER_OPTION_UNIX_SOCK)
#else
#define LWS_UNIX_SOCK_ENABLED(vhost) (0)
#endif
enum uri_path_states {
URIPS_IDLE,
URIPS_SEEN_SLASH,
URIPS_SEEN_SLASH_DOT,
URIPS_SEEN_SLASH_DOT_DOT,
};
enum uri_esc_states {
URIES_IDLE,
URIES_SEEN_PERCENT,
URIES_SEEN_PERCENT_H1,
};
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_CLIENT)
client: do client stash in a single alloc Improve the code around stash, getting rid of the strdups for a net code reduction. Remove the special destroy helper for stash since it becomes a one-liner. Trade several stack allocs in the client reset function for a single sized brief heap alloc to reduce peak stack alloc by around 700 bytes.
2019-08-17 20:46:53 +01:00
enum {
CIS_ADDRESS,
CIS_PATH,
CIS_HOST,
CIS_ORIGIN,
CIS_PROTOCOL,
CIS_METHOD,
CIS_IFACE,
CIS_ALPN,
CIS_COUNT
};
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
struct client_info_stash {
client: do client stash in a single alloc Improve the code around stash, getting rid of the strdups for a net code reduction. Remove the special destroy helper for stash since it becomes a one-liner. Trade several stack allocs in the client reset function for a single sized brief heap alloc to reduce peak stack alloc by around 700 bytes.
2019-08-17 20:46:53 +01:00
char *cis[CIS_COUNT];
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
void *opaque_user_data; /* not allocated or freed by lws */
};
#endif
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#if defined(LWS_WITH_UDP)
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#define lws_wsi_is_udp(___wsi) (!!___wsi->udp)
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#define LWS_H2_FRAME_HEADER_LENGTH 9
unify us sorted waits There are quite a few linked-lists of things that want events after some period. This introduces a type binding an lws_dll2 for the list and a lws_usec_t for the duration. The wsi timeouts, the hrtimer and the sequencer timeouts are converted to use these, also in the common event wait calculation.
2019-08-08 20:05:03 +01:00
lws_usec_t
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
__lws_sul_service_ripe(lws_dll2_owner_t *own, int num_own, lws_usec_t usnow);
#if defined(LWS_WITH_DEPRECATED_THINGS)
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
struct lws_timed_vh_protocol {
struct lws_timed_vh_protocol *next;
lws_sorted_usec_list_t sul;
const struct lws_protocols *protocol;
struct lws_vhost *vhost; /* only used for pending processing */
int reason;
int tsi_req;
};
unify us sorted waits There are quite a few linked-lists of things that want events after some period. This introduces a type binding an lws_dll2 for the list and a lws_usec_t for the duration. The wsi timeouts, the hrtimer and the sequencer timeouts are converted to use these, also in the common event wait calculation.
2019-08-08 20:05:03 +01:00
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
#endif
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
/*
* lws_async_dns
*/
typedef struct lws_async_dns {
lws_sockaddr46 sa46; /* nameserver */
lws_retry: udp support
2019-09-08 08:08:55 +01:00
lws_dll2_owner_t waiting;
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
lws_dll2_owner_t cached;
struct lws *wsi;
time_t time_set_server;
route: on change also check source address still extant
2021-02-05 13:08:41 +00:00
uint8_t dns_server_set:1;
uint8_t dns_server_connected:1;
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
} lws_async_dns_t;
typedef enum {
LADNS_CONF_SERVER_UNKNOWN = -1,
LADNS_CONF_SERVER_SAME,
LADNS_CONF_SERVER_CHANGED
} lws_async_dns_server_check_t;
#if defined(LWS_WITH_SYS_ASYNC_DNS)
void
lws_aysnc_dns_completed(struct lws *wsi, void *sa, size_t salen,
lws_async_dns_retcode_t ret);
#endif
void
lws_async_dns_cancel(struct lws *wsi);
route: on change also check source address still extant
2021-02-05 13:08:41 +00:00
void
lws_async_dns_drop_server(struct lws_context *context);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/*
* so we can have n connections being serviced simultaneously,
* these things need to be isolated per-thread.
*/
struct lws_context_per_thread {
#if LWS_MAX_SMP > 1
pthread_mutex_t lock_stats;
struct lws_mutex_refcount mr;
pthread_t self;
#endif
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
struct lws_dll2_owner dll_buflist_owner; /* guys with pending rxflow */
struct lws_dll2_owner seq_owner; /* list of lws_sequencer-s */
lws_system: helpers for attaching to existing event loop from other threads In the case code is composed into a single process, but it isn't monolithic in the sense it's made up of modular "applications" that are written separate projects, provide a way for the "applications" to request a callback from the lws event loop thread context safely. From the callback the applications can set up their operations on the lws event loop and drop their own thread. Since it requires system-specific locking to be threadsafe, provide a non-threadsafe helper and then indirect the actual usage through a user-defined lws_system ops function pointer that wraps the unsafe api with the system locking to make it safe.
2019-12-31 15:24:58 +00:00
lws_dll2_owner_t attach_owner; /* pending lws_attach */
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
client: secure streams Secure Streams is an optional layer on top of lws that separates policy like endpoint selection and tls cert validation into a device JSON policy document. Code that wants to open a client connection just specifies a streamtype name, and no longer deals with details like the endpoint, the protocol (!) or anything else other than payloads and optionally generic metadata; the JSON policy contains all the details for each streamtype. h1, h2, ws and mqtt client connections are supported. Logical secure streams outlive any particular connection and supports "nailed-up" connectivity regardless of underlying connection stability.
2020-02-29 12:37:24 +00:00
#if defined(LWS_WITH_SECURE_STREAMS)
lws_dll2_owner_t ss_owner;
#endif
#if defined(LWS_WITH_SECURE_STREAMS_PROXY_API) || \
defined(LWS_WITH_SECURE_STREAMS_THREAD_API)
lws_dll2_owner_t ss_dsh_owner;
lws_dll2_owner_t ss_client_owner;
#endif
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
struct lws_dll2_owner pt_sul_owner[LWS_COUNT_PT_SUL_OWNERS];
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
#if defined (LWS_WITH_SEQUENCER)
lws_sorted_usec_list_t sul_seq_heartbeat;
#endif
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if (defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2)) && defined(LWS_WITH_SERVER)
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
lws_sorted_usec_list_t sul_ah_lifecheck;
#endif
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_TLS) && defined(LWS_WITH_SERVER)
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
lws_sorted_usec_list_t sul_tls;
#endif
#if defined(LWS_PLAT_UNIX)
lws_sorted_usec_list_t sul_plat;
#endif
lws_validity: unified connection validity tracking Refactor everything around ping / pong handling in ws and h2, so there is instead a protocol-independent validity lws_sul tracking how long it has been since the last exchange that confirms the operation of the network connection in both directions. Clean out periodic role callback and replace the last two role users with discrete lws_sul for each pt.
2019-09-18 13:09:32 +01:00
#if defined(LWS_ROLE_CGI)
lws_sorted_usec_list_t sul_cgi;
#endif
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
#if defined(LWS_WITH_PEER_LIMITS)
lws_sorted_usec_list_t sul_peer_limits;
#endif
fakewsi: replace with smaller substructure Currently we always reserve a fakewsi per pt so events that don't have a related actual wsi, like vhost-protocol-init or vhost cert init via protocol callback can make callbacks that look reasonable to user protocol handler code expecting a valid wsi every time. This patch splits out stuff that user callbacks often unconditionally expect to be in a wsi, like context pointer, vhost pointer etc into a substructure, which is composed into struct lws at the top of it. Internal references (struct lws is opaque, so there are only internal references) are all updated to go via the substructre, the compiler should make that a NOP. Helpers are added when fakewsi is used and referenced. If not PLAT_FREERTOS, we continue to provide a full fakewsi in the pt as before, although the helpers improve consistency by zeroing down the substructure. There is a huge amount of user code out there over the last 10 years that did not always have the minimal examples to follow, some of it does some unexpected things. If it is PLAT_FREERTOS, that is a newer thing in lws and users have the benefit of being able to follow the minimal examples' approach. For PLAT_FREERTOS we don't reserve the fakewsi in the pt any more, saving around 800 bytes. The helpers then create a struct lws_a (the substructure) on the stack, zero it down (but it is only like 4 pointers) and prepare it with whatever we know like the context. Then we cast it to a struct lws * and use it in the user protocol handler call. In this case, the remainder of the struct lws is undefined. However the amount of old protocol handlers that might touch things outside of the substructure in PLAT_FREERTOS is very limited compared to legacy lws user code and the saving is significant on constrained devices. User handlers should not be touching everything in a wsi every time anyway, there are several cases where there is no valid wsi to do the call with. Dereference of things outside the substructure should only happen when the callback reason shows there is a valid wsi bound to the activity (as in all the minimal examples).
2020-07-19 08:33:46 +01:00
#if !defined(LWS_PLAT_FREERTOS)
struct lws *fake_wsi; /* used for callbacks where there's no wsi */
#endif
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
#if defined(LWS_WITH_TLS)
struct lws_pt_tls tls;
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
struct lws_context *context;
/*
* usable by anything in the service code, but only if the scope
* does not last longer than the service action (since next service
* of any socket can likewise use it and overwrite)
*/
unsigned char *serv_buf;
struct lws_pollfd *fds;
volatile struct lws_foreign_thread_pollfd * volatile foreign_pfd_list;
windows: migrate to WSAPoll Switch out the guts of the default window platform wait to use WSAPoll(), switch the lws_cancel_service() mechanism to use a UDP socket pair.
2020-12-05 05:01:55 +00:00
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_sockfd_type dummy_pipe_fds[2];
struct lws *pipe_wsi;
/* --- role based members --- */
#if defined(LWS_ROLE_WS) && !defined(LWS_WITHOUT_EXTENSIONS)
struct lws_pt_role_ws ws;
#endif
#if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2)
struct lws_pt_role_http http;
#endif
#if defined(LWS_ROLE_DBUS)
struct lws_pt_role_dbus dbus;
#endif
/* --- event library based members --- */
event libs: default to building as dynamically loaded plugins Event lib support as it has been isn't scaling well, at the low level libevent and libev headers have a namespace conflict so they can't both be built into the same image, and at the distro level, binding all the event libs to libwebsockets.so makes a bloaty situation for packaging, lws will drag in all the event libs every time. This patch implements the plan discussed here https://github.com/warmcat/libwebsockets/issues/1980 and refactors the event lib support so they are built into isolated plugins and bound at runtime according to what the application says it wants to use. The event lib plugins can be packaged individually so that only the needed sets of support are installed (perhaps none of them if the user code is OK with the default poll() loop). And dependent user code can mark the specific event loop plugin package as required so pieces are added as needed. The eventlib-foreign example is also refactored to build the selected lib support isolated. A readme is added detailing the changes and how to use them. https://libwebsockets.org/git/libwebsockets/tree/READMEs/README.event-libs.md
2020-08-27 15:37:14 +01:00
#if defined(LWS_WITH_EVENT_LIBS)
void *evlib_pt; /* overallocated */
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
/* --- */
unsigned long count_conns;
unsigned int fds_count;
/*
* set to the Thread ID that's doing the service loop just before entry
* to poll indicates service thread likely idling in poll()
* volatile because other threads may check it as part of processing
* for pollfd event change.
*/
volatile int service_tid;
int service_tid_detected;
context: refactor destroy flow
2020-11-16 19:32:58 +00:00
#if !defined(LWS_PLAT_FREERTOS)
int count_event_loop_static_asset_handles;
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
volatile unsigned char inside_poll;
volatile unsigned char foreign_spinlock;
unsigned char tid;
unsigned char inside_service:1;
event lib: update http client multi to work with it and clean destroy flow Add selectable event lib support to minimal-http-client-multi and clean up context destroy flow so we can use lws_destroy_context() from inside the callback to indicate we want to end the event loop, without using the traditional "interrupted" flag and in a way that works no matter which event loop backend is being used.
2020-01-23 11:12:28 +00:00
unsigned char inside_lws_service:1;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
unsigned char event_loop_foreign:1;
unsigned char event_loop_destroy_processing_done:1;
context: refactor destroy flow
2020-11-16 19:32:58 +00:00
unsigned char event_loop_pt_unused:1;
event lib: update http client multi to work with it and clean destroy flow Add selectable event lib support to minimal-http-client-multi and clean up context destroy flow so we can use lws_destroy_context() from inside the callback to indicate we want to end the event loop, without using the traditional "interrupted" flag and in a way that works no matter which event loop backend is being used.
2020-01-23 11:12:28 +00:00
unsigned char destroy_self:1;
unsigned char is_destroyed:1;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
};
/*
* virtual host -related context information
* vhostwide SSL context
* vhostwide proxy
*
* hierarchy:
*
* context -> vhost -> wsi
*
* incoming connection non-SSL vhost binding:
*
* listen socket -> wsi -> select vhost after first headers
*
* incoming connection SSL vhost binding:
*
* SSL SNI -> wsi -> bind after SSL negotiation
*/
struct lws_vhost {
debloat: remove things from being built by default that should be conditional
2019-08-18 06:29:34 +01:00
#if defined(LWS_WITH_CLIENT) && defined(LWS_CLIENT_HTTP_PROXYING)
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
char proxy_basic_auth_token[128];
#endif
#if LWS_MAX_SMP > 1
pthread_mutex_t lock;
char close_flow_vs_tsi[LWS_MAX_SMP];
#endif
#if defined(LWS_ROLE_H2)
struct lws_vhost_role_h2 h2;
#endif
#if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2)
struct lws_vhost_role_http http;
#endif
#if defined(LWS_ROLE_WS) && !defined(LWS_WITHOUT_EXTENSIONS)
struct lws_vhost_role_ws ws;
#endif
lws_lifecycle This adds some new objects and helpers for keeping and logging info on grouped allocations, a group is, eg, SS handles or client wsis. Allocated objects get a context-unique "tag" string intended to replace %p / wsi pointers etc. Pointers quickly become confusing when allocations are freed and reused, the tag string won't repeat until you produce 2^64 objects in a context. In addition the tag string documents the object group, with prefixes like "wsi-" or "vh-" and contain object-specific additional information like the vhost name, address / port or the role of the wsi. At creation time the lws code can use a format string and args to add whatever group-specific info makes sense, eg, a wsi bound to a secure stream can also append the guid of the secure stream, it's copied into the new object tag and so is still available cleanly after the stream is destroyed if the wsi outlives it.
2020-12-25 05:54:19 +00:00
lws_lifecycle_t lc;
vhost_destroy: refactor
2021-01-22 09:11:22 +00:00
lws_dll2_t vh_being_destroyed_list;
lws_lifecycle This adds some new objects and helpers for keeping and logging info on grouped allocations, a group is, eg, SS handles or client wsis. Allocated objects get a context-unique "tag" string intended to replace %p / wsi pointers etc. Pointers quickly become confusing when allocations are freed and reused, the tag string won't repeat until you produce 2^64 objects in a context. In addition the tag string documents the object group, with prefixes like "wsi-" or "vh-" and contain object-specific additional information like the vhost name, address / port or the role of the wsi. At creation time the lws code can use a format string and args to add whatever group-specific info makes sense, eg, a wsi bound to a secure stream can also append the guid of the secure stream, it's copied into the new object tag and so is still available cleanly after the stream is destroyed if the wsi outlives it.
2020-12-25 05:54:19 +00:00
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if defined(LWS_WITH_SOCKS5)
char socks_proxy_address[128];
char socks_user[96];
char socks_password[96];
#endif
tls: openssl-only: client-only: session caching
2021-03-25 08:37:36 +00:00
#if defined(LWS_WITH_TLS_SESSIONS)
lws_dll2_owner_t tls_sessions; /* vh lock */
#endif
event libs: default to building as dynamically loaded plugins Event lib support as it has been isn't scaling well, at the low level libevent and libev headers have a namespace conflict so they can't both be built into the same image, and at the distro level, binding all the event libs to libwebsockets.so makes a bloaty situation for packaging, lws will drag in all the event libs every time. This patch implements the plan discussed here https://github.com/warmcat/libwebsockets/issues/1980 and refactors the event lib support so they are built into isolated plugins and bound at runtime according to what the application says it wants to use. The event lib plugins can be packaged individually so that only the needed sets of support are installed (perhaps none of them if the user code is OK with the default poll() loop). And dependent user code can mark the specific event loop plugin package as required so pieces are added as needed. The eventlib-foreign example is also refactored to build the selected lib support isolated. A readme is added detailing the changes and how to use them. https://libwebsockets.org/git/libwebsockets/tree/READMEs/README.event-libs.md
2020-08-27 15:37:14 +01:00
#if defined(LWS_WITH_EVENT_LIBS)
void *evlib_vh; /* overallocated */
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
#if defined(LWS_WITH_SYS_METRICS)
lws_metric_t *mt_traffic_rx;
lws_metric_t *mt_traffic_tx;
debloat: remove things from being built by default that should be conditional
2019-08-18 06:29:34 +01:00
#endif
fault injection
2021-02-17 10:31:22 +00:00
#if defined(LWS_WITH_SYS_FAULT_INJECTION)
Fault injection add lws_xos: xoshiro256 PRNG
2021-03-16 13:32:05 +00:00
lws_fi_ctx_t fic;
fault injection
2021-02-17 10:31:22 +00:00
/**< Fault Injection ctx for the vhost, hierarchy vhost->context */
#endif
context-vhost options: move to uint64_t
2019-09-13 13:12:55 +01:00
uint64_t options;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
struct lws_context *context;
struct lws_vhost *vhost_next;
lws_validity: unified connection validity tracking Refactor everything around ping / pong handling in ws and h2, so there is instead a protocol-independent validity lws_sul tracking how long it has been since the last exchange that confirms the operation of the network connection in both directions. Clean out periodic role callback and replace the last two role users with discrete lws_sul for each pt.
2019-09-18 13:09:32 +01:00
const lws_retry_bo_t *retry_policy;
ss: server: h1, h2, ws basic support Add initial support for defining servers using Secure Streams policy and api semantics. Serving h1, h2 and ws should be functional, the new minimal example shows a combined http + SS server with an incrementing ws message shown in the browser over tls, in around 200 lines of user code. NOP out anything to do with plugins, they're not currently used. Update the docs correspondingly.
2020-07-27 10:03:12 +01:00
#if defined(LWS_WITH_SERVER) && defined(LWS_WITH_SECURE_STREAMS)
lws_ss_handle_t *ss_handle; /* ss handle for the server obj */
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
struct lws *lserv_wsi;
const char *name;
const char *iface;
const char *listen_accept_role;
const char *listen_accept_protocol;
unix skt: allow control over skt user:group If you're providing a unix socket service that will be proxied / served by another process on the same machine, the unix fd permissions on the listening unix socket fd have to be managed so only something running under the server credentials can open the listening unix socket.
2019-03-25 08:07:28 +08:00
const char *unix_socket_perms;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
void (*finalize)(struct lws_vhost *vh, void *arg);
void *finalize_arg;
const struct lws_protocols *protocols;
void **protocol_vh_privs;
const struct lws_protocol_vhost_options *pvo;
const struct lws_protocol_vhost_options *headers;
lws_dll: upgrade all instances to lws_dll2 lws_dll2 removes the downsides of lws_dll and adds new features like a running member count and explicit owner type... it's cleaner and more robust (eg, nodes know their owner, so they can casually switch between list owners and remove themselves without the code knowing the owner). This deprecates lws_dll, but since it's public it allows it to continue to be built for 4.0 release if you give cmake LWS_WITH_DEPRECATED_LWS_DLL. All remaining internal users of lws_dll are migrated to lws_dll2.
2019-08-08 16:58:55 +01:00
struct lws_dll2_owner *same_vh_protocol_owner;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
struct lws_vhost *no_listener_vhost_list;
abstract: existing connection compare
2019-07-05 09:38:32 +01:00
struct lws_dll2_owner abstract_instances_owner; /* vh lock */
abstract: allow completely generic instantiation and destruction
2019-06-22 06:59:49 +01:00
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_CLIENT)
lws_dll: upgrade all instances to lws_dll2 lws_dll2 removes the downsides of lws_dll and adds new features like a running member count and explicit owner type... it's cleaner and more robust (eg, nodes know their owner, so they can casually switch between list owners and remove themselves without the code knowing the owner). This deprecates lws_dll, but since it's public it allows it to continue to be built for 4.0 release if you give cmake LWS_WITH_DEPRECATED_LWS_DLL. All remaining internal users of lws_dll are migrated to lws_dll2.
2019-08-08 16:58:55 +01:00
struct lws_dll2_owner dll_cli_active_conns_owner;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
lws_retry: udp support
2019-09-08 08:08:55 +01:00
struct lws_dll2_owner vh_awaiting_socket_owner;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if defined(LWS_WITH_TLS)
struct lws_vhost_tls tls;
#endif
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
#if defined(LWS_WITH_DEPRECATED_THINGS)
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
struct lws_timed_vh_protocol *timed_vh_protocol_list;
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
void *user;
int listen_port;
freertos: rename esp32 plat to freertos
2019-08-18 10:35:43 +01:00
#if !defined(LWS_PLAT_FREERTOS) && !defined(OPTEE_TA) && !defined(WIN32)
debloat: remove things from being built by default that should be conditional
2019-08-18 06:29:34 +01:00
int bind_iface;
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if defined(LWS_WITH_SOCKS5)
unsigned int socks_proxy_port;
#endif
int count_protocols;
int ka_time;
int ka_probes;
int ka_interval;
int keepalive_timeout;
int timeout_secs_ah_idle;
client: allow setting overall connect timeout from vh init Add a member to the vh init struct allowing control of the overall connection wait introduced in an earlier patch. Set it to 20s by default. The timeout_secs member controls the individual DNS result connect timeout and is reduced to 5s by default.
2020-05-26 17:05:39 +01:00
int connect_timeout_secs;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
int count_bound_wsi;
#ifdef LWS_WITH_ACCESS_LOG
int log_fd;
#endif
tls: openssl-only: client-only: session caching
2021-03-25 08:37:36 +00:00
#if defined(LWS_WITH_TLS_SESSIONS)
uint32_t tls_session_cache_max;
#endif
ss: static policy: dynamic vhost instantiation Presently a vh is allocated per trust store at policy parsing-time, this is no problem on a linux-class device or if you decide you need a dynamic policy for functionality reasons. However if you're in a constrained enough situation that the static policy makes sense, in the case your trust stores do not have 100% duty cycle, ie, are anyway always in use, the currently-unused vhosts and their x.509 stack are sitting there taking up heap for no immediate benefit. This patch modifies behaviour in ..._STATIC_POLICY_ONLY so that vhosts and associated x.509 tls contexts are not instantiated until a secure stream using them is created; they are refcounted, and when the last logical secure stream using a vhost is destroyed, the vhost and its tls context is also destroyed. If another ss connection is created that wants to use the trust store, the vhost and x.509 context is regenerated again as needed. Currently the refcounting is by ss, it's also possible to move the refcounting to be by connection. The choice is between the delay to generate the vh being visisble at logical ss creation-time, or at connection-time. It's anyway not preferable to have ss instantiated and taking up space with no associated connection or connection attempt underway. NB you will need to reprocess any static policies after this patch so they conform to the trust_store changes.
2020-07-20 07:28:28 +01:00
#if defined(LWS_WITH_SECURE_STREAMS_STATIC_POLICY_ONLY)
int8_t ss_refcount;
/**< refcount of number of ss connections with streamtypes using this
* trust store */
#endif
client: secure streams Secure Streams is an optional layer on top of lws that separates policy like endpoint selection and tls cert validation into a device JSON policy document. Code that wants to open a client connection just specifies a streamtype name, and no longer deals with details like the endpoint, the protocol (!) or anything else other than payloads and optionally generic metadata; the JSON policy contains all the details for each streamtype. h1, h2, ws and mqtt client connections are supported. Logical secure streams outlive any particular connection and supports "nailed-up" connectivity regardless of underlying connection stability.
2020-02-29 12:37:24 +00:00
uint8_t allocated_vhost_protocols:1;
uint8_t created_vhost_protocols:1;
uint8_t being_destroyed:1;
uint8_t from_ss_policy:1;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
unsigned char default_protocol_index;
unsigned char raw_protocol_index;
};
void
__lws_vhost_destroy2(struct lws_vhost *vh);
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
#define mux_to_wsi(_m) lws_container_of(_m, struct lws, mux)
void
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
lws_wsi_mux_insert(struct lws *wsi, struct lws *parent_wsi, unsigned int sid);
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
int
lws_wsi_mux_mark_parents_needing_writeable(struct lws *wsi);
struct lws *
lws_wsi_mux_move_child_to_tail(struct lws **wsi2);
int
lws_wsi_mux_action_pending_writeable_reqs(struct lws *wsi);
void
lws_wsi_mux_dump_children(struct lws *wsi);
void
lws_wsi_mux_close_children(struct lws *wsi, int reason);
void
lws_wsi_mux_sibling_disconnect(struct lws *wsi);
void
lws_wsi_mux_dump_waiting_children(struct lws *wsi);
int
lws_wsi_mux_apply_queue(struct lws *wsi);
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
/*
* struct lws
*/
fakewsi: replace with smaller substructure Currently we always reserve a fakewsi per pt so events that don't have a related actual wsi, like vhost-protocol-init or vhost cert init via protocol callback can make callbacks that look reasonable to user protocol handler code expecting a valid wsi every time. This patch splits out stuff that user callbacks often unconditionally expect to be in a wsi, like context pointer, vhost pointer etc into a substructure, which is composed into struct lws at the top of it. Internal references (struct lws is opaque, so there are only internal references) are all updated to go via the substructre, the compiler should make that a NOP. Helpers are added when fakewsi is used and referenced. If not PLAT_FREERTOS, we continue to provide a full fakewsi in the pt as before, although the helpers improve consistency by zeroing down the substructure. There is a huge amount of user code out there over the last 10 years that did not always have the minimal examples to follow, some of it does some unexpected things. If it is PLAT_FREERTOS, that is a newer thing in lws and users have the benefit of being able to follow the minimal examples' approach. For PLAT_FREERTOS we don't reserve the fakewsi in the pt any more, saving around 800 bytes. The helpers then create a struct lws_a (the substructure) on the stack, zero it down (but it is only like 4 pointers) and prepare it with whatever we know like the context. Then we cast it to a struct lws * and use it in the user protocol handler call. In this case, the remainder of the struct lws is undefined. However the amount of old protocol handlers that might touch things outside of the substructure in PLAT_FREERTOS is very limited compared to legacy lws user code and the saving is significant on constrained devices. User handlers should not be touching everything in a wsi every time anyway, there are several cases where there is no valid wsi to do the call with. Dereference of things outside the substructure should only happen when the callback reason shows there is a valid wsi bound to the activity (as in all the minimal examples).
2020-07-19 08:33:46 +01:00
/*
* These pieces are very commonly used (via accessors) in user protocol handlers
* and have to be valid, even in the case no real wsi is available for the cb.
*
* We put all this category of pointers in there and compose it at the top of
* struct lws, so a dummy wsi providing these only needs to be this big, while
* still being castable for being a struct wsi *
*/
struct lws_a {
struct lws_context *context;
struct lws_vhost *vhost;
const struct lws_protocols *protocol;
void *opaque_user_data;
};
/*
* For RTOS-class platforms, their code is relatively new, post-minimal examples
* and tend to not have legacy user protocol handler baggage touching unexpected
* things in fakewsi unconditionally... we can use an lws_a on the stack and
* don't need to define the rest of the wsi content, just cast it, this saves
* a wsi footprint in heap (typ 800 bytes nowadays even on RTOS).
*
* For other platforms that have been around for years and have thousands of
* different user protocol handler implementations, it's likely some of them
* will be touching the struct lws content unconditionally in the handler even
* when we are calling back with a non wsi-specific reason, and may react badly
* to it being garbage. So continue to implement those as a full, zero-ed down
* prepared fakewsi on heap at context creation time.
*/
#if defined(LWS_PLAT_FREERTOS)
#define lws_fakewsi_def_plwsa(pt) struct lws_a lwsa, *plwsa = &lwsa
#else
#define lws_fakewsi_def_plwsa(pt) struct lws_a *plwsa = &(pt)->fake_wsi->a
#endif
/* since we reuse the pt version, also correct to zero down the lws_a part */
#define lws_fakewsi_prep_plwsa_ctx(_c) \
memset(plwsa, 0, sizeof(*plwsa)); plwsa->context = _c
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
struct lws {
fakewsi: replace with smaller substructure Currently we always reserve a fakewsi per pt so events that don't have a related actual wsi, like vhost-protocol-init or vhost cert init via protocol callback can make callbacks that look reasonable to user protocol handler code expecting a valid wsi every time. This patch splits out stuff that user callbacks often unconditionally expect to be in a wsi, like context pointer, vhost pointer etc into a substructure, which is composed into struct lws at the top of it. Internal references (struct lws is opaque, so there are only internal references) are all updated to go via the substructre, the compiler should make that a NOP. Helpers are added when fakewsi is used and referenced. If not PLAT_FREERTOS, we continue to provide a full fakewsi in the pt as before, although the helpers improve consistency by zeroing down the substructure. There is a huge amount of user code out there over the last 10 years that did not always have the minimal examples to follow, some of it does some unexpected things. If it is PLAT_FREERTOS, that is a newer thing in lws and users have the benefit of being able to follow the minimal examples' approach. For PLAT_FREERTOS we don't reserve the fakewsi in the pt any more, saving around 800 bytes. The helpers then create a struct lws_a (the substructure) on the stack, zero it down (but it is only like 4 pointers) and prepare it with whatever we know like the context. Then we cast it to a struct lws * and use it in the user protocol handler call. In this case, the remainder of the struct lws is undefined. However the amount of old protocol handlers that might touch things outside of the substructure in PLAT_FREERTOS is very limited compared to legacy lws user code and the saving is significant on constrained devices. User handlers should not be touching everything in a wsi every time anyway, there are several cases where there is no valid wsi to do the call with. Dereference of things outside the substructure should only happen when the callback reason shows there is a valid wsi bound to the activity (as in all the minimal examples).
2020-07-19 08:33:46 +01:00
struct lws_a a;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/* structs */
#if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct _lws_http_mode_related http;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
#if defined(LWS_ROLE_H2)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct _lws_h2_related h2;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
#if defined(LWS_ROLE_WS)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct _lws_websocket_related *ws; /* allocated if we upgrade to ws */
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
#if defined(LWS_ROLE_DBUS)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct _lws_dbus_mode_related dbus;
#endif
client: MQTT Adds client support for MQTT QoS0 and QoS1, compatible with AWS IoT Supports stream binding where independent client connections to the same endpoint can mux on a single tcp + tls connection with topic routing managed internally.
2020-02-25 13:28:25 +00:00
#if defined(LWS_ROLE_MQTT)
struct _lws_mqtt_related *mqtt;
#endif
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
client: MQTT Adds client support for MQTT QoS0 and QoS1, compatible with AWS IoT Supports stream binding where independent client connections to the same endpoint can mux on a single tcp + tls connection with topic routing managed internally.
2020-02-25 13:28:25 +00:00
#if defined(LWS_ROLE_H2) || defined(LWS_ROLE_MQTT)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws_muxable mux;
h2: LCCSCF_H2_MANUAL_RXFLOW and refactor txcr This changes the approach of tx credit management to set the initial stream tx credit window to zero. This is the only way with RFC7540 to gain the ability to selectively precisely rx flow control incoming streams. At the time the headers are sent, a WINDOW_UPDATE is sent with the initial tx credit towards us for that specific stream. By default, this acts as before with a 256KB window added for both the stream and the nwsi, and additional window management sent as stuff is received. It's now also possible to set a member in the client info struct and a new option LCCSCF_H2_MANUAL_RXFLOW to precisely manage both the initial tx credit for a specific stream and the ongoing rate limit by meting out further tx credit manually. Add another minimal example http-client-h2-rxflow demonstrating how to force a connection's peer's initial budget to transmit to us and control it during the connection lifetime to restrict the amount of incoming data we have to buffer.
2019-12-26 02:35:41 +00:00
struct lws_tx_credit txc;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
lws_lifecycle This adds some new objects and helpers for keeping and logging info on grouped allocations, a group is, eg, SS handles or client wsis. Allocated objects get a context-unique "tag" string intended to replace %p / wsi pointers etc. Pointers quickly become confusing when allocations are freed and reused, the tag string won't repeat until you produce 2^64 objects in a context. In addition the tag string documents the object group, with prefixes like "wsi-" or "vh-" and contain object-specific additional information like the vhost name, address / port or the role of the wsi. At creation time the lws code can use a format string and args to add whatever group-specific info makes sense, eg, a wsi bound to a secure stream can also append the guid of the secure stream, it's copied into the new object tag and so is still available cleanly after the stream is destroyed if the wsi outlives it.
2020-12-25 05:54:19 +00:00
lws_lifecycle_t lc;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/* lifetime members */
event libs: default to building as dynamically loaded plugins Event lib support as it has been isn't scaling well, at the low level libevent and libev headers have a namespace conflict so they can't both be built into the same image, and at the distro level, binding all the event libs to libwebsockets.so makes a bloaty situation for packaging, lws will drag in all the event libs every time. This patch implements the plan discussed here https://github.com/warmcat/libwebsockets/issues/1980 and refactors the event lib support so they are built into isolated plugins and bound at runtime according to what the application says it wants to use. The event lib plugins can be packaged individually so that only the needed sets of support are installed (perhaps none of them if the user code is OK with the default poll() loop). And dependent user code can mark the specific event loop plugin package as required so pieces are added as needed. The eventlib-foreign example is also refactored to build the selected lib support isolated. A readme is added detailing the changes and how to use them. https://libwebsockets.org/git/libwebsockets/tree/READMEs/README.event-libs.md
2020-08-27 15:37:14 +01:00
#if defined(LWS_WITH_EVENT_LIBS)
void *evlib_wsi; /* overallocated */
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
lws_sorted_usec_list_t sul_timeout;
lws_sorted_usec_list_t sul_hrtimer;
lws_sorted_usec_list_t sul_validity;
connect: enforce timeout for connect async wait This patch allows client connections to recover from a nonresponsive (ie, does not complete connect()) peer and continue to try subsequent DNS results.
2020-05-11 09:07:45 +01:00
lws_sorted_usec_list_t sul_connect_timeout;
lws_validity: unified connection validity tracking Refactor everything around ping / pong handling in ws and h2, so there is instead a protocol-independent validity lws_sul tracking how long it has been since the last exchange that confirms the operation of the network connection in both directions. Clean out periodic role callback and replace the last two role users with discrete lws_sul for each pt.
2019-09-18 13:09:32 +01:00
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws_dll2 dll_buflist; /* guys with pending rxflow */
struct lws_dll2 same_vh_protocol;
struct lws_dll2 vh_awaiting_socket;
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
#if defined(LWS_WITH_SYS_ASYNC_DNS)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws_dll2 adns; /* on adns list of guys to tell result */
lws_async_dns_cb_t adns_cb; /* callback with result */
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
#endif
#if defined(LWS_WITH_CLIENT)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws_dll2 dll_cli_active_conns;
struct lws_dll2 dll2_cli_txn_queue;
struct lws_dll2_owner dll2_cli_txn_queue_owner;
client: rfc6724 dns results sorting RFC6724 defines an ipv6-centric DNS result sorting algorithm, that takes route and source address route information for the results given by the DNS resolution, and sorts them in order of preferability, which defines the order they should be tried in. If LWS_WITH_NETLINK, then lws takes care about collecting and monitoring the interface, route and source address information, and uses it to perform the RFC6724 sorting to re-sort the DNS before trying to make the connections.
2020-09-20 09:14:46 +01:00
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
/**< caliper is reused for tcp, tls and txn conn phases */
client: rfc6724 dns results sorting RFC6724 defines an ipv6-centric DNS result sorting algorithm, that takes route and source address route information for the results given by the DNS resolution, and sorts them in order of preferability, which defines the order they should be tried in. If LWS_WITH_NETLINK, then lws takes care about collecting and monitoring the interface, route and source address information, and uses it to perform the RFC6724 sorting to re-sort the DNS before trying to make the connections.
2020-09-20 09:14:46 +01:00
lws_dll2_t speculative_list;
lws_dll2_owner_t speculative_connect_owner;
/* wsis: additional connection candidates */
lws_dll2_owner_t dns_sorted_list;
/* lws_dns_sort_t: dns results wrapped and sorted in a linked-list...
* deleted as they are tried, list empty == everything tried */
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
#endif
adopt: improve logging of server adopt fail This is usually something that either couldn't negotate tls at all or compatible tls parameters. Log the vhost it came in on and the IP.
2019-10-13 18:08:28 +01:00
fault injection
2021-02-17 10:31:22 +00:00
#if defined(LWS_WITH_SYS_FAULT_INJECTION)
Fault injection add lws_xos: xoshiro256 PRNG
2021-03-16 13:32:05 +00:00
lws_fi_ctx_t fic;
fault injection
2021-02-17 10:31:22 +00:00
/**< Fault Injection ctx for the wsi, hierarchy wsi->vhost->context */
#endif
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
#if defined(LWS_WITH_SYS_METRICS)
lws_metrics_caliper_compose(cal_conn)
#endif
route: on change also check source address still extant
2021-02-05 13:08:41 +00:00
lws_sockaddr46 sa46_local;
wsi: store peer lws_sockaddr46 If we connect out to an IP address, or we adopt a connected socket, from now on we want to hold the peer sockaddr in the wsi. Adapt ACCESS_LOG to use this new copy rather than keep the stringified version.
2020-10-05 06:15:10 +01:00
lws_sockaddr46 sa46_peer;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/* pointers */
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws *parent; /* points to parent, if any */
struct lws *child_list; /* points to first child */
struct lws *sibling_list; /* subsequent children at same level */
const struct lws_role_ops *role_ops;
struct lws_sequencer *seq; /* associated sequencer if any */
const lws_retry_bo_t *retry_policy;
lws_sequencer_t: allow wsi binding
2019-07-22 14:02:00 -07:00
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if defined(LWS_WITH_THREADPOOL)
threadpool: allow multiple threadpool tasks to bind to same wsi
2020-04-04 10:47:11 +01:00
lws_dll2_owner_t tp_task_owner; /* struct lws_threadpool_task */
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
#if defined(LWS_WITH_PEER_LIMITS)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws_peer *peer;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#if defined(LWS_WITH_UDP)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws_udp *udp;
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#endif
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_CLIENT)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct client_info_stash *stash;
char *cli_hostname_copy;
lws_conmon: connection monitoring and stats generation This provides a build option LWS_WITH_CONMON that lets user code recover detailed connection stats on client connections with the LCCSCF_CONMON flag. In addition to latencies for dns, socket connection, tls and first protocol response where possible, it also provides the user code an unfiltered list of DNS responses that the client received, and the peer it actually succeded to connect to.
2021-03-15 05:20:15 +00:00
#if defined(LWS_WITH_CONMON)
struct lws_conmon conmon;
lws_usec_t conmon_datum;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
lws_conmon: connection monitoring and stats generation This provides a build option LWS_WITH_CONMON that lets user code recover detailed connection stats on client connections with the LCCSCF_CONMON flag. In addition to latencies for dns, socket connection, tls and first protocol response where possible, it also provides the user code an unfiltered list of DNS responses that the client received, and the peer it actually succeded to connect to.
2021-03-15 05:20:15 +00:00
#endif /* WITH_CLIENT */
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
void *user_space;
void *opaque_parent_data;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws_buflist *buflist; /* input-side buflist */
struct lws_buflist *buflist_out; /* output-side buflist */
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if defined(LWS_WITH_TLS)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
struct lws_lws_tls tls;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
lws_sock_file_fd_type desc; /* .filefd / .sockfd */
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
lws_wsi_state_t wsistate;
lws_wsi_state_t wsistate_pre_close;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/* ints */
#define LWS_NO_FDS_POS (-1)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
int position_in_fds_table;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_CLIENT)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
int chunk_remaining;
int flags;
#endif
unsigned int cache_secs;
unsigned int hdr_parsing_completed:1;
unsigned int mux_substream:1;
unsigned int upgraded_to_http2:1;
unsigned int mux_stream_immortal:1;
unsigned int h2_stream_carries_ws:1; /* immortal set as well */
unsigned int h2_stream_carries_sse:1; /* immortal set as well */
unsigned int h2_acked_settings:1;
unsigned int seen_nonpseudoheader:1;
unsigned int listener:1;
unsigned int pf_packet:1;
unsigned int do_broadcast:1;
unsigned int user_space_externally_allocated:1;
unsigned int socket_is_permanently_unusable:1;
unsigned int rxflow_change_to:2;
unsigned int conn_stat_done:1;
unsigned int cache_reuse:1;
unsigned int cache_revalidate:1;
unsigned int cache_intermediaries:1;
unsigned int favoured_pollin:1;
unsigned int sending_chunked:1;
unsigned int interpreting:1;
unsigned int already_did_cce:1;
unsigned int told_user_closed:1;
unsigned int told_event_loop_closed:1;
unsigned int waiting_to_send_close_frame:1;
unsigned int close_needs_ack:1;
unsigned int ipv6:1;
unsigned int parent_pending_cb_on_writable:1;
unsigned int cgi_stdout_zero_length:1;
unsigned int seen_zero_length_recv:1;
unsigned int rxflow_will_be_applied:1;
unsigned int event_pipe:1;
unsigned int handling_404:1;
unsigned int protocol_bind_balance:1;
unsigned int unix_skt:1;
unsigned int close_when_buffered_out_drained:1;
unsigned int h1_ws_proxied:1;
unsigned int proxied_ws_parent:1;
unsigned int do_bind:1;
unsigned int validity_hup:1;
fallback: dont check after first ssl accept attempt
2020-03-06 10:16:12 +00:00
unsigned int skip_fallback:1;
lws_spawn: windows Move the unix spawn.c from lib/misc through to lib/plat/unix, and add an implementation for windows in lib/plat/windows
2020-04-07 06:35:00 +01:00
unsigned int file_desc:1;
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
unsigned int conn_validity_wakesuspend:1;
cpd: trigger if getaddrinfo failed If getaddrinfo() is not able to reach the server, there may be a connectivity problem downstream of the device that has not been recognized by the Captive Portal Detect pieces yet. If it looks like that might have happened, used the getaddrinfo() return to provoke a new CPD scan.
2020-12-21 15:44:30 +00:00
unsigned int dns_reachability:1;
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
unsigned int could_have_pending:1; /* detect back-to-back writes */
unsigned int outer_will_close:1;
unsigned int shadow:1; /* we do not control fd lifecycle at all */
ss: server: make sure failures after adopt invalidate ss copy of wsi For server, if the adoption of the incoming connection proceeds but then fails early on, eg, tls alert due to hostname mismatch with cert, the wsi close happens but it doesn't clean up the invalidated reference to itself in the server ss object... if it became established, that's handled by the ss protocol callback. This patch helps the close path to understand there is a related ss object and to clean up after itself.
2020-09-13 10:56:53 +01:00
#if defined(LWS_WITH_SECURE_STREAMS)
unsigned int for_ss:1;
ss: enforce balanced CONNECT vs DISCONNECT
2020-12-27 16:05:48 +00:00
unsigned int bound_ss_proxy_conn:1;
unsigned int client_bound_sspc:1;
sspc: cleanup bridged wsi
2020-12-27 19:34:30 +00:00
unsigned int client_proxy_onward:1;
ss: server: make sure failures after adopt invalidate ss copy of wsi For server, if the adoption of the incoming connection proceeds but then fails early on, eg, tls alert due to hostname mismatch with cert, the wsi close happens but it doesn't clean up the invalidated reference to itself in the server ss object... if it became established, that's handled by the ss protocol callback. This patch helps the close path to understand there is a related ss object and to clean up after itself.
2020-09-13 10:56:53 +01:00
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#ifdef LWS_WITH_ACCESS_LOG
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
unsigned int access_log_pending:1;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_CLIENT)
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
unsigned int do_ws:1; /* whether we are doing http or ws flow */
unsigned int chunked:1; /* if the clientside connection is chunked */
unsigned int client_rx_avail:1;
unsigned int client_http_body_pending:1;
unsigned int transaction_from_pipeline_queue:1;
unsigned int keepalive_active:1;
unsigned int keepalive_rejected:1;
unsigned int redirected_to_get:1;
unsigned int client_pipeline:1;
unsigned int client_h2_alpn:1;
unsigned int client_mux_substream:1;
unsigned int client_mux_migrated:1;
cleaning
2020-01-02 08:32:23 +00:00
unsigned int client_subsequent_mime_part:1;
http client: add flag to disable redir follow
2020-01-21 13:27:36 +00:00
unsigned int client_no_follow_redirect:1;
client: suppress CONNECTION_ERROR if still in client_connect_via_info If the client connection attempt fails early, we report it will a NULL return from the client connection api. If it fails later, perhaps after more times around the event loop, we report it as a CONNECTION_ERROR. This patch makes sure we don't do CONNECTION_ERROR flow if in fact we are still in the client_connect_via_info() and in a position to report the failure by returning NULL from there, without it under some conditions we will do both a CONNECTION_ERROR and return NULL.
2020-06-26 09:58:20 +01:00
unsigned int client_suppress_CONNECTION_ERROR:1;
/**< because the client connection creation api is still the parent of
* this activity, and will report the failure */
tls: openssl-only: client-only: session caching
2021-03-25 08:37:36 +00:00
unsigned int tls_session_reused:1;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
#ifdef _WIN32
unsigned int sock_send_blocking:1;
#endif
netlink: migrate to context For SMP case, it was desirable to have a netlink listener per pt so they could deal with pt-level changes in the pt's local service thread. But Linux restricts the process to just one netlink listener. We worked around it by only listening on pt[0], this aligns us a bit more with the reality and moves to a single routing table in the context. There's still more to do for SMP case locking.
2021-03-07 09:44:29 +00:00
uint16_t ocport, c_port, conn_port;
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
uint16_t retry;
client: allow setting keep warm time Until now if the generic transaction completes and the connection is idle, there's a fixed 5s grace period to keep the connection up in case something else wants it. This allows setting it in the client creation info struct .keep_warm_secs. If left at 0, then it maintains the backward-compatible 5s wait.
2020-05-06 07:53:41 +01:00
#if defined(LWS_WITH_CLIENT)
uint16_t keep_warm_secs;
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/* chars */
char lws_rx_parse_state; /* enum lws_rx_parse_state */
char rx_frame_type; /* enum lws_write_protocol */
char pending_timeout; /* enum pending_timeout */
char tsi; /* thread service index we belong to */
char protocol_interpret_idx;
char redirects;
uint8_t rxflow_bitmap;
lws_dll: remove lws_dll_lws and deprecate lws_dll_remove
2019-03-20 07:39:55 +08:00
uint8_t bound_vhost_index;
lws_spawn_piped: break out from cgi The vfork optimized spawn, stdxxx and terminal handling in the cgi implementation is quite mature and sophisticated, and useful for other things unrelated to cgi. Break it out into its own public api under LWS_WITH_SPAWN, off by default. Expand it so the parent wsi is optional, and the role and protocol bindings for stdxxx pipes can be set. Allow optional sul timeout and external lws_dll2 owner for extant children. Remove inline style from minimal http-server-cgi
2020-02-12 10:12:39 +00:00
uint8_t lsp_channel; /* which of stdin/out/err */
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#ifdef LWS_WITH_CGI
char hdr_state;
#endif
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_CLIENT)
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
char chunk_parser; /* enum lws_chunk_parser */
client: iterate connection attempts through addrinfo list
2019-09-16 04:12:45 +01:00
uint8_t addrinfo_idx;
tls: lws_system per-connection client certs Now the generic lws_system blobs can cover client certs + key, let's add support for applying one of the blob sets to a specific client connection (rather than doing it via the vhost).
2019-12-08 03:04:03 +00:00
uint8_t sys_tls_client_cert;
ip tos support
2021-02-04 09:08:17 +00:00
uint8_t c_pri;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_CGI) || defined(LWS_WITH_CLIENT)
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
char reason_bf; /* internal writeable callback reason bitfield */
#endif
roles: netlink This creates a role for RFC3549 Netlink monitoring. If the OS supports it (currently, linux) then each pt creates a wsi with the netlink role and dumps the current routing table at pt init. It then maintains a cache of the routing table in each pt. Upon routing table changes an SMD message is issued as an event, and Captive Portal Detection is triggered. All of the pt's current connections are reassessed for routability under the changed routing table, those that no longer have a valid route or gateway are closed.
2020-10-04 07:28:41 +01:00
#if defined(LWS_WITH_NETLINK)
lws_route_uidx_t peer_route_uidx;
/**< unique index of the route the connection is estimated to take */
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#endif
lws_http_mark_sse https://github.com/warmcat/libwebsockets/issues/1486
2019-01-30 20:59:56 +08:00
uint8_t immortal_substream_count;
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
/* volatile to make sure code is aware other thread can change */
volatile char handling_pollout;
volatile char leave_pollout_active;
smp: adopt: deal with load balancing init window With SMP as soon as we add the new sockfd to the fds table, in the case we load-balanced the fd on to a different pt, service on it becomes live immediately and concurrently. This can lead to the unexpected situation that while we think we're still initing the new wsi from our thread, it can have lived out its whole life concurrently from another service thread. Add a volatile flag to inform the owning pt that if it wants to service the wsi during this init window, it must wait and retry next time around the event loop.
2019-02-23 05:41:30 +08:00
#if LWS_MAX_SMP > 1
volatile char undergoing_init_from_other_pt;
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
};
#define lws_is_flowcontrolled(w) (!!(wsi->rxflow_bitmap))
lws_spawn_piped: break out from cgi The vfork optimized spawn, stdxxx and terminal handling in the cgi implementation is quite mature and sophisticated, and useful for other things unrelated to cgi. Break it out into its own public api under LWS_WITH_SPAWN, off by default. Expand it so the parent wsi is optional, and the role and protocol bindings for stdxxx pipes can be set. Allow optional sul timeout and external lws_dll2 owner for extant children. Remove inline style from minimal http-server-cgi
2020-02-12 10:12:39 +00:00
#if defined(LWS_WITH_SPAWN)
#if defined(WIN32) || defined(_WIN32)
#else
#include <sys/wait.h>
#include <sys/times.h>
#endif
struct lws_spawn_piped {
struct lws_spawn_piped_info info;
struct lws_dll2 dll;
lws_sorted_usec_list_t sul;
fds: add sanity checks
2020-05-04 07:24:58 +01:00
lws_sorted_usec_list_t sul_reap;
lws_spawn_piped: break out from cgi The vfork optimized spawn, stdxxx and terminal handling in the cgi implementation is quite mature and sophisticated, and useful for other things unrelated to cgi. Break it out into its own public api under LWS_WITH_SPAWN, off by default. Expand it so the parent wsi is optional, and the role and protocol bindings for stdxxx pipes can be set. Allow optional sul timeout and external lws_dll2 owner for extant children. Remove inline style from minimal http-server-cgi
2020-02-12 10:12:39 +00:00
lws_spawn: windows Move the unix spawn.c from lib/misc through to lib/plat/unix, and add an implementation for windows in lib/plat/windows
2020-04-07 06:35:00 +01:00
struct lws_context *context;
lws_spawn_piped: break out from cgi The vfork optimized spawn, stdxxx and terminal handling in the cgi implementation is quite mature and sophisticated, and useful for other things unrelated to cgi. Break it out into its own public api under LWS_WITH_SPAWN, off by default. Expand it so the parent wsi is optional, and the role and protocol bindings for stdxxx pipes can be set. Allow optional sul timeout and external lws_dll2 owner for extant children. Remove inline style from minimal http-server-cgi
2020-02-12 10:12:39 +00:00
struct lws *stdwsi[3];
lws_spawn: windows Move the unix spawn.c from lib/misc through to lib/plat/unix, and add an implementation for windows in lib/plat/windows
2020-04-07 06:35:00 +01:00
lws_filefd_type pipe_fds[3][2];
lws_spawn_piped: break out from cgi The vfork optimized spawn, stdxxx and terminal handling in the cgi implementation is quite mature and sophisticated, and useful for other things unrelated to cgi. Break it out into its own public api under LWS_WITH_SPAWN, off by default. Expand it so the parent wsi is optional, and the role and protocol bindings for stdxxx pipes can be set. Allow optional sul timeout and external lws_dll2 owner for extant children. Remove inline style from minimal http-server-cgi
2020-02-12 10:12:39 +00:00
int count_log_lines;
lws_usec_t created; /* set by lws_spawn_piped() */
lws_usec_t reaped;
lws_usec_t accounting[4];
lws_spawn: windows Move the unix spawn.c from lib/misc through to lib/plat/unix, and add an implementation for windows in lib/plat/windows
2020-04-07 06:35:00 +01:00
#if defined(WIN32)
HANDLE child_pid;
lws_sorted_usec_list_t sul_poll;
#else
lws_spawn_piped: break out from cgi The vfork optimized spawn, stdxxx and terminal handling in the cgi implementation is quite mature and sophisticated, and useful for other things unrelated to cgi. Break it out into its own public api under LWS_WITH_SPAWN, off by default. Expand it so the parent wsi is optional, and the role and protocol bindings for stdxxx pipes can be set. Allow optional sul timeout and external lws_dll2 owner for extant children. Remove inline style from minimal http-server-cgi
2020-02-12 10:12:39 +00:00
pid_t child_pid;
siginfo_t si;
lws_spawn: windows Move the unix spawn.c from lib/misc through to lib/plat/unix, and add an implementation for windows in lib/plat/windows
2020-04-07 06:35:00 +01:00
#endif
spawn: retry when last stdwsi close may not be immediately followed by reapable process
2020-06-04 10:12:08 +01:00
int reap_retry_budget;
lws_spawn_piped: break out from cgi The vfork optimized spawn, stdxxx and terminal handling in the cgi implementation is quite mature and sophisticated, and useful for other things unrelated to cgi. Break it out into its own public api under LWS_WITH_SPAWN, off by default. Expand it so the parent wsi is optional, and the role and protocol bindings for stdxxx pipes can be set. Allow optional sul timeout and external lws_dll2 owner for extant children. Remove inline style from minimal http-server-cgi
2020-02-12 10:12:39 +00:00
uint8_t pipes_alive:2;
uint8_t we_killed_him_timeout:1;
uint8_t we_killed_him_spew:1;
uint8_t ungraceful:1;
};
void
lws_spawn_piped_destroy(struct lws_spawn_piped **lsp);
int
lws_spawn_reap(struct lws_spawn_piped *lsp);
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
void
lws_service_do_ripe_rxflow(struct lws_context_per_thread *pt);
const struct lws_role_ops *
lws_role_by_name(const char *name);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
route: on change also check source address still extant
2021-02-05 13:08:41 +00:00
lws_socket_bind(struct lws_vhost *vhost, struct lws *wsi,
lws_sockfd_type sockfd, int port, const char *iface,
int ipv6_allowed);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if defined(LWS_WITH_IPV6)
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
unsigned long
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_get_addr_scope(const char *ipaddr);
#endif
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_close_free_wsi(struct lws *wsi, enum lws_close_status, const char *caller);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__lws_close_free_wsi(struct lws *wsi, enum lws_close_status, const char *caller);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__lws_free_wsi(struct lws *wsi);
lws_conmon: connection monitoring and stats generation This provides a build option LWS_WITH_CONMON that lets user code recover detailed connection stats on client connections with the LCCSCF_CONMON flag. In addition to latencies for dns, socket connection, tls and first protocol response where possible, it also provides the user code an unfiltered list of DNS responses that the client received, and the peer it actually succeded to connect to.
2021-03-15 05:20:15 +00:00
void
lws_conmon_addrinfo_destroy(struct addrinfo *ai);
int
lws_conmon_append_copy_new_dns_results(struct lws *wsi,
const struct addrinfo *cai);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if LWS_MAX_SMP > 1
static LWS_INLINE void
lws_pt_mutex_init(struct lws_context_per_thread *pt)
{
lws_mutex_refcount_init(&pt->mr);
pthread_mutex_init(&pt->lock_stats, NULL);
}
static LWS_INLINE void
lws_pt_mutex_destroy(struct lws_context_per_thread *pt)
{
pthread_mutex_destroy(&pt->lock_stats);
lws_mutex_refcount_destroy(&pt->mr);
}
#define lws_pt_lock(pt, reason) lws_mutex_refcount_lock(&pt->mr, reason)
#define lws_pt_unlock(pt) lws_mutex_refcount_unlock(&pt->mr)
smp: lws_mutex_refcount: add assert held helper also additional pt locks shown as needed by that
2020-08-31 08:12:16 +01:00
#define lws_pt_assert_lock_held(pt) lws_mutex_refcount_assert_held(&pt->mr)
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
static LWS_INLINE void
lws_pt_stats_lock(struct lws_context_per_thread *pt)
{
pthread_mutex_lock(&pt->lock_stats);
}
static LWS_INLINE void
lws_pt_stats_unlock(struct lws_context_per_thread *pt)
{
pthread_mutex_unlock(&pt->lock_stats);
}
#endif
/*
* EXTENSIONS
*/
#if defined(LWS_WITHOUT_EXTENSIONS)
#define lws_any_extension_handled(_a, _b, _c, _d) (0)
#define lws_ext_cb_active(_a, _b, _c, _d) (0)
#define lws_ext_cb_all_exts(_a, _b, _c, _d, _e) (0)
#define lws_issue_raw_ext_access lws_issue_raw
#define lws_context_init_extensions(_a, _b)
#endif
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_client_interpret_server_handshake(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_ws_rx_sm(struct lws *wsi, char already_processed, unsigned char c);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_issue_raw_ext_access(struct lws *wsi, unsigned char *buf, size_t len);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_role_transition(struct lws *wsi, enum lwsi_role role, enum lwsi_state state,
const struct lws_role_ops *ops);
int
lws_http_to_fallback(struct lws *wsi, unsigned char *buf, size_t len);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
user_callback_handle_rxflow(lws_callback_function, struct lws *wsi,
enum lws_callback_reasons reason, void *user,
void *in, size_t len);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
windows: clean warnings around int usage Change all plat instances of lws_plat_setnonblocking() to use lws_sockfd_type
2019-10-21 23:56:32 +00:00
lws_plat_set_nonblocking(lws_sockfd_type fd);
adopt: force incoming fd to nonblocking Incoming fds muct be nonblocking for any event loop... add a platform api to do that and call it during adopt.
2019-03-07 09:49:52 +08:00
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_plat_set_socket_options(struct lws_vhost *vhost, lws_sockfd_type fd,
int unix_skt);
ip tos support
2021-02-04 09:08:17 +00:00
int
lws_plat_set_socket_options_ip(lws_sockfd_type fd, uint8_t pri, int lws_flags);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_plat_check_connection_error(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_header_table_attach(struct lws *wsi, int autoservice);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_header_table_detach(struct lws *wsi, int autoservice);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__lws_header_table_detach(struct lws *wsi, int autoservice);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_header_table_reset(struct lws *wsi, int autoservice);
void
__lws_header_table_reset(struct lws *wsi, int autoservice);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
char * LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_hdr_simple_ptr(struct lws *wsi, enum lws_token_indexes h);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_hdr_simple_create(struct lws *wsi, enum lws_token_indexes h, const char *s);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_ensure_user_space(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_change_pollfd(struct lws *wsi, int _and, int _or);
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_SERVER)
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
int _lws_vhost_init_server(const struct lws_context_creation_info *info,
struct lws_vhost *vhost);
cmake: disable export visibility when building lws static This is complicated by the fact extern on a function declaration implies visibility... we have to make LWS_EXTERN empty when building static. And, setting target_compile_definitions() doesn't work inside macros, so it has to be set explicitly for the plugins. Checking the symbol status needs nm -C -D as per https://stackoverflow.com/questions/37934388/symbol-visibility-not-working-as-expected after this patch, libwebsockets.a shows no symbols when checked like that and the static-linked minimal examples only show -U for their other dynamic imports. In a handful of cases we use LWS_EXTERN on extern data declarations, those then need to change to explicit extern.
2020-09-06 11:46:25 +01:00
struct lws_vhost *
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_select_vhost(struct lws_context *context, int port, const char *servername);
cmake: disable export visibility when building lws static This is complicated by the fact extern on a function declaration implies visibility... we have to make LWS_EXTERN empty when building static. And, setting target_compile_definitions() doesn't work inside macros, so it has to be set explicitly for the plugins. Checking the symbol status needs nm -C -D as per https://stackoverflow.com/questions/37934388/symbol-visibility-not-working-as-expected after this patch, libwebsockets.a shows no symbols when checked like that and the static-linked minimal examples only show -U for their other dynamic imports. In a handful of cases we use LWS_EXTERN on extern data declarations, those then need to change to explicit extern.
2020-09-06 11:46:25 +01:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_parse_ws(struct lws *wsi, unsigned char **buf, size_t len);
cmake: disable export visibility when building lws static This is complicated by the fact extern on a function declaration implies visibility... we have to make LWS_EXTERN empty when building static. And, setting target_compile_definitions() doesn't work inside macros, so it has to be set explicitly for the plugins. Checking the symbol status needs nm -C -D as per https://stackoverflow.com/questions/37934388/symbol-visibility-not-working-as-expected after this patch, libwebsockets.a shows no symbols when checked like that and the static-linked minimal examples only show -U for their other dynamic imports. In a handful of cases we use LWS_EXTERN on extern data declarations, those then need to change to explicit extern.
2020-09-06 11:46:25 +01:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_server_get_canonical_hostname(struct lws_context *context,
const struct lws_context_creation_info *info);
#else
#define _lws_vhost_init_server(_a, _b) (0)
#define lws_parse_ws(_a, _b, _c) (0)
#define lws_server_get_canonical_hostname(_a, _b)
#endif
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__remove_wsi_socket_from_fds(struct lws *wsi);
rx flow: handle partial flow buffer consumption https://github.com/warmcat/libwebsockets/issues/1550 rx flow control needs to handle the situation that it is draining from a previous rx flow control period, and the user code reasserts rx flow control partway through that. The accounting for the used rx then boils down to only trimming the rxflow buflist we were "replaying" to consume however much we managed to deliver of that this time before the rx flow control came again. "Normal" rx consumption is wrong in this case, since we accounted for it entirely in the rxflow cache buflist. The patch recognizes this situation, does the accounting in the cache buflist, and then lies to the caller that there was no rx consumption to be accounted for at his level.
2019-04-19 07:13:40 +01:00
enum {
LWSRXFC_ERROR = -1,
LWSRXFC_CACHED = 0,
LWSRXFC_ADDITIONAL = 1,
LWSRXFC_TRIMMED = 2,
};
service: resurrect timeout_ms being -1 as return immediately There's no longer any reason to come out of sleep for periodic service which has been eliminated by lws_sul. With event libs, there is no opportunity to do it anyway since their event loop is atomic and makes callbacks and sleeps until it is stopped. But some users are relying on the old poll() service loop as glue that's difficult to replace. So for now help that happen by accepting the timeout_ms of -1 as meaning sample poll and service what's there without any wait.
2019-09-16 15:36:12 +01:00
int
_lws_plat_service_forced_tsi(struct lws_context *context, int tsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
lws_rxflow_cache(struct lws *wsi, unsigned char *buf, size_t n, size_t len);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_service_flag_pending(struct lws_context *context, int tsi);
static LWS_INLINE int
lws_has_buffered_out(struct lws *wsi) { return !!wsi->buflist_out; }
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_ws_client_rx_sm(struct lws *wsi, unsigned char c);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
lws_parser_return_t LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_parse(struct lws *wsi, unsigned char *buf, int *len);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_parse_urldecode(struct lws *wsi, uint8_t *_c);
sa46: network check This adds a helper to test if an sa46 is on an sa46-based subnet. The compare helper is adapted to say that non INET/INET6 addresses with the same AF match.
2020-10-05 08:21:28 +01:00
void
lws_sa46_copy_address(lws_sockaddr46 *sa46a, const void *in, int af);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_http_action(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__lws_close_free_wsi_final(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_libuv_closehandle(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_libuv_check_watcher_active(struct lws *wsi);
event libs: default to building as dynamically loaded plugins Event lib support as it has been isn't scaling well, at the low level libevent and libev headers have a namespace conflict so they can't both be built into the same image, and at the distro level, binding all the event libs to libwebsockets.so makes a bloaty situation for packaging, lws will drag in all the event libs every time. This patch implements the plan discussed here https://github.com/warmcat/libwebsockets/issues/1980 and refactors the event lib support so they are built into isolated plugins and bound at runtime according to what the application says it wants to use. The event lib plugins can be packaged individually so that only the needed sets of support are installed (perhaps none of them if the user code is OK with the default poll() loop). And dependent user code can mark the specific event loop plugin package as required so pieces are added as needed. The eventlib-foreign example is also refactored to build the selected lib support isolated. A readme is added detailing the changes and how to use them. https://libwebsockets.org/git/libwebsockets/tree/READMEs/README.event-libs.md
2020-08-27 15:37:14 +01:00
#if defined(LWS_WITH_EVLIB_PLUGINS) || defined(LWS_WITH_PLUGINS)
plugins: generalize and provide public api Move the common plugin scanning dir stuff to be based on lws_dir, which already builds for windows. Previously this was done via dirent for unix and libuv for windows. Reduce the dl plat stuff to just wrap instantiation and destruction of dynlibs, establish common code in lib/misc/dir.c for plugin scanning itself. Migrate the libuv windows dl stuff to windows-plugins.c, so that he's available even if later libuv loop support becomes and event lib plugin. Remove the existing api exports scheme for plugins, just export a const struct now which has a fixed header type but then whatever you want afterwards depending on the class / purpose of the plugin. Place a "class" string in the header so there can be different kinds of plugins implying different types exported. Make the plugin apis public and add support for filter by class string, and per instantation / destruction callbacks so the subclassed header type can do its thing for the plugin class. The user provides a linked-list base for his class of plugins, so he can manage them completely separately and in user code / user export types. Rip out some last hangers-on from generic sessions / tables. This is all aimed at making the plugins support general enough so it can provide event lib plugins later.
2020-08-27 09:34:35 +01:00
const lws_plugin_header_t *
lws_plat_dlopen(struct lws_plugin **pplugin, const char *libpath,
const char *sofilename, const char *_class,
each_plugin_cb_t each, void *each_user);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
plugins: generalize and provide public api Move the common plugin scanning dir stuff to be based on lws_dir, which already builds for windows. Previously this was done via dirent for unix and libuv for windows. Reduce the dl plat stuff to just wrap instantiation and destruction of dynlibs, establish common code in lib/misc/dir.c for plugin scanning itself. Migrate the libuv windows dl stuff to windows-plugins.c, so that he's available even if later libuv loop support becomes and event lib plugin. Remove the existing api exports scheme for plugins, just export a const struct now which has a fixed header type but then whatever you want afterwards depending on the class / purpose of the plugin. Place a "class" string in the header so there can be different kinds of plugins implying different types exported. Make the plugin apis public and add support for filter by class string, and per instantation / destruction callbacks so the subclassed header type can do its thing for the plugin class. The user provides a linked-list base for his class of plugins, so he can manage them completely separately and in user code / user export types. Rip out some last hangers-on from generic sessions / tables. This is all aimed at making the plugins support general enough so it can provide event lib plugins later.
2020-08-27 09:34:35 +01:00
int
lws_plat_destroy_dl(struct lws_plugin *p);
event libs: default to building as dynamically loaded plugins Event lib support as it has been isn't scaling well, at the low level libevent and libev headers have a namespace conflict so they can't both be built into the same image, and at the distro level, binding all the event libs to libwebsockets.so makes a bloaty situation for packaging, lws will drag in all the event libs every time. This patch implements the plan discussed here https://github.com/warmcat/libwebsockets/issues/1980 and refactors the event lib support so they are built into isolated plugins and bound at runtime according to what the application says it wants to use. The event lib plugins can be packaged individually so that only the needed sets of support are installed (perhaps none of them if the user code is OK with the default poll() loop). And dependent user code can mark the specific event loop plugin package as required so pieces are added as needed. The eventlib-foreign example is also refactored to build the selected lib support isolated. A readme is added detailing the changes and how to use them. https://libwebsockets.org/git/libwebsockets/tree/READMEs/README.event-libs.md
2020-08-27 15:37:14 +01:00
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
struct lws *
lws_adopt_socket_vhost(struct lws_vhost *vh, lws_sockfd_type accept_fd);
void
lws_vhost_bind_wsi(struct lws_vhost *vh, struct lws *wsi);
void
lws_vhost_unbind_wsi(struct lws *wsi);
void
__lws_set_timeout(struct lws *wsi, enum pending_timeout reason, int secs);
int
__lws_change_pollfd(struct lws *wsi, int _and, int _or);
int
lws_callback_as_writeable(struct lws *wsi);
int
lws_role_call_client_bind(struct lws *wsi,
const struct lws_client_connect_info *i);
void
lws_remove_child_from_any_parent(struct lws *wsi);
char *
lws_generate_client_ws_handshake(struct lws *wsi, char *p, const char *conn1);
int
lws_client_ws_upgrade(struct lws *wsi, const char **cce);
int
lws_create_client_ws_object(const struct lws_client_connect_info *i,
struct lws *wsi);
int
lws_alpn_comma_to_openssl(const char *comma, uint8_t *os, int len);
int
lws_role_call_alpn_negotiated(struct lws *wsi, const char *alpn);
int
lws_tls_server_conn_alpn(struct lws *wsi);
int
lws_ws_client_rx_sm_block(struct lws *wsi, unsigned char **buf, size_t len);
void
lws_destroy_event_pipe(struct lws *wsi);
/* socks */
client: modernize socks5 fixing heap overflow https://github.com/warmcat/libwebsockets/issues/1583
2019-05-22 15:51:04 +01:00
int
socks5: cleanup and add test options Refactor SOCKS5 client support to be gathered into lib/core-net/socks5-client.c and make that build contingent on LWS_WITH_SOCKS5.
2020-02-18 14:27:27 +00:00
lws_socks5c_generate_msg(struct lws *wsi, enum socks_msg_type type, ssize_t *msg_len);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
#if defined(LWS_WITH_DEPRECATED_THINGS)
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__lws_timed_callback_remove(struct lws_vhost *vh, struct lws_timed_vh_protocol *p);
sul: multiple timer domains Adapt the pt sul owner list to be an array, and define two different lists, one that acts like before and is the default for existing users, and another that has the ability to cooperate with systemwide suspend to restrict the interval spent suspended so that it will wake in time for the earliest thing on this wake-suspend sul list. Clean the api a bit and add lws_sul_cancel() that only needs the sul as the argument. Add a flag for client creation info to indicate that this client connection is important enough that, eg, validity checking it to detect silently dead connections should go on the wake-suspend sul list. That flag is exposed in secure streams policy so it can be added to a streamtype with "swake_validity": true Deprecate out the old vhost timer stuff that predates sul. Add a flag LWS_WITH_DEPRECATED_THINGS in cmake so users can get it back temporarily before it will be removed in a v4.2. Adapt all remaining in-tree users of it to use explicit suls.
2020-05-28 12:48:17 +01:00
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__insert_wsi_socket_into_fds(struct lws_context *context, struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_issue_raw(struct lws *wsi, unsigned char *buf, size_t len);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
lws_usec_t
sequencer: upgrade timeout to use us Adapt service loops and event libs to use microsecond waits internally, for hrtimer and sequencer. Reduce granularity according to platform / event lib wait. Add a helper so there's a single place to extend it.
2019-08-08 06:30:14 +01:00
__lws_seq_timeout_check(struct lws_context_per_thread *pt, lws_usec_t usnow);
lws_sequencer
2019-06-24 07:15:50 +01:00
client: secure streams Secure Streams is an optional layer on top of lws that separates policy like endpoint selection and tls cert validation into a device JSON policy document. Code that wants to open a client connection just specifies a streamtype name, and no longer deals with details like the endpoint, the protocol (!) or anything else other than payloads and optionally generic metadata; the JSON policy contains all the details for each streamtype. h1, h2, ws and mqtt client connections are supported. Logical secure streams outlive any particular connection and supports "nailed-up" connectivity regardless of underlying connection stability.
2020-02-29 12:37:24 +00:00
lws_usec_t
__lws_ss_timeout_check(struct lws_context_per_thread *pt, lws_usec_t usnow);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
struct lws * LWS_WARN_UNUSED_RESULT
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
lws_client_connect_2_dnsreq(struct lws *wsi);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
LWS_VISIBLE struct lws * LWS_WARN_UNUSED_RESULT
lws_client_reset(struct lws **wsi, int ssl, const char *address, int port,
client: lws_client_reset option to keep ws With this, ws connection to https://libwebsockets.org/redir-testserver (which redirects to https://libwebsockets.org/testserver) can work OK. https://github.com/warmcat/libwebsockets/issues/1820
2020-01-10 11:47:01 +00:00
const char *path, const char *host, char weak);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
struct lws * LWS_WARN_UNUSED_RESULT
lws_lifecycle This adds some new objects and helpers for keeping and logging info on grouped allocations, a group is, eg, SS handles or client wsis. Allocated objects get a context-unique "tag" string intended to replace %p / wsi pointers etc. Pointers quickly become confusing when allocations are freed and reused, the tag string won't repeat until you produce 2^64 objects in a context. In addition the tag string documents the object group, with prefixes like "wsi-" or "vh-" and contain object-specific additional information like the vhost name, address / port or the role of the wsi. At creation time the lws code can use a format string and args to add whatever group-specific info makes sense, eg, a wsi bound to a secure stream can also append the guid of the secure stream, it's copied into the new object tag and so is still available cleanly after the stream is destroyed if the wsi outlives it.
2020-12-25 05:54:19 +00:00
lws_create_new_server_wsi(struct lws_vhost *vhost, int fixed_tsi, const char *desc);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
char * LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_generate_client_handshake(struct lws *wsi, char *pkt);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_handle_POLLOUT_event(struct lws *wsi, struct lws_pollfd *pollfd);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
struct lws *
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_http_client_connect_via_info2(struct lws *wsi);
roles: netlink This creates a role for RFC3549 Netlink monitoring. If the OS supports it (currently, linux) then each pt creates a wsi with the netlink role and dumps the current routing table at pt init. It then maintains a cache of the routing table in each pt. Upon routing table changes an SMD message is issued as an event, and Captive Portal Detection is triggered. All of the pt's current connections are reassessed for routability under the changed routing table, those that no longer have a valid route or gateway are closed.
2020-10-04 07:28:41 +01:00
struct lws *
wsi: unify base wsi creation function A few different places want to create wsis and basically repeat their own versions of the flow. Let's unify it into one helper in wsi.c Also require the context lock held (this only impacts LWS_MAX_SMP > 1)
2020-12-24 16:06:50 +00:00
__lws_wsi_create_with_role(struct lws_context *context, int tsi,
roles: netlink This creates a role for RFC3549 Netlink monitoring. If the OS supports it (currently, linux) then each pt creates a wsi with the netlink role and dumps the current routing table at pt init. It then maintains a cache of the routing table in each pt. Upon routing table changes an SMD message is issued as an event, and Captive Portal Detection is triggered. All of the pt's current connections are reassessed for routability under the changed routing table, those that no longer have a valid route or gateway are closed.
2020-10-04 07:28:41 +01:00
const struct lws_role_ops *ops);
int
lws_wsi_inject_to_loop(struct lws_context_per_thread *pt, struct lws *wsi);
int
lws_wsi_extract_from_loop(struct lws *wsi);
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_CLIENT)
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
client: move staged connect pieces into core-net They have been in lib/roles/http for historical reasons, and all ended up in client-handshake.c that doesn't describe what they actually do any more. Separate out the staged client connect related stage functions into lib/core-net/client/client2.c: lws_client_connect_2_dnsreq() lib/core-net/client/client3.c: lws_client_connect_3_connect() lib/core-net/client/client4.c: lws_client_connect_4_established() Move a couple of other functions from there that don't belong out to tls-client.c and client-http.c, which is related to http and remains in the http role dir.
2020-09-19 13:27:33 +01:00
lws_http_client_socket_service(struct lws *wsi, struct lws_pollfd *pollfd);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_http_transaction_completed_client(struct lws *wsi);
#if !defined(LWS_WITH_TLS)
#define lws_context_init_client_ssl(_a, _b) (0)
#endif
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_decode_ssl_error(void);
#else
#define lws_context_init_client_ssl(_a, _b) (0)
#endif
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__lws_rx_flow_control(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
_lws_change_pollfd(struct lws *wsi, int _and, int _or, struct lws_pollargs *pa);
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_SERVER)
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_handshake_server(struct lws *wsi, unsigned char **buf, size_t len);
#else
#define lws_server_socket_service(_b, _c) (0)
#define lws_handshake_server(_a, _b, _c) (0)
#endif
#ifdef LWS_WITH_ACCESS_LOG
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_access_log(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_prepare_access_log_info(struct lws *wsi, char *uri_ptr, int len, int meth);
#else
#define lws_access_log(_a)
#endif
h2: LCCSCF_H2_MANUAL_RXFLOW and refactor txcr This changes the approach of tx credit management to set the initial stream tx credit window to zero. This is the only way with RFC7540 to gain the ability to selectively precisely rx flow control incoming streams. At the time the headers are sent, a WINDOW_UPDATE is sent with the initial tx credit towards us for that specific stream. By default, this acts as before with a 256KB window added for both the stream and the nwsi, and additional window management sent as stuff is received. It's now also possible to set a member in the client info struct and a new option LCCSCF_H2_MANUAL_RXFLOW to precisely manage both the initial tx credit for a specific stream and the ongoing rate limit by meting out further tx credit manually. Add another minimal example http-client-h2-rxflow demonstrating how to force a connection's peer's initial budget to transmit to us and control it during the connection lifetime to restrict the amount of incoming data we have to buffer.
2019-12-26 02:35:41 +00:00
#if defined(_DEBUG)
void
lws_wsi_txc_describe(struct lws_tx_credit *txc, const char *at, uint32_t sid);
#else
#define lws_wsi_txc_describe(x, y, z) { (void)x; }
#endif
int
lws_wsi_txc_check_skint(struct lws_tx_credit *txc, int32_t tx_cr);
int
lws_wsi_txc_report_manual_txcr_in(struct lws *wsi, int32_t bump);
h2: unify immortal stream tracking across SSE and ws substreams It was already correct but add helpers to isolate and deduplicate processing adding and closing a generically immortal stream. Change the default 31s h2 network connection timeout to be settable by .keepalive_timeout if nonzero. Add a public api allowing a client h2 stream to transition to half-closed LOCAL (by sending a 0-byte DATA with END_STREAM) and mark itself as immortal to create a read-only long-poll stream if the server allows it. Add a vhost server option flag LWS_SERVER_OPTION_VH_H2_HALF_CLOSED_LONG_POLL which allows the vhost to treat half-closed remotes as immortal long poll streams.
2019-09-13 10:33:24 +01:00
void
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
lws_mux_mark_immortal(struct lws *wsi);
h2: unify immortal stream tracking across SSE and ws substreams It was already correct but add helpers to isolate and deduplicate processing adding and closing a generically immortal stream. Change the default 31s h2 network connection timeout to be settable by .keepalive_timeout if nonzero. Add a public api allowing a client h2 stream to transition to half-closed LOCAL (by sending a 0-byte DATA with END_STREAM) and mark itself as immortal to create a read-only long-poll stream if the server allows it. Add a vhost server option flag LWS_SERVER_OPTION_VH_H2_HALF_CLOSED_LONG_POLL which allows the vhost to treat half-closed remotes as immortal long poll streams.
2019-09-13 10:33:24 +01:00
void
lws_http_close_immortal(struct lws *wsi);
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_cgi_kill_terminated(struct lws_context_per_thread *pt);
h2: unify immortal stream tracking across SSE and ws substreams It was already correct but add helpers to isolate and deduplicate processing adding and closing a generically immortal stream. Change the default 31s h2 network connection timeout to be settable by .keepalive_timeout if nonzero. Add a public api allowing a client h2 stream to transition to half-closed LOCAL (by sending a 0-byte DATA with END_STREAM) and mark itself as immortal to create a read-only long-poll stream if the server allows it. Add a vhost server option flag LWS_SERVER_OPTION_VH_H2_HALF_CLOSED_LONG_POLL which allows the vhost to treat half-closed remotes as immortal long poll streams.
2019-09-13 10:33:24 +01:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_cgi_remove_and_kill(struct lws *wsi);
h2: unify immortal stream tracking across SSE and ws substreams It was already correct but add helpers to isolate and deduplicate processing adding and closing a generically immortal stream. Change the default 31s h2 network connection timeout to be settable by .keepalive_timeout if nonzero. Add a public api allowing a client h2 stream to transition to half-closed LOCAL (by sending a 0-byte DATA with END_STREAM) and mark itself as immortal to create a read-only long-poll stream if the server allows it. Add a vhost server option flag LWS_SERVER_OPTION_VH_H2_HALF_CLOSED_LONG_POLL which allows the vhost to treat half-closed remotes as immortal long poll streams.
2019-09-13 10:33:24 +01:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_plat_delete_socket_from_fds(struct lws_context *context,
struct lws *wsi, int m);
h2: unify immortal stream tracking across SSE and ws substreams It was already correct but add helpers to isolate and deduplicate processing adding and closing a generically immortal stream. Change the default 31s h2 network connection timeout to be settable by .keepalive_timeout if nonzero. Add a public api allowing a client h2 stream to transition to half-closed LOCAL (by sending a 0-byte DATA with END_STREAM) and mark itself as immortal to create a read-only long-poll stream if the server allows it. Add a vhost server option flag LWS_SERVER_OPTION_VH_H2_HALF_CLOSED_LONG_POLL which allows the vhost to treat half-closed remotes as immortal long poll streams.
2019-09-13 10:33:24 +01:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_plat_insert_socket_into_fds(struct lws_context *context,
struct lws *wsi);
h2: unify immortal stream tracking across SSE and ws substreams It was already correct but add helpers to isolate and deduplicate processing adding and closing a generically immortal stream. Change the default 31s h2 network connection timeout to be settable by .keepalive_timeout if nonzero. Add a public api allowing a client h2 stream to transition to half-closed LOCAL (by sending a 0-byte DATA with END_STREAM) and mark itself as immortal to create a read-only long-poll stream if the server allows it. Add a vhost server option flag LWS_SERVER_OPTION_VH_H2_HALF_CLOSED_LONG_POLL which allows the vhost to treat half-closed remotes as immortal long poll streams.
2019-09-13 10:33:24 +01:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_plat_change_pollfd(struct lws_context *context, struct lws *wsi,
struct lws_pollfd *pfd);
ss: server: h1, h2, ws basic support Add initial support for defining servers using Secure Streams policy and api semantics. Serving h1, h2 and ws should be functional, the new minimal example shows a combined http + SS server with an incrementing ws message shown in the browser over tls, in around 200 lines of user code. NOP out anything to do with plugins, they're not currently used. Update the docs correspondingly.
2020-07-27 10:03:12 +01:00
#if defined(LWS_WITH_SERVER) && defined(LWS_WITH_SECURE_STREAMS)
int
lws_adopt_ss_server_accept(struct lws *new_wsi);
#endif
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
int
lws_plat_pipe_create(struct lws *wsi);
int
context: refactor destroy flow
2020-11-16 19:32:58 +00:00
lws_plat_pipe_signal(struct lws_context *ctx, int tsi);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
void
lws_plat_pipe_close(struct lws *wsi);
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
void
lws_addrinfo_clean(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_add_wsi_to_draining_ext_list(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_remove_wsi_from_draining_ext_list(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_poll_listen_fd(struct lws_pollfd *fd);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_plat_service(struct lws_context *context, int timeout_ms);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
LWS_VISIBLE int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
_lws_plat_service_tsi(struct lws_context *context, int timeout_ms, int tsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_pthread_self_to_tsi(struct lws_context *context);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
const char * LWS_WARN_UNUSED_RESULT
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
lws_plat_inet_ntop(int af, const void *src, char *dst, socklen_t cnt);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int LWS_WARN_UNUSED_RESULT
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_plat_inet_pton(int af, const char *src, void *dst);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_same_vh_protocol_remove(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
__lws_same_vh_protocol_remove(struct lws *wsi);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
void
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_same_vh_protocol_insert(struct lws *wsi, int n);
sequencer: cleanup on pt takedown
2019-08-05 19:26:38 +01:00
void
sequencer: upgrade timeout to use us Adapt service loops and event libs to use microsecond waits internally, for hrtimer and sequencer. Reduce granularity according to platform / event lib wait. Add a helper so there's a single place to extend it.
2019-08-08 06:30:14 +01:00
lws_seq_destroy_all_on_pt(struct lws_context_per_thread *pt);
lws_sequencer
2019-06-24 07:15:50 +01:00
roles: netlink This creates a role for RFC3549 Netlink monitoring. If the OS supports it (currently, linux) then each pt creates a wsi with the netlink role and dumps the current routing table at pt init. It then maintains a cache of the routing table in each pt. Upon routing table changes an SMD message is issued as an event, and Captive Portal Detection is triggered. All of the pt's current connections are reassessed for routability under the changed routing table, those that no longer have a valid route or gateway are closed.
2020-10-04 07:28:41 +01:00
void
lws_addrinfo_clean(struct lws *wsi);
int
_lws_route_pt_close_unroutable(struct lws_context_per_thread *pt);
void
_lws_routing_entry_dump(lws_route_t *rou);
void
netlink: migrate to context For SMP case, it was desirable to have a netlink listener per pt so they could deal with pt-level changes in the pt's local service thread. But Linux restricts the process to just one netlink listener. We worked around it by only listening on pt[0], this aligns us a bit more with the reality and moves to a single routing table in the context. There's still more to do for SMP case locking.
2021-03-07 09:44:29 +00:00
_lws_routing_table_dump(struct lws_context *cx);
roles: netlink This creates a role for RFC3549 Netlink monitoring. If the OS supports it (currently, linux) then each pt creates a wsi with the netlink role and dumps the current routing table at pt init. It then maintains a cache of the routing table in each pt. Upon routing table changes an SMD message is issued as an event, and Captive Portal Detection is triggered. All of the pt's current connections are reassessed for routability under the changed routing table, those that no longer have a valid route or gateway are closed.
2020-10-04 07:28:41 +01:00
route: on change also check source address still extant
2021-02-05 13:08:41 +00:00
#define LRR_IGNORE_PRI (1 << 0)
#define LRR_MATCH_SRC (1 << 1)
route: assert if route table becomes full
2021-03-29 06:42:50 +01:00
#define LRR_JUST_CHECK (1 << 2)
route: on change also check source address still extant
2021-02-05 13:08:41 +00:00
route: assert if route table becomes full
2021-03-29 06:42:50 +01:00
lws_route_t *
route: on change also check source address still extant
2021-02-05 13:08:41 +00:00
_lws_route_remove(struct lws_context_per_thread *pt, lws_route_t *robj, int flags);
roles: netlink This creates a role for RFC3549 Netlink monitoring. If the OS supports it (currently, linux) then each pt creates a wsi with the netlink role and dumps the current routing table at pt init. It then maintains a cache of the routing table in each pt. Upon routing table changes an SMD message is issued as an event, and Captive Portal Detection is triggered. All of the pt's current connections are reassessed for routability under the changed routing table, those that no longer have a valid route or gateway are closed.
2020-10-04 07:28:41 +01:00
void
_lws_route_table_empty(struct lws_context_per_thread *pt);
void
_lws_route_table_ifdown(struct lws_context_per_thread *pt, int idx);
lws_route_uidx_t
netlink: migrate to context For SMP case, it was desirable to have a netlink listener per pt so they could deal with pt-level changes in the pt's local service thread. But Linux restricts the process to just one netlink listener. We worked around it by only listening on pt[0], this aligns us a bit more with the reality and moves to a single routing table in the context. There's still more to do for SMP case locking.
2021-03-07 09:44:29 +00:00
_lws_route_get_uidx(struct lws_context *cx);
roles: netlink This creates a role for RFC3549 Netlink monitoring. If the OS supports it (currently, linux) then each pt creates a wsi with the netlink role and dumps the current routing table at pt init. It then maintains a cache of the routing table in each pt. Upon routing table changes an SMD message is issued as an event, and Captive Portal Detection is triggered. All of the pt's current connections are reassessed for routability under the changed routing table, those that no longer have a valid route or gateway are closed.
2020-10-04 07:28:41 +01:00
int
_lws_route_pt_close_route_users(struct lws_context_per_thread *pt,
lws_route_uidx_t uidx);
lws_route_t *
_lws_route_est_outgoing(struct lws_context_per_thread *pt,
const lws_sockaddr46 *dest);
client: rfc6724 dns results sorting RFC6724 defines an ipv6-centric DNS result sorting algorithm, that takes route and source address route information for the results given by the DNS resolution, and sorts them in order of preferability, which defines the order they should be tried in. If LWS_WITH_NETLINK, then lws takes care about collecting and monitoring the interface, route and source address information, and uses it to perform the RFC6724 sorting to re-sort the DNS before trying to make the connections.
2020-09-20 09:14:46 +01:00
int
lws_sort_dns(struct lws *wsi, const struct addrinfo *result);
minimal-http-client-multi: add POST This adds support for POST in both h1 and h2 queues / stream binding. The previous queueing tried to keep the "leader" wsi who made the actual connection around and have it act on the transaction queue tail if it had done its own thing. This refactors it so instead, who is the "leader" moves down the queue and the queued guys inherit the fd, SSL * and queue from the old leader as they take over. This lets them operate in their own wsi identity directly and gets rid of all the "effective wsi" checks, which was applied incompletely and getting out of hand considering the separate lws_mux checks for h2 and other muxed protocols alongside it. This change also allows one wsi at a time to own the transaction for POST. --post is added as an option to lws-minimal-http-client-multi and 6 extra selftests with POST on h1/h2, pipelined or not and staggered or not are added to the CI.
2020-01-30 13:19:11 +00:00
int
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
lws_broadcast(struct lws_context_per_thread *pt, int reason, void *in, size_t len);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#if defined(LWS_WITH_PEER_LIMITS)
void
lws_peer_track_wsi_close(struct lws_context *context, struct lws_peer *peer);
int
lws_peer_confirm_ah_attach_ok(struct lws_context *context,
struct lws_peer *peer);
void
lws_peer_track_ah_detach(struct lws_context *context, struct lws_peer *peer);
void
lws_peer_cull_peer_wait_list(struct lws_context *context);
struct lws_peer *
lws_get_or_create_peer(struct lws_vhost *vhost, lws_sockfd_type sockfd);
void
lws_peer_add_wsi(struct lws_context *context, struct lws_peer *peer,
struct lws *wsi);
void
lws_peer_dump_from_wsi(struct lws *wsi);
#endif
#ifdef LWS_WITH_HUBBUB
hubbub_error
html_parser_cb(const hubbub_token *token, void *pw);
#endif
int
lws_threadpool_tsi_context(struct lws_context *context, int tsi);
void
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
__lws_wsi_remove_from_sul(struct lws *wsi);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
lws_validity: unified connection validity tracking Refactor everything around ping / pong handling in ws and h2, so there is instead a protocol-independent validity lws_sul tracking how long it has been since the last exchange that confirms the operation of the network connection in both directions. Clean out periodic role callback and replace the last two role users with discrete lws_sul for each pt.
2019-09-18 13:09:32 +01:00
void
lws_validity_confirmed(struct lws *wsi);
void
_lws_validity_confirmed_role(struct lws *wsi);
sul: all timed objects use a single pt sul list wsi timeout, wsi hrtimer, sequencer timeout and vh-protocol timer all now participate on a single sorted us list. The whole idea of polling wakes is thrown out, poll waits ignore the timeout field and always use infinite timeouts. Introduce a public api that can schedule its own callback from the event loop with us resolution (usually ms is all the platform can do). Upgrade timeouts and sequencer timeouts to also be able to use us resolution. Introduce a prepared fakewsi in the pt, so we don't have to allocate one on the heap when we need it. Directly handle vh-protocol timer if LWS_MAX_SMP == 1
2019-08-09 10:12:09 +01:00
int
lws_seq_pt_init(struct lws_context_per_thread *pt);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
int
lws_buflist_aware_read(struct lws_context_per_thread *pt, struct lws *wsi,
lws_buflist_aware_read: restrict to incoming ebuf length if non-NULL ebuf.token incoming (Includes fixes from Yichen Gu) Currently the incoming ebuf is always replaced to point to either a whole buflist segment, or up to the (pt_serv_buf - LWS_PRE) length in the pt_serv_buf. This is called on path for handling http read... some user code reasonably wants to restrict the read size to what it can handle. Change the other lws_buflist_aware_read() callers to zero ebuf before calling, and for those have it keep the current behaviour; but if non-NULL ebuf.token on incoming, as in http read path case, restrict both reported len of buflist content and the read length to the incoming ebuf.len so the user code can control what it will get at one time. Additionally muxed protocol wsi have no choice but to read what was sent to them since it's HOL-blocking for other streams and its own WINDOW_UPDATEs. So add an internal param to lws_buflist_aware_read() forcing read even if buflist content is available.
2020-01-20 10:02:56 +00:00
struct lws_tokens *ebuf, char fr, const char *hint);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
int
client: use block parse and buflist With http, the protocol doesn't indicate where the headers end and the next transaction or body begin. Until now, we handled that for client header response parsing by reading from the tls buffer bytewise. This modernizes the code to read in up to 256-byte chunks and parse the chunks in one hit (the parse API is already set up for doing this elsewhere). Now we have a generic input buflist, adapt the parser loop to go through that and arrange that any leftovers are placed on there.
2019-08-27 06:06:13 +01:00
lws_buflist_aware_finished_consuming(struct lws *wsi, struct lws_tokens *ebuf,
int used, int buffered, const char *hint);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
abstract: allow completely generic instantiation and destruction
2019-06-22 06:59:49 +01:00
extern const struct lws_protocols protocol_abs_client_raw_skt,
protocol_abs_client_unit_test;
smtp: make abstract
2019-04-21 19:57:19 +01:00
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
void
__lws_reset_wsi(struct lws *wsi);
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
void
lws_metrics_dump(struct lws_context *ctx);
lws_inform_client_conn_fail There are many places where we have the same code to inform about client connection failure... consolidate it
2019-08-10 09:20:27 +01:00
void
lws_inform_client_conn_fail(struct lws *wsi, void *arg, size_t len);
asynchronous dns for ipv4 and ipv6 This adds the option to have lws do its own dns resolution on the event loop, without blocking. Existing implementations get the name resolution done by the libc, which is blocking. In the case you are opening client connections but need to carefully manage latency, another connection opening and doing the name resolution becomes a big problem. Currently it supports - ipv4 / A records - ipv6 / AAAA records - ipv4-over-ipv6 ::ffff:1.2.3.4 A record promotion for ipv6 - only one server supported over UDP :53 - nameserver discovery on linux, windows, freertos It also has some nice advantages - lws-style paranoid response parsing - random unique tid generation to increase difficulty of poisoning - it's really integrated with the lws event loop, it does not spawn threads or use the libc resolver, and of course no blocking at all - platform-specific server address capturing (from /etc/resolv.conf on linux, windows apis on windows) - it has LRU caching - piggybacking (multiple requests before the first completes go on a list on the first request, not spawn multiple requests) - observes TTL in cache - TTL and timeout use lws_sul timers on the event loop - ipv6 pieces only built if cmake LWS_IPV6 enabled
2019-09-19 06:54:53 +01:00
#if defined(LWS_WITH_SYS_ASYNC_DNS)
lws_async_dns_server_check_t
lws_plat_asyncdns_init(struct lws_context *context, lws_sockaddr46 *sa);
int
lws_async_dns_init(struct lws_context *context);
void
lws_async_dns_deinit(lws_async_dns_t *dns);
#endif
lws_state and system state Introduce a generic lws_state object with notification handlers that may be registered in a chain. Implement one of those in the context to manage the "system state". Allow other pieces of lws and user code to register notification handlers on a context list. Handlers can object to or take over responsibility to move forward and retry system state changes if they know that some dependent action must succeed first. For example if the system time is invalid, we cannot move on to a state where anything can do tls until that has been corrected.
2019-09-19 09:48:17 +01:00
int
lws_protocol_init_vhost(struct lws_vhost *vh, int *any);
muxable client: make http support generic h1 and h2 has a bunch of code supporting autobinding outgoing client connections to be streams in, or queued as pipelined on, the same / existing single network connection, if it's to the same endpoint. Adapt this http-specific code and active connection tracking to be usable for generic muxable protocols the same way.
2019-09-23 04:23:07 -07:00
int
smp: helgrind and sai lock fixes
2020-04-15 20:57:00 +01:00
_lws_generic_transaction_completed_active_conn(struct lws **wsi, char take_vh_lock);
muxable client: make http support generic h1 and h2 has a bunch of code supporting autobinding outgoing client connections to be streams in, or queued as pipelined on, the same / existing single network connection, if it's to the same endpoint. Adapt this http-specific code and active connection tracking to be usable for generic muxable protocols the same way.
2019-09-23 04:23:07 -07:00
#define ACTIVE_CONNS_SOLO 0
#define ACTIVE_CONNS_MUXED 1
#define ACTIVE_CONNS_QUEUED 2
client: MQTT Adds client support for MQTT QoS0 and QoS1, compatible with AWS IoT Supports stream binding where independent client connections to the same endpoint can mux on a single tcp + tls connection with topic routing managed internally.
2020-02-25 13:28:25 +00:00
#define ACTIVE_CONNS_FAILED 3
muxable client: make http support generic h1 and h2 has a bunch of code supporting autobinding outgoing client connections to be streams in, or queued as pipelined on, the same / existing single network connection, if it's to the same endpoint. Adapt this http-specific code and active connection tracking to be usable for generic muxable protocols the same way.
2019-09-23 04:23:07 -07:00
fds: add sanity checks
2020-05-04 07:24:58 +01:00
#if defined(_DEBUG) && !defined(LWS_PLAT_FREERTOS) && !defined(WIN32) && !defined(LWS_PLAT_OPTEE)
int
sanity_assert_no_wsi_traces(const struct lws_context *context, struct lws *wsi);
int
sanity_assert_no_sockfd_traces(const struct lws_context *context,
lws_sockfd_type sfd);
#else
static inline int sanity_assert_no_wsi_traces(const struct lws_context *context, struct lws *wsi) { (void)context; (void)wsi; return 0; }
static inline int sanity_assert_no_sockfd_traces(const struct lws_context *context, lws_sockfd_type sfd) { (void)context; (void)sfd; return 0; }
#endif
void
delete_from_fdwsi(const struct lws_context *context, struct lws *wsi);
muxable client: make http support generic h1 and h2 has a bunch of code supporting autobinding outgoing client connections to be streams in, or queued as pipelined on, the same / existing single network connection, if it's to the same endpoint. Adapt this http-specific code and active connection tracking to be usable for generic muxable protocols the same way.
2019-09-23 04:23:07 -07:00
int
active_conns: move out dependency on ah
2019-12-23 09:25:56 +00:00
lws_vhost_active_conns(struct lws *wsi, struct lws **nwsi, const char *adsin);
const char *
lws_wsi_client_stash_item(struct lws *wsi, int stash_idx, int hdr_idx);
lws_state and system state Introduce a generic lws_state object with notification handlers that may be registered in a chain. Implement one of those in the context to manage the "system state". Allow other pieces of lws and user code to register notification handlers on a context list. Handlers can object to or take over responsibility to move forward and retry system state changes if they know that some dependent action must succeed first. For example if the system time is invalid, we cannot move on to a state where anything can do tls until that has been corrected.
2019-09-19 09:48:17 +01:00
windows: clean type warnings There are some minor public api type improvements rather than cast everywhere inside lws and user code to work around them... these changed from int to size_t - lws_buflist_use_segment() return - lws_tokenize_t .len and .token_len - lws_tokenize_cstr() length - lws_get_peer_simple() namelen - lws_get_peer_simple_fd() namelen, int fd -> lws_sockfd_type fd - lws_write_numeric_address() len - lws_sa46_write_numeric_address() len These changes are typically a NOP for user code
2020-01-11 14:04:50 +00:00
int
lws_plat_BINDTODEVICE(lws_sockfd_type fd, const char *ifname);
socks5: cleanup and add test options Refactor SOCKS5 client support to be gathered into lib/core-net/socks5-client.c and make that build contingent on LWS_WITH_SOCKS5.
2020-02-18 14:27:27 +00:00
int
lws_socks5c_ads_server(struct lws_vhost *vh,
const struct lws_context_creation_info *info);
int
lws_socks5c_handle_state(struct lws *wsi, struct lws_pollfd *pollfd,
const char **pcce);
int
lws_socks5c_greet(struct lws *wsi, const char **pcce);
mbedtls: attempt to remove dependency on net_sockets.c The mbedtls openssl wrapper wants to use exports from mbedtls' net_sockets.c, but this is only supposed to work on *nix and windows. Typically people are using mbedtls on RTOS type platforms and to use it, net_sockets.c needs some hacking. Try to avoid that situation by porting the two exports we need into the lws plat code and call from the wrapper.
2020-03-27 13:24:44 +00:00
int
lws_plat_mbedtls_net_send(void *ctx, const uint8_t *buf, size_t len);
int
lws_plat_mbedtls_net_recv(void *ctx, unsigned char *buf, size_t len);
sul: lws_sul_nonmonotonic_adjust FreeRTOS only supports nonmonotonic time, when we correct it by, eg, ntpclient, we offset all the existing sul timeouts. This adds an internal helper function to correct existing sul timeouts by the step amount, and call it in lws ntpclient implementation when adjusting the gettimeofday() time.
2020-07-03 06:42:31 +01:00
lws_usec_t
lws_sul_nonmonotonic_adjust(struct lws_context *ctx, int64_t step_us);
vhost_destroy: refactor
2021-01-22 09:11:22 +00:00
void
__lws_vhost_destroy_pt_wsi_dieback_start(struct lws_vhost *vh);
lws_netdev: use lws_settings Perform the AP selection using lws_settings and a generic scan state machine
2020-07-02 15:38:53 +01:00
void
lws_netdev_instance_remove_destroy(struct lws_netdev_instance *ni);
client: rfc6724 dns results sorting RFC6724 defines an ipv6-centric DNS result sorting algorithm, that takes route and source address route information for the results given by the DNS resolution, and sorts them in order of preferability, which defines the order they should be tried in. If LWS_WITH_NETLINK, then lws takes care about collecting and monitoring the interface, route and source address information, and uses it to perform the RFC6724 sorting to re-sort the DNS before trying to make the connections.
2020-09-20 09:14:46 +01:00
int
lws_score_dns_results(struct lws_context *ctx,
const struct addrinfo **result);
lws_smd: take care about build with disabled
2020-08-16 05:35:56 +01:00
#if defined(LWS_WITH_SYS_SMD)
lws_netdev: use lws_settings Perform the AP selection using lws_settings and a generic scan state machine
2020-07-02 15:38:53 +01:00
int
lws_netdev_smd_cb(void *opaque, lws_smd_class_t _class, lws_usec_t timestamp,
void *buf, size_t len);
lws_smd: take care about build with disabled
2020-08-16 05:35:56 +01:00
#endif
lws_netdev: use lws_settings Perform the AP selection using lws_settings and a generic scan state machine
2020-07-02 15:38:53 +01:00
void
lws_netdev_instance_create(lws_netdev_instance_t *ni, struct lws_context *ctx,
const lws_netdev_ops_t *ops, const char *name,
void *platinfo);
int
lws_netdev_wifi_rssi_sort_compare(const lws_dll2_t *d, const lws_dll2_t *i);
void
lws_netdev_wifi_scan_empty(lws_netdev_instance_wifi_t *wnd);
lws_wifi_sta_t *
lws_netdev_wifi_scan_find(lws_netdev_instance_wifi_t *wnd, const char *ssid,
const uint8_t *bssid);
int
lws_netdev_wifi_scan_select(lws_netdev_instance_wifi_t *wnd);
lws_wifi_creds_t *
lws_netdev_credentials_find(lws_netdevs_t *netdevs, const char *ssid,
const uint8_t *bssid);
int
lws_netdev_wifi_redo_last(lws_netdev_instance_wifi_t *wnd);
void
lws_ntpc_trigger(struct lws_context *ctx);
void
lws_netdev_wifi_scan(lws_sorted_usec_list_t *sul);
#define lws_netdevs_from_ndi(ni) \
lws_container_of((ni)->list.owner, lws_netdevs_t, owner)
#define lws_context_from_netdevs(nd) \
lws_container_of(nd, struct lws_context, netdevs)
/* get the owner of the ni, then compute the context the owner is embedded in */
#define netdev_instance_to_ctx(ni) \
lws_container_of(lws_netdevs_from_ndi(ni), \
struct lws_context, netdevs)
mbedtls: attempt to remove dependency on net_sockets.c The mbedtls openssl wrapper wants to use exports from mbedtls' net_sockets.c, but this is only supposed to work on *nix and windows. Typically people are using mbedtls on RTOS type platforms and to use it, net_sockets.c needs some hacking. Try to avoid that situation by porting the two exports we need into the lws plat code and call from the wrapper.
2020-03-27 13:24:44 +00:00
socks5: cleanup and add test options Refactor SOCKS5 client support to be gathered into lib/core-net/socks5-client.c and make that build contingent on LWS_WITH_SOCKS5.
2020-02-18 14:27:27 +00:00
enum {
LW5CHS_RET_RET0,
LW5CHS_RET_BAIL3,
LW5CHS_RET_STARTHS,
LW5CHS_RET_NOTHING
};
clean: client connect
2020-09-19 19:36:38 +01:00
void
lws_4to6(uint8_t *v6addr, const uint8_t *v4addr);
void
lws_sa46_4to6(lws_sockaddr46 *sa46, const uint8_t *v4addr, uint16_t port);
LWS_WITH_NETWORK: cmake option for no network code
2019-01-13 06:58:21 +08:00
#ifdef __cplusplus
};
#endif
#endif
Reference in a new issue Copy permalink