2014-04-03 07:36:41 +08:00
|
|
|
/*
|
|
|
|
|
* libwebsockets - small server side websockets and web server implementation
|
|
|
|
|
*
|
2021-06-06 07:22:28 +01:00
|
|
|
* Copyright (C) 2010 - 2021 Andy Green <andy@warmcat.com>
|
2014-04-03 07:36:41 +08:00
|
|
|
*
|
2019-08-14 10:44:14 +01:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
|
* of this software and associated documentation files (the "Software"), to
|
|
|
|
|
* deal in the Software without restriction, including without limitation the
|
|
|
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
|
|
|
* furnished to do so, subject to the following conditions:
|
2014-04-03 07:36:41 +08:00
|
|
|
*
|
2019-08-14 10:44:14 +01:00
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
|
* all copies or substantial portions of the Software.
|
2014-04-03 07:36:41 +08:00
|
|
|
*
|
2019-08-14 10:44:14 +01:00
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
|
* IN THE SOFTWARE.
|
2014-04-03 07:36:41 +08:00
|
|
|
*/
|
|
|
|
|
|
2019-08-15 10:49:52 +01:00
|
|
|
#include "private-lib-core.h"
|
2014-04-03 07:36:41 +08:00
|
|
|
|
2021-08-10 06:35:59 +01:00
|
|
|
#if defined(_DEBUG)
|
|
|
|
|
void
|
|
|
|
|
lws_service_assert_loop_thread(struct lws_context *cx, int tsi)
|
|
|
|
|
{
|
|
|
|
|
if (!cx->event_loop_ops->foreign_thread)
|
|
|
|
|
/* we can't judge it */
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (!cx->event_loop_ops->foreign_thread(cx, tsi))
|
|
|
|
|
/* OK */
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Lws apis are NOT THREADSAFE with the sole exception of
|
|
|
|
|
* lws_cancel_service(). If you look at the assert backtrace, you
|
|
|
|
|
* should see you're illegally calling an lws api from another thread.
|
|
|
|
|
*/
|
|
|
|
|
assert(0);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
int
|
|
|
|
|
lws_callback_as_writeable(struct lws *wsi)
|
2014-10-22 15:37:28 +08:00
|
|
|
{
|
2017-12-07 07:20:47 +08:00
|
|
|
int n, m;
|
2014-10-22 15:37:28 +08:00
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
n = wsi->role_ops->writeable_cb[lwsi_role_server(wsi)];
|
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
|
|
|
m = user_callback_handle_rxflow(wsi->a.protocol->callback,
|
2018-04-11 13:39:42 +08:00
|
|
|
wsi, (enum lws_callback_reasons) n,
|
|
|
|
|
wsi->user_space, NULL, 0);
|
2017-12-07 07:20:47 +08:00
|
|
|
|
|
|
|
|
return m;
|
2014-10-22 15:37:28 +08:00
|
|
|
}
|
|
|
|
|
|
2020-01-02 08:32:23 +00:00
|
|
|
int
|
2015-12-15 21:15:58 +08:00
|
|
|
lws_handle_POLLOUT_event(struct lws *wsi, struct lws_pollfd *pollfd)
|
2014-04-03 07:36:41 +08:00
|
|
|
{
|
2017-11-12 09:16:46 +08:00
|
|
|
volatile struct lws *vwsi = (volatile struct lws *)wsi;
|
2018-04-11 13:39:42 +08:00
|
|
|
int n;
|
2018-03-27 09:17:19 +08:00
|
|
|
|
2021-02-15 14:17:52 +00:00
|
|
|
if (wsi->socket_is_permanently_unusable)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2017-11-12 09:16:46 +08:00
|
|
|
vwsi->leave_pollout_active = 0;
|
|
|
|
|
vwsi->handling_pollout = 1;
|
2017-04-05 08:30:55 +08:00
|
|
|
/*
|
|
|
|
|
* if another thread wants POLLOUT on us, from here on while
|
|
|
|
|
* handling_pollout is set, he will only set leave_pollout_active.
|
|
|
|
|
* If we are going to disable POLLOUT, we will check that first.
|
|
|
|
|
*/
|
2018-04-11 13:39:42 +08:00
|
|
|
wsi->could_have_pending = 0; /* clear back-to-back write detection */
|
2017-04-05 08:30:55 +08:00
|
|
|
|
2016-01-11 11:34:01 +08:00
|
|
|
/*
|
|
|
|
|
* user callback is lowest priority to get these notifications
|
|
|
|
|
* actually, since other pending things cannot be disordered
|
2018-04-11 13:39:42 +08:00
|
|
|
*
|
|
|
|
|
* Priority 1: pending truncated sends are incomplete ws fragments
|
2016-01-11 11:34:01 +08:00
|
|
|
* If anything else sent first the protocol would be
|
|
|
|
|
* corrupted.
|
http: compression methods
Add generic http compression layer eanbled at cmake with LWS_WITH_HTTP_STREAM_COMPRESSION.
This is wholly a feature of the HTTP role (used by h1 and h2 roles) and doesn't exist
outside that context.
Currently provides 'deflate' and 'br' compression methods for server side only.
'br' requires also -DLWS_WITH_HTTP_BROTLI=1 at cmake and the brotli libraries (available in
your distro already) and dev package.
Other compression methods can be added nicely using an ops struct.
The built-in file serving stuff will use this is the client says he can handle it, and the
mimetype of the file either starts with "text/" (html and css etc) or is the mimetype of
Javascript.
zlib allocates quite a bit while in use, it seems to be around 256KiB per stream. So this
is only useful on relatively strong servers with lots of memory. However for some usecases
where you are serving a lot of css and js assets, it's a nice help.
The patch performs special treatment for http/1.1 pipelining, since the compression is
performed on the fly the compressed content-length is not known until the end. So for h1
only, chunked transfer-encoding is automatically added so pipelining can continue of the
connection.
For h2 the chunking is neither supported nor required, so it "just works".
User code can also request to add a compression transform before the reply headers were
sent using the new api
LWS_VISIBLE int
lws_http_compression_apply(struct lws *wsi, const char *name,
unsigned char **p, unsigned char *end, char decomp);
... this allows transparent compression of dynamically generated HTTP. The requested
compression (eg, "deflate") is only applied if the client headers indicated it was
supported, otherwise it's a NOP.
Name may be NULL in which case the first compression method in the internal table at
stream.c that is mentioned as acceptable by the client will be used.
NOTE: the compression translation, same as h2 support, relies on the user code using
LWS_WRITE_HTTP and then LWS_WRITE_HTTP_FINAL on the last part written. The internal
lws fileserving code already does this.
2018-09-02 14:43:05 +08:00
|
|
|
*
|
|
|
|
|
* These are post- any compression transform
|
2016-01-11 11:34:01 +08:00
|
|
|
*/
|
2018-04-11 13:39:42 +08:00
|
|
|
|
2018-08-20 12:02:26 +08:00
|
|
|
if (lws_has_buffered_out(wsi)) {
|
|
|
|
|
if (lws_issue_raw(wsi, NULL, 0) < 0) {
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_info(wsi, "signalling to close");
|
2017-04-05 08:30:55 +08:00
|
|
|
goto bail_die;
|
2014-04-10 14:25:24 +08:00
|
|
|
}
|
2014-04-03 07:36:41 +08:00
|
|
|
/* leave POLLOUT active either way */
|
2017-04-05 08:30:55 +08:00
|
|
|
goto bail_ok;
|
2014-04-10 17:06:59 +08:00
|
|
|
} else
|
2018-04-02 11:55:17 +08:00
|
|
|
if (lwsi_state(wsi) == LRS_FLUSHING_BEFORE_CLOSE) {
|
2017-05-07 08:19:55 +08:00
|
|
|
wsi->socket_is_permanently_unusable = 1;
|
2017-04-05 08:30:55 +08:00
|
|
|
goto bail_die; /* retry closing now */
|
2017-05-07 08:19:55 +08:00
|
|
|
}
|
2015-12-15 21:15:58 +08:00
|
|
|
|
http: compression methods
Add generic http compression layer eanbled at cmake with LWS_WITH_HTTP_STREAM_COMPRESSION.
This is wholly a feature of the HTTP role (used by h1 and h2 roles) and doesn't exist
outside that context.
Currently provides 'deflate' and 'br' compression methods for server side only.
'br' requires also -DLWS_WITH_HTTP_BROTLI=1 at cmake and the brotli libraries (available in
your distro already) and dev package.
Other compression methods can be added nicely using an ops struct.
The built-in file serving stuff will use this is the client says he can handle it, and the
mimetype of the file either starts with "text/" (html and css etc) or is the mimetype of
Javascript.
zlib allocates quite a bit while in use, it seems to be around 256KiB per stream. So this
is only useful on relatively strong servers with lots of memory. However for some usecases
where you are serving a lot of css and js assets, it's a nice help.
The patch performs special treatment for http/1.1 pipelining, since the compression is
performed on the fly the compressed content-length is not known until the end. So for h1
only, chunked transfer-encoding is automatically added so pipelining can continue of the
connection.
For h2 the chunking is neither supported nor required, so it "just works".
User code can also request to add a compression transform before the reply headers were
sent using the new api
LWS_VISIBLE int
lws_http_compression_apply(struct lws *wsi, const char *name,
unsigned char **p, unsigned char *end, char decomp);
... this allows transparent compression of dynamically generated HTTP. The requested
compression (eg, "deflate") is only applied if the client headers indicated it was
supported, otherwise it's a NOP.
Name may be NULL in which case the first compression method in the internal table at
stream.c that is mentioned as acceptable by the client will be used.
NOTE: the compression translation, same as h2 support, relies on the user code using
LWS_WRITE_HTTP and then LWS_WRITE_HTTP_FINAL on the last part written. The internal
lws fileserving code already does this.
2018-09-02 14:43:05 +08:00
|
|
|
/* Priority 2: pre- compression transform */
|
|
|
|
|
|
|
|
|
|
#if defined(LWS_WITH_HTTP_STREAM_COMPRESSION)
|
|
|
|
|
if (wsi->http.comp_ctx.buflist_comp ||
|
|
|
|
|
wsi->http.comp_ctx.may_have_more) {
|
|
|
|
|
enum lws_write_protocol wp = LWS_WRITE_HTTP;
|
|
|
|
|
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_info(wsi, "compl comp partial (buflist_comp %p, may %d)",
|
|
|
|
|
wsi->http.comp_ctx.buflist_comp,
|
|
|
|
|
wsi->http.comp_ctx.may_have_more);
|
http: compression methods
Add generic http compression layer eanbled at cmake with LWS_WITH_HTTP_STREAM_COMPRESSION.
This is wholly a feature of the HTTP role (used by h1 and h2 roles) and doesn't exist
outside that context.
Currently provides 'deflate' and 'br' compression methods for server side only.
'br' requires also -DLWS_WITH_HTTP_BROTLI=1 at cmake and the brotli libraries (available in
your distro already) and dev package.
Other compression methods can be added nicely using an ops struct.
The built-in file serving stuff will use this is the client says he can handle it, and the
mimetype of the file either starts with "text/" (html and css etc) or is the mimetype of
Javascript.
zlib allocates quite a bit while in use, it seems to be around 256KiB per stream. So this
is only useful on relatively strong servers with lots of memory. However for some usecases
where you are serving a lot of css and js assets, it's a nice help.
The patch performs special treatment for http/1.1 pipelining, since the compression is
performed on the fly the compressed content-length is not known until the end. So for h1
only, chunked transfer-encoding is automatically added so pipelining can continue of the
connection.
For h2 the chunking is neither supported nor required, so it "just works".
User code can also request to add a compression transform before the reply headers were
sent using the new api
LWS_VISIBLE int
lws_http_compression_apply(struct lws *wsi, const char *name,
unsigned char **p, unsigned char *end, char decomp);
... this allows transparent compression of dynamically generated HTTP. The requested
compression (eg, "deflate") is only applied if the client headers indicated it was
supported, otherwise it's a NOP.
Name may be NULL in which case the first compression method in the internal table at
stream.c that is mentioned as acceptable by the client will be used.
NOTE: the compression translation, same as h2 support, relies on the user code using
LWS_WRITE_HTTP and then LWS_WRITE_HTTP_FINAL on the last part written. The internal
lws fileserving code already does this.
2018-09-02 14:43:05 +08:00
|
|
|
|
roles: compress role ops structs
role ops are usually only sparsely filled, there are currently 20
function pointers but several roles only fill in two. No single
role has more than 14 of the ops. On a 32/64 bit build this part
of the ops struct takes a fixed 80 / 160 bytes then.
First reduce the type of the callback reason part from uint16_t to
uint8_t, this saves 12 bytes unconditionally.
Change to a separate function pointer array with a nybble index
array, it costs 10 bytes for the index and a pointer to the
separate array, for 32-bit the cost is
2 + (4 x ops_used)
and for 64-bit
6 + (8 x ops_used)
for 2 x ops_used it means 32-bit: 10 vs 80 / 64-bit: 22 vs 160
For a typical system with h1 (9), h2 (14), listen (2), netlink (2),
pipe (1), raw_skt (3), ws (12), == 43 ops_used out of 140, it means
the .rodata for this reduced from 32-bit: 560 -> 174 (386 byte
saving) and 64-bit: 1120 -> 350 (770 byte saving)
This doesn't account for the changed function ops calling code, two
ways were tried, a preprocessor macro and explicit functions
For an x86_64 gcc 10 build with most options, release mode,
.text + .rodata
before patch: 553282
accessor macro: 552714 (568 byte saving)
accessor functions: 553674 (392 bytes worse than without patch)
therefore we went with the macros
2020-10-19 13:55:21 +01:00
|
|
|
if (lws_rops_fidx(wsi->role_ops, LWS_ROPS_write_role_protocol) &&
|
|
|
|
|
lws_rops_func_fidx(wsi->role_ops, LWS_ROPS_write_role_protocol).
|
|
|
|
|
write_role_protocol(wsi, NULL, 0, &wp) < 0) {
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_info(wsi, "signalling to close");
|
http: compression methods
Add generic http compression layer eanbled at cmake with LWS_WITH_HTTP_STREAM_COMPRESSION.
This is wholly a feature of the HTTP role (used by h1 and h2 roles) and doesn't exist
outside that context.
Currently provides 'deflate' and 'br' compression methods for server side only.
'br' requires also -DLWS_WITH_HTTP_BROTLI=1 at cmake and the brotli libraries (available in
your distro already) and dev package.
Other compression methods can be added nicely using an ops struct.
The built-in file serving stuff will use this is the client says he can handle it, and the
mimetype of the file either starts with "text/" (html and css etc) or is the mimetype of
Javascript.
zlib allocates quite a bit while in use, it seems to be around 256KiB per stream. So this
is only useful on relatively strong servers with lots of memory. However for some usecases
where you are serving a lot of css and js assets, it's a nice help.
The patch performs special treatment for http/1.1 pipelining, since the compression is
performed on the fly the compressed content-length is not known until the end. So for h1
only, chunked transfer-encoding is automatically added so pipelining can continue of the
connection.
For h2 the chunking is neither supported nor required, so it "just works".
User code can also request to add a compression transform before the reply headers were
sent using the new api
LWS_VISIBLE int
lws_http_compression_apply(struct lws *wsi, const char *name,
unsigned char **p, unsigned char *end, char decomp);
... this allows transparent compression of dynamically generated HTTP. The requested
compression (eg, "deflate") is only applied if the client headers indicated it was
supported, otherwise it's a NOP.
Name may be NULL in which case the first compression method in the internal table at
stream.c that is mentioned as acceptable by the client will be used.
NOTE: the compression translation, same as h2 support, relies on the user code using
LWS_WRITE_HTTP and then LWS_WRITE_HTTP_FINAL on the last part written. The internal
lws fileserving code already does this.
2018-09-02 14:43:05 +08:00
|
|
|
goto bail_die;
|
|
|
|
|
}
|
|
|
|
|
lws_callback_on_writable(wsi);
|
|
|
|
|
|
|
|
|
|
goto bail_ok;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
#ifdef LWS_WITH_CGI
|
2017-09-23 12:55:21 +08:00
|
|
|
/*
|
2020-10-11 07:43:46 +01:00
|
|
|
* A cgi connection's wire protocol remains h1 or h2. He is just
|
|
|
|
|
* getting his data from his child cgis.
|
2016-01-11 11:34:01 +08:00
|
|
|
*/
|
2018-04-27 19:16:50 +08:00
|
|
|
if (wsi->http.cgi) {
|
2017-03-22 20:15:01 +08:00
|
|
|
/* also one shot */
|
|
|
|
|
if (pollfd)
|
|
|
|
|
if (lws_change_pollfd(wsi, LWS_POLLOUT, 0)) {
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_info(wsi, "failed at set pollfd");
|
2017-03-22 20:15:01 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
2016-04-13 11:42:53 +08:00
|
|
|
goto user_service_go_again;
|
2017-03-22 20:15:01 +08:00
|
|
|
}
|
2016-04-13 11:42:53 +08:00
|
|
|
#endif
|
|
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
/* if we got here, we should have wire protocol ops set on the wsi */
|
|
|
|
|
assert(wsi->role_ops);
|
2016-07-15 13:41:38 +08:00
|
|
|
|
roles: compress role ops structs
role ops are usually only sparsely filled, there are currently 20
function pointers but several roles only fill in two. No single
role has more than 14 of the ops. On a 32/64 bit build this part
of the ops struct takes a fixed 80 / 160 bytes then.
First reduce the type of the callback reason part from uint16_t to
uint8_t, this saves 12 bytes unconditionally.
Change to a separate function pointer array with a nybble index
array, it costs 10 bytes for the index and a pointer to the
separate array, for 32-bit the cost is
2 + (4 x ops_used)
and for 64-bit
6 + (8 x ops_used)
for 2 x ops_used it means 32-bit: 10 vs 80 / 64-bit: 22 vs 160
For a typical system with h1 (9), h2 (14), listen (2), netlink (2),
pipe (1), raw_skt (3), ws (12), == 43 ops_used out of 140, it means
the .rodata for this reduced from 32-bit: 560 -> 174 (386 byte
saving) and 64-bit: 1120 -> 350 (770 byte saving)
This doesn't account for the changed function ops calling code, two
ways were tried, a preprocessor macro and explicit functions
For an x86_64 gcc 10 build with most options, release mode,
.text + .rodata
before patch: 553282
accessor macro: 552714 (568 byte saving)
accessor functions: 553674 (392 bytes worse than without patch)
therefore we went with the macros
2020-10-19 13:55:21 +01:00
|
|
|
if (!lws_rops_fidx(wsi->role_ops, LWS_ROPS_handle_POLLOUT))
|
2017-04-05 08:30:55 +08:00
|
|
|
goto bail_ok;
|
2015-12-14 08:52:03 +08:00
|
|
|
|
roles: compress role ops structs
role ops are usually only sparsely filled, there are currently 20
function pointers but several roles only fill in two. No single
role has more than 14 of the ops. On a 32/64 bit build this part
of the ops struct takes a fixed 80 / 160 bytes then.
First reduce the type of the callback reason part from uint16_t to
uint8_t, this saves 12 bytes unconditionally.
Change to a separate function pointer array with a nybble index
array, it costs 10 bytes for the index and a pointer to the
separate array, for 32-bit the cost is
2 + (4 x ops_used)
and for 64-bit
6 + (8 x ops_used)
for 2 x ops_used it means 32-bit: 10 vs 80 / 64-bit: 22 vs 160
For a typical system with h1 (9), h2 (14), listen (2), netlink (2),
pipe (1), raw_skt (3), ws (12), == 43 ops_used out of 140, it means
the .rodata for this reduced from 32-bit: 560 -> 174 (386 byte
saving) and 64-bit: 1120 -> 350 (770 byte saving)
This doesn't account for the changed function ops calling code, two
ways were tried, a preprocessor macro and explicit functions
For an x86_64 gcc 10 build with most options, release mode,
.text + .rodata
before patch: 553282
accessor macro: 552714 (568 byte saving)
accessor functions: 553674 (392 bytes worse than without patch)
therefore we went with the macros
2020-10-19 13:55:21 +01:00
|
|
|
n = lws_rops_func_fidx(wsi->role_ops, LWS_ROPS_handle_POLLOUT).
|
|
|
|
|
handle_POLLOUT(wsi);
|
2020-02-25 13:28:25 +00:00
|
|
|
switch (n) {
|
2018-04-11 13:39:42 +08:00
|
|
|
case LWS_HP_RET_BAIL_OK:
|
2017-04-05 08:30:55 +08:00
|
|
|
goto bail_ok;
|
2018-04-11 13:39:42 +08:00
|
|
|
case LWS_HP_RET_BAIL_DIE:
|
2017-04-05 08:30:55 +08:00
|
|
|
goto bail_die;
|
2020-02-25 13:28:25 +00:00
|
|
|
case LWS_HP_RET_DROP_POLLOUT:
|
2018-04-11 13:39:42 +08:00
|
|
|
case LWS_HP_RET_USER_SERVICE:
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
assert(0);
|
2014-04-03 07:36:41 +08:00
|
|
|
}
|
2018-03-19 08:10:32 +08:00
|
|
|
|
2014-04-03 07:36:41 +08:00
|
|
|
/* one shot */
|
|
|
|
|
|
2017-04-05 08:30:55 +08:00
|
|
|
if (pollfd) {
|
2017-11-12 09:16:46 +08:00
|
|
|
int eff = vwsi->leave_pollout_active;
|
2017-04-05 08:30:55 +08:00
|
|
|
|
2018-04-17 11:43:20 +08:00
|
|
|
if (!eff) {
|
2017-04-05 08:30:55 +08:00
|
|
|
if (lws_change_pollfd(wsi, LWS_POLLOUT, 0)) {
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_info(wsi, "failed at set pollfd");
|
2017-04-05 08:30:55 +08:00
|
|
|
goto bail_die;
|
|
|
|
|
}
|
2018-04-17 11:43:20 +08:00
|
|
|
}
|
2017-04-05 08:30:55 +08:00
|
|
|
|
2017-11-12 09:16:46 +08:00
|
|
|
vwsi->handling_pollout = 0;
|
2017-04-05 08:30:55 +08:00
|
|
|
|
|
|
|
|
/* cannot get leave_pollout_active set after the above */
|
2018-02-20 12:07:10 +08:00
|
|
|
if (!eff && wsi->leave_pollout_active) {
|
|
|
|
|
/*
|
|
|
|
|
* got set inbetween sampling eff and clearing
|
|
|
|
|
* handling_pollout, force POLLOUT on
|
|
|
|
|
*/
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "leave_pollout_active");
|
2018-02-20 12:07:10 +08:00
|
|
|
if (lws_change_pollfd(wsi, 0, LWS_POLLOUT)) {
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_info(wsi, "failed at set pollfd");
|
2018-02-20 12:07:10 +08:00
|
|
|
goto bail_die;
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-04-05 08:30:55 +08:00
|
|
|
|
2017-11-12 09:16:46 +08:00
|
|
|
vwsi->leave_pollout_active = 0;
|
2017-04-05 08:30:55 +08:00
|
|
|
}
|
2014-04-11 13:14:37 +08:00
|
|
|
|
2018-11-29 08:29:48 +08:00
|
|
|
if (lwsi_role_client(wsi) && !wsi->hdr_parsing_completed &&
|
2018-04-17 11:43:20 +08:00
|
|
|
lwsi_state(wsi) != LRS_H2_WAITING_TO_SEND_HEADERS &&
|
2018-11-29 08:29:48 +08:00
|
|
|
lwsi_state(wsi) != LRS_ISSUE_HTTP_BODY)
|
2017-04-05 08:30:55 +08:00
|
|
|
goto bail_ok;
|
|
|
|
|
|
2020-02-25 13:28:25 +00:00
|
|
|
if (n == LWS_HP_RET_DROP_POLLOUT)
|
|
|
|
|
goto bail_ok;
|
|
|
|
|
|
2016-02-27 11:42:22 +08:00
|
|
|
|
2016-04-13 11:42:53 +08:00
|
|
|
#ifdef LWS_WITH_CGI
|
|
|
|
|
user_service_go_again:
|
|
|
|
|
#endif
|
|
|
|
|
|
roles: compress role ops structs
role ops are usually only sparsely filled, there are currently 20
function pointers but several roles only fill in two. No single
role has more than 14 of the ops. On a 32/64 bit build this part
of the ops struct takes a fixed 80 / 160 bytes then.
First reduce the type of the callback reason part from uint16_t to
uint8_t, this saves 12 bytes unconditionally.
Change to a separate function pointer array with a nybble index
array, it costs 10 bytes for the index and a pointer to the
separate array, for 32-bit the cost is
2 + (4 x ops_used)
and for 64-bit
6 + (8 x ops_used)
for 2 x ops_used it means 32-bit: 10 vs 80 / 64-bit: 22 vs 160
For a typical system with h1 (9), h2 (14), listen (2), netlink (2),
pipe (1), raw_skt (3), ws (12), == 43 ops_used out of 140, it means
the .rodata for this reduced from 32-bit: 560 -> 174 (386 byte
saving) and 64-bit: 1120 -> 350 (770 byte saving)
This doesn't account for the changed function ops calling code, two
ways were tried, a preprocessor macro and explicit functions
For an x86_64 gcc 10 build with most options, release mode,
.text + .rodata
before patch: 553282
accessor macro: 552714 (568 byte saving)
accessor functions: 553674 (392 bytes worse than without patch)
therefore we went with the macros
2020-10-19 13:55:21 +01:00
|
|
|
if (lws_rops_fidx(wsi->role_ops, LWS_ROPS_perform_user_POLLOUT)) {
|
|
|
|
|
if (lws_rops_func_fidx(wsi->role_ops,
|
|
|
|
|
LWS_ROPS_perform_user_POLLOUT).
|
|
|
|
|
perform_user_POLLOUT(wsi) == -1)
|
2018-04-11 13:39:42 +08:00
|
|
|
goto bail_die;
|
2017-10-13 10:33:02 +08:00
|
|
|
else
|
2018-04-11 13:39:42 +08:00
|
|
|
goto bail_ok;
|
2017-10-13 10:33:02 +08:00
|
|
|
}
|
2019-08-19 09:31:17 +02:00
|
|
|
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "non mux: wsistate 0x%lx, ops %s",
|
|
|
|
|
(unsigned long)wsi->wsistate, wsi->role_ops->name);
|
2018-03-11 11:26:06 +08:00
|
|
|
|
2017-11-12 09:16:46 +08:00
|
|
|
vwsi = (volatile struct lws *)wsi;
|
|
|
|
|
vwsi->leave_pollout_active = 0;
|
2017-04-05 08:30:55 +08:00
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
n = lws_callback_as_writeable(wsi);
|
2017-11-12 09:16:46 +08:00
|
|
|
vwsi->handling_pollout = 0;
|
2017-11-05 07:03:13 +08:00
|
|
|
|
2017-11-12 09:16:46 +08:00
|
|
|
if (vwsi->leave_pollout_active)
|
2019-07-13 12:06:33 -07:00
|
|
|
if (lws_change_pollfd(wsi, 0, LWS_POLLOUT))
|
|
|
|
|
goto bail_die;
|
2017-11-05 07:03:13 +08:00
|
|
|
|
|
|
|
|
return n;
|
2017-04-05 08:30:55 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* since these don't disable the POLLOUT, they are always doing the
|
|
|
|
|
* right thing for leave_pollout_active whether it was set or not.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
bail_ok:
|
2017-11-12 09:16:46 +08:00
|
|
|
vwsi->handling_pollout = 0;
|
|
|
|
|
vwsi->leave_pollout_active = 0;
|
2017-04-05 08:30:55 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
bail_die:
|
2017-11-12 09:16:46 +08:00
|
|
|
vwsi->handling_pollout = 0;
|
|
|
|
|
vwsi->leave_pollout_active = 0;
|
2017-04-05 08:30:55 +08:00
|
|
|
|
|
|
|
|
return -1;
|
2014-04-03 07:36:41 +08:00
|
|
|
}
|
|
|
|
|
|
2019-04-19 07:13:40 +01:00
|
|
|
int
|
2020-12-12 06:21:40 +00:00
|
|
|
lws_rxflow_cache(struct lws *wsi, unsigned char *buf, size_t n, size_t len)
|
2014-10-08 12:00:53 +08:00
|
|
|
{
|
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_context_per_thread *pt = &wsi->a.context->pt[(int)wsi->tsi];
|
2018-04-13 16:01:38 +08:00
|
|
|
uint8_t *buffered;
|
|
|
|
|
size_t blen;
|
2019-04-19 07:13:40 +01:00
|
|
|
int ret = LWSRXFC_CACHED, m;
|
2018-04-13 16:01:38 +08:00
|
|
|
|
2014-10-08 12:00:53 +08:00
|
|
|
/* his RX is flowcontrolled, don't send remaining now */
|
2018-04-17 15:35:15 +08:00
|
|
|
blen = lws_buflist_next_segment_len(&wsi->buflist, &buffered);
|
2018-04-13 16:01:38 +08:00
|
|
|
if (blen) {
|
2019-07-01 05:53:08 +01:00
|
|
|
if (buf >= buffered && buf + len <= buffered + blen &&
|
|
|
|
|
blen != (size_t)len) {
|
2019-04-19 07:13:40 +01:00
|
|
|
/*
|
|
|
|
|
* rxflow while we were spilling prev rxflow
|
|
|
|
|
*
|
|
|
|
|
* len indicates how much was unused, then... so trim
|
|
|
|
|
* the head buflist to match that situation
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
lws_buflist_use_segment(&wsi->buflist, blen - len);
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "trim existing rxflow %d -> %d",
|
|
|
|
|
(int)blen, (int)len);
|
2018-04-13 16:01:38 +08:00
|
|
|
|
2019-04-19 07:13:40 +01:00
|
|
|
return LWSRXFC_TRIMMED;
|
2017-10-13 10:33:02 +08:00
|
|
|
}
|
2019-04-19 07:13:40 +01:00
|
|
|
ret = LWSRXFC_ADDITIONAL;
|
2014-10-08 12:00:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* a new rxflow, buffer it and warn caller */
|
2017-09-23 12:55:21 +08:00
|
|
|
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "rxflow append %d", (int)(len - n));
|
2018-04-17 15:35:15 +08:00
|
|
|
m = lws_buflist_append_segment(&wsi->buflist, buf + n, len - n);
|
2018-04-17 11:43:20 +08:00
|
|
|
|
2018-04-13 16:01:38 +08:00
|
|
|
if (m < 0)
|
2019-04-19 07:13:40 +01:00
|
|
|
return LWSRXFC_ERROR;
|
2018-04-17 11:43:20 +08:00
|
|
|
if (m) {
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "added to rxflow list");;
|
2019-09-11 14:43:09 +01:00
|
|
|
if (lws_dll2_is_detached(&wsi->dll_buflist))
|
|
|
|
|
lws_dll2_add_head(&wsi->dll_buflist, &pt->dll_buflist_owner);
|
2018-04-17 11:43:20 +08:00
|
|
|
}
|
2014-10-08 12:00:53 +08:00
|
|
|
|
2018-04-13 16:01:38 +08:00
|
|
|
return ret;
|
2014-10-08 12:00:53 +08:00
|
|
|
}
|
|
|
|
|
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
/* this is used by the platform service code to stop us waiting for network
|
|
|
|
|
* activity in poll() when we have something that already needs service
|
|
|
|
|
*/
|
|
|
|
|
|
2020-01-02 08:32:23 +00:00
|
|
|
int
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
lws_service_adjust_timeout(struct lws_context *context, int timeout_ms, int tsi)
|
|
|
|
|
{
|
2019-08-19 09:31:17 +02:00
|
|
|
struct lws_context_per_thread *pt;
|
|
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
|
return 1;
|
|
|
|
|
|
2020-12-23 14:59:00 +00:00
|
|
|
if (!context->protocol_init_done)
|
|
|
|
|
if (lws_protocol_init(context))
|
|
|
|
|
return 1;
|
|
|
|
|
|
2020-06-24 20:15:46 +01:00
|
|
|
#if defined(LWS_WITH_SYS_SMD)
|
|
|
|
|
if (!tsi && lws_smd_message_pending(context)) {
|
|
|
|
|
lws_smd_msg_distribute(context);
|
|
|
|
|
if (lws_smd_message_pending(context))
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2019-08-19 09:31:17 +02:00
|
|
|
pt = &context->pt[tsi];
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
|
2021-06-06 07:22:28 +01:00
|
|
|
if (pt->evlib_pt) {
|
2021-05-26 09:13:03 +01:00
|
|
|
lws_usec_t u;
|
|
|
|
|
|
|
|
|
|
lws_pt_lock(pt, __func__); /* -------------- pt { */
|
|
|
|
|
|
|
|
|
|
u = __lws_sul_service_ripe(pt->pt_sul_owner,
|
2020-09-18 09:19:04 +01:00
|
|
|
LWS_COUNT_PT_SUL_OWNERS, lws_now_usecs());
|
2021-12-14 06:56:45 +00:00
|
|
|
/*
|
|
|
|
|
* We will come back with 0 if nothing to do at the moment, or
|
|
|
|
|
* the number of us until something to do
|
|
|
|
|
*/
|
|
|
|
|
if (u && u < (lws_usec_t)timeout_ms * (lws_usec_t)1000)
|
2021-06-06 07:22:28 +01:00
|
|
|
timeout_ms = (int)(u / 1000);
|
2021-05-26 09:13:03 +01:00
|
|
|
|
|
|
|
|
lws_pt_unlock(pt);
|
2020-09-18 09:19:04 +01:00
|
|
|
}
|
|
|
|
|
|
2018-09-02 14:35:37 +08:00
|
|
|
/*
|
|
|
|
|
* Figure out if we really want to wait in poll()... we only need to
|
|
|
|
|
* wait if really nothing already to do and we have to wait for
|
|
|
|
|
* something from network
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
*/
|
2018-04-25 08:42:18 +08:00
|
|
|
#if defined(LWS_ROLE_WS) && !defined(LWS_WITHOUT_EXTENSIONS)
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
/* 1) if we know we are draining rx ext, do not wait in poll */
|
2018-04-25 08:42:18 +08:00
|
|
|
if (pt->ws.rx_draining_ext_list)
|
2016-04-06 08:36:30 +08:00
|
|
|
return 0;
|
2018-04-19 12:53:53 +08:00
|
|
|
#endif
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
|
2019-01-13 06:58:21 +08:00
|
|
|
#if defined(LWS_WITH_TLS)
|
2018-11-23 08:47:56 +08:00
|
|
|
/* 2) if we know we have non-network pending data,
|
|
|
|
|
* do not wait in poll */
|
2018-05-01 12:41:42 +08:00
|
|
|
|
|
|
|
|
if (pt->context->tls_ops &&
|
2018-09-02 14:35:37 +08:00
|
|
|
pt->context->tls_ops->fake_POLLIN_for_buffered &&
|
|
|
|
|
pt->context->tls_ops->fake_POLLIN_for_buffered(pt))
|
2018-05-01 12:41:42 +08:00
|
|
|
return 0;
|
2019-01-13 06:58:21 +08:00
|
|
|
#endif
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
|
2019-06-24 07:15:50 +01:00
|
|
|
/*
|
|
|
|
|
* 4) If there is any wsi with rxflow buffered and in a state to process
|
2018-04-17 15:35:15 +08:00
|
|
|
* it, we should not wait in poll
|
|
|
|
|
*/
|
|
|
|
|
|
2019-04-21 06:24:05 +01:00
|
|
|
lws_start_foreach_dll(struct lws_dll2 *, d, pt->dll_buflist_owner.head) {
|
2018-04-17 15:35:15 +08:00
|
|
|
struct lws *wsi = lws_container_of(d, struct lws, dll_buflist);
|
|
|
|
|
|
2019-04-21 06:24:05 +01:00
|
|
|
if (!lws_is_flowcontrolled(wsi) &&
|
|
|
|
|
lwsi_state(wsi) != LRS_DEFERRING_ACTION)
|
2016-04-06 08:36:30 +08:00
|
|
|
return 0;
|
2018-04-17 15:35:15 +08:00
|
|
|
|
2018-09-02 14:35:37 +08:00
|
|
|
/*
|
2019-06-24 07:15:50 +01:00
|
|
|
* 5) If any guys with http compression to spill, we shouldn't wait in
|
2018-09-02 14:35:37 +08:00
|
|
|
* poll but hurry along and service them
|
|
|
|
|
*/
|
|
|
|
|
|
2018-04-17 15:35:15 +08:00
|
|
|
} lws_end_foreach_dll(d);
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
|
|
|
|
|
return timeout_ms;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-30 19:17:32 +08:00
|
|
|
/*
|
|
|
|
|
* POLLIN said there is something... we must read it, and either use it; or
|
|
|
|
|
* if other material already in the buflist append it and return the buflist
|
|
|
|
|
* head material.
|
|
|
|
|
*/
|
2018-04-11 13:39:42 +08:00
|
|
|
int
|
2018-04-17 15:35:15 +08:00
|
|
|
lws_buflist_aware_read(struct lws_context_per_thread *pt, struct lws *wsi,
|
2020-01-20 10:02:56 +00:00
|
|
|
struct lws_tokens *ebuf, char fr, const char *hint)
|
2018-04-11 13:39:42 +08:00
|
|
|
{
|
2020-01-20 10:02:56 +00:00
|
|
|
int n, e, bns;
|
|
|
|
|
uint8_t *ep, *b;
|
2019-09-12 05:41:19 +01:00
|
|
|
|
2020-12-25 05:54:19 +00:00
|
|
|
// lwsl_debug("%s: %s: %s: prior %d\n", __func__, lws_wsi_tag(wsi), hint, prior);
|
2019-09-12 05:41:19 +01:00
|
|
|
// lws_buflist_describe(&wsi->buflist, wsi, __func__);
|
|
|
|
|
|
|
|
|
|
(void)hint;
|
2020-01-20 10:02:56 +00:00
|
|
|
if (!ebuf->token)
|
|
|
|
|
ebuf->token = pt->serv_buf + LWS_PRE;
|
|
|
|
|
if (!ebuf->len ||
|
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
|
|
|
(unsigned int)ebuf->len > wsi->a.context->pt_serv_buf_size - LWS_PRE)
|
2020-12-12 06:21:40 +00:00
|
|
|
ebuf->len = (int)(wsi->a.context->pt_serv_buf_size - LWS_PRE);
|
2019-09-12 05:41:19 +01:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
e = ebuf->len;
|
|
|
|
|
ep = ebuf->token;
|
2018-04-30 19:17:32 +08:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
/* h2 or muxed stream... must force the read due to HOL blocking */
|
2019-09-12 05:41:19 +01:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
if (wsi->mux_substream)
|
|
|
|
|
fr = 1;
|
2018-04-11 13:39:42 +08:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
/* there's something on the buflist? */
|
2018-04-30 19:17:32 +08:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
bns = (int)lws_buflist_next_segment_len(&wsi->buflist, &ebuf->token);
|
|
|
|
|
b = ebuf->token;
|
2018-04-30 19:17:32 +08:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
if (!fr && bns)
|
|
|
|
|
goto buflist_material;
|
2018-04-30 19:17:32 +08:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
/* we're going to read something */
|
2018-04-11 13:39:42 +08:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
ebuf->token = ep;
|
2020-12-12 06:21:40 +00:00
|
|
|
ebuf->len = n = lws_ssl_capable_read(wsi, ep, (size_t)e);
|
2020-01-20 10:02:56 +00:00
|
|
|
|
2021-06-18 07:28:23 +01:00
|
|
|
lwsl_wsi_debug(wsi, "%s: ssl_capable_read %d", hint, ebuf->len);
|
2020-01-20 10:02:56 +00:00
|
|
|
|
|
|
|
|
if (!bns && /* only acknowledge error when we handled buflist content */
|
|
|
|
|
n == LWS_SSL_CAPABLE_ERROR) {
|
2020-01-23 11:12:28 +00:00
|
|
|
lwsl_debug("%s: SSL_CAPABLE_ERROR\n", __func__);
|
2018-04-30 19:17:32 +08:00
|
|
|
return -1;
|
2018-04-11 13:39:42 +08:00
|
|
|
}
|
|
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
if (n <= 0 && bns)
|
|
|
|
|
/*
|
|
|
|
|
* There wasn't anything to read yet, but there's something
|
|
|
|
|
* on the buflist to give him
|
|
|
|
|
*/
|
|
|
|
|
goto buflist_material;
|
2018-04-30 19:17:32 +08:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
/* we read something */
|
2018-04-30 19:17:32 +08:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
if (fr && bns) {
|
|
|
|
|
/*
|
|
|
|
|
* Stash what we read, since there's earlier buflist material
|
|
|
|
|
*/
|
2018-04-30 19:17:32 +08:00
|
|
|
|
2020-12-12 06:21:40 +00:00
|
|
|
n = lws_buflist_append_segment(&wsi->buflist, ebuf->token, (size_t)ebuf->len);
|
2020-01-20 10:02:56 +00:00
|
|
|
if (n < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
if (n && lws_dll2_is_detached(&wsi->dll_buflist))
|
|
|
|
|
lws_dll2_add_head(&wsi->dll_buflist,
|
|
|
|
|
&pt->dll_buflist_owner);
|
2019-09-12 05:41:19 +01:00
|
|
|
|
2020-01-20 10:02:56 +00:00
|
|
|
goto buflist_material;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* directly return what we read
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
buflist_material:
|
|
|
|
|
|
|
|
|
|
ebuf->token = b;
|
|
|
|
|
if (e < bns)
|
|
|
|
|
/* restrict to e, if more than e available */
|
|
|
|
|
ebuf->len = e;
|
|
|
|
|
else
|
|
|
|
|
ebuf->len = bns;
|
|
|
|
|
|
|
|
|
|
return 1; /* from buflist */
|
2018-04-17 15:35:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
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)
|
2018-04-17 15:35:15 +08:00
|
|
|
{
|
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_context_per_thread *pt = &wsi->a.context->pt[(int)wsi->tsi];
|
2018-04-17 15:35:15 +08:00
|
|
|
int m;
|
2018-04-11 13:39:42 +08:00
|
|
|
|
2018-04-30 19:17:32 +08:00
|
|
|
/* it's in the buflist; we didn't use any */
|
|
|
|
|
|
|
|
|
|
if (!used && buffered)
|
|
|
|
|
return 0;
|
2018-04-11 13:39:42 +08:00
|
|
|
|
2018-04-17 15:35:15 +08:00
|
|
|
if (used && buffered) {
|
2020-01-30 13:19:11 +00:00
|
|
|
if (wsi->buflist) {
|
2021-06-28 05:05:57 +01:00
|
|
|
m = (int)lws_buflist_use_segment(&wsi->buflist,
|
|
|
|
|
(size_t)used);
|
2020-01-30 13:19:11 +00:00
|
|
|
if (m)
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2018-04-17 15:35:15 +08:00
|
|
|
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_info(wsi, "removed from dll_buflist");
|
2019-04-21 06:24:05 +01:00
|
|
|
lws_dll2_remove(&wsi->dll_buflist);
|
2018-04-17 15:35:15 +08:00
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-17 15:35:15 +08:00
|
|
|
/* any remainder goes on the buflist */
|
2018-04-11 13:39:42 +08:00
|
|
|
|
2020-12-12 06:21:40 +00:00
|
|
|
if (used < ebuf->len && ebuf->len >= 0 && used >= 0) {
|
2018-04-30 19:17:32 +08:00
|
|
|
m = lws_buflist_append_segment(&wsi->buflist,
|
2019-05-30 08:21:33 +08:00
|
|
|
ebuf->token + used,
|
2020-12-12 06:21:40 +00:00
|
|
|
(unsigned int)(ebuf->len - used));
|
2018-04-30 19:17:32 +08:00
|
|
|
if (m < 0)
|
|
|
|
|
return 1; /* OOM */
|
|
|
|
|
if (m) {
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "added to rxflow list");
|
2019-09-11 14:43:09 +01:00
|
|
|
if (lws_dll2_is_detached(&wsi->dll_buflist))
|
|
|
|
|
lws_dll2_add_head(&wsi->dll_buflist,
|
2019-04-21 06:24:05 +01:00
|
|
|
&pt->dll_buflist_owner);
|
2018-04-30 19:17:32 +08:00
|
|
|
}
|
|
|
|
|
}
|
2018-04-17 15:35:15 +08:00
|
|
|
|
|
|
|
|
return 0;
|
2018-04-11 13:39:42 +08:00
|
|
|
}
|
|
|
|
|
|
2018-04-17 11:43:20 +08:00
|
|
|
void
|
|
|
|
|
lws_service_do_ripe_rxflow(struct lws_context_per_thread *pt)
|
|
|
|
|
{
|
|
|
|
|
struct lws_pollfd pfd;
|
|
|
|
|
|
2019-04-21 06:24:05 +01:00
|
|
|
if (!pt->dll_buflist_owner.head)
|
2018-04-17 11:43:20 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* service all guys with pending rxflow that reached a state they can
|
|
|
|
|
* accept the pending data
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
lws_pt_lock(pt, __func__);
|
|
|
|
|
|
2019-04-21 06:24:05 +01:00
|
|
|
lws_start_foreach_dll_safe(struct lws_dll2 *, d, d1,
|
|
|
|
|
pt->dll_buflist_owner.head) {
|
2018-04-17 15:35:15 +08:00
|
|
|
struct lws *wsi = lws_container_of(d, struct lws, dll_buflist);
|
2018-04-17 11:43:20 +08:00
|
|
|
|
2018-04-16 19:52:28 +08:00
|
|
|
pfd.events = LWS_POLLIN;
|
|
|
|
|
pfd.revents = LWS_POLLIN;
|
2018-04-17 11:43:20 +08:00
|
|
|
pfd.fd = -1;
|
|
|
|
|
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "rxflow processing: fc=%d, 0x%lx",
|
|
|
|
|
lws_is_flowcontrolled(wsi),
|
|
|
|
|
(unsigned long)wsi->wsistate);
|
2018-04-17 11:43:20 +08:00
|
|
|
|
|
|
|
|
if (!lws_is_flowcontrolled(wsi) &&
|
2020-01-23 11:12:28 +00:00
|
|
|
lwsi_state(wsi) != LRS_DEFERRING_ACTION) {
|
|
|
|
|
pt->inside_lws_service = 1;
|
|
|
|
|
|
roles: compress role ops structs
role ops are usually only sparsely filled, there are currently 20
function pointers but several roles only fill in two. No single
role has more than 14 of the ops. On a 32/64 bit build this part
of the ops struct takes a fixed 80 / 160 bytes then.
First reduce the type of the callback reason part from uint16_t to
uint8_t, this saves 12 bytes unconditionally.
Change to a separate function pointer array with a nybble index
array, it costs 10 bytes for the index and a pointer to the
separate array, for 32-bit the cost is
2 + (4 x ops_used)
and for 64-bit
6 + (8 x ops_used)
for 2 x ops_used it means 32-bit: 10 vs 80 / 64-bit: 22 vs 160
For a typical system with h1 (9), h2 (14), listen (2), netlink (2),
pipe (1), raw_skt (3), ws (12), == 43 ops_used out of 140, it means
the .rodata for this reduced from 32-bit: 560 -> 174 (386 byte
saving) and 64-bit: 1120 -> 350 (770 byte saving)
This doesn't account for the changed function ops calling code, two
ways were tried, a preprocessor macro and explicit functions
For an x86_64 gcc 10 build with most options, release mode,
.text + .rodata
before patch: 553282
accessor macro: 552714 (568 byte saving)
accessor functions: 553674 (392 bytes worse than without patch)
therefore we went with the macros
2020-10-19 13:55:21 +01:00
|
|
|
if (lws_rops_func_fidx(wsi->role_ops,
|
|
|
|
|
LWS_ROPS_handle_POLLIN).
|
|
|
|
|
handle_POLLIN(pt, wsi, &pfd) ==
|
2018-04-17 15:35:15 +08:00
|
|
|
LWS_HPI_RET_PLEASE_CLOSE_ME)
|
2020-01-23 11:12:28 +00:00
|
|
|
lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS,
|
|
|
|
|
"close_and_handled");
|
|
|
|
|
pt->inside_lws_service = 0;
|
|
|
|
|
}
|
2018-04-17 11:43:20 +08:00
|
|
|
|
|
|
|
|
} lws_end_foreach_dll_safe(d, d1);
|
|
|
|
|
|
|
|
|
|
lws_pt_unlock(pt);
|
|
|
|
|
}
|
2018-04-11 13:39:42 +08:00
|
|
|
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
/*
|
|
|
|
|
* guys that need POLLIN service again without waiting for network action
|
|
|
|
|
* can force POLLIN here if not flowcontrolled, so they will get service.
|
|
|
|
|
*
|
|
|
|
|
* Return nonzero if anybody got their POLLIN faked
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
lws_service_flag_pending(struct lws_context *context, int tsi)
|
|
|
|
|
{
|
2019-08-19 09:31:17 +02:00
|
|
|
struct lws_context_per_thread *pt;
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
int forced = 0;
|
|
|
|
|
|
2019-08-19 09:31:17 +02:00
|
|
|
if (!context)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
pt = &context->pt[tsi];
|
|
|
|
|
|
2018-03-02 14:22:49 +08:00
|
|
|
lws_pt_lock(pt, __func__);
|
|
|
|
|
|
2018-04-17 11:43:20 +08:00
|
|
|
/*
|
2018-04-19 12:53:53 +08:00
|
|
|
* 1) If there is any wsi with a buflist and in a state to process
|
2018-04-17 11:43:20 +08:00
|
|
|
* it, we should not wait in poll
|
|
|
|
|
*/
|
|
|
|
|
|
2019-04-21 06:24:05 +01:00
|
|
|
lws_start_foreach_dll(struct lws_dll2 *, d, pt->dll_buflist_owner.head) {
|
2018-04-17 15:35:15 +08:00
|
|
|
struct lws *wsi = lws_container_of(d, struct lws, dll_buflist);
|
2018-04-17 11:43:20 +08:00
|
|
|
|
2019-04-21 06:24:05 +01:00
|
|
|
if (!lws_is_flowcontrolled(wsi) &&
|
|
|
|
|
lwsi_state(wsi) != LRS_DEFERRING_ACTION) {
|
2018-04-17 11:43:20 +08:00
|
|
|
forced = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} lws_end_foreach_dll(d);
|
|
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
#if defined(LWS_ROLE_WS)
|
roles: compress role ops structs
role ops are usually only sparsely filled, there are currently 20
function pointers but several roles only fill in two. No single
role has more than 14 of the ops. On a 32/64 bit build this part
of the ops struct takes a fixed 80 / 160 bytes then.
First reduce the type of the callback reason part from uint16_t to
uint8_t, this saves 12 bytes unconditionally.
Change to a separate function pointer array with a nybble index
array, it costs 10 bytes for the index and a pointer to the
separate array, for 32-bit the cost is
2 + (4 x ops_used)
and for 64-bit
6 + (8 x ops_used)
for 2 x ops_used it means 32-bit: 10 vs 80 / 64-bit: 22 vs 160
For a typical system with h1 (9), h2 (14), listen (2), netlink (2),
pipe (1), raw_skt (3), ws (12), == 43 ops_used out of 140, it means
the .rodata for this reduced from 32-bit: 560 -> 174 (386 byte
saving) and 64-bit: 1120 -> 350 (770 byte saving)
This doesn't account for the changed function ops calling code, two
ways were tried, a preprocessor macro and explicit functions
For an x86_64 gcc 10 build with most options, release mode,
.text + .rodata
before patch: 553282
accessor macro: 552714 (568 byte saving)
accessor functions: 553674 (392 bytes worse than without patch)
therefore we went with the macros
2020-10-19 13:55:21 +01:00
|
|
|
forced |= lws_rops_func_fidx(&role_ops_ws,
|
|
|
|
|
LWS_ROPS_service_flag_pending).
|
|
|
|
|
service_flag_pending(context, tsi);
|
2018-04-11 13:39:42 +08:00
|
|
|
#endif
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
#if defined(LWS_WITH_TLS)
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
/*
|
|
|
|
|
* 2) For all guys with buffered SSL read data already saved up, if they
|
|
|
|
|
* are not flowcontrolled, fake their POLLIN status so they'll get
|
|
|
|
|
* service to use up the buffered incoming data, even though their
|
|
|
|
|
* network socket may have nothing
|
|
|
|
|
*/
|
2019-08-08 16:58:55 +01:00
|
|
|
lws_start_foreach_dll_safe(struct lws_dll2 *, p, p1,
|
|
|
|
|
lws_dll2_get_head(&pt->tls.dll_pending_tls_owner)) {
|
2018-11-23 08:47:56 +08:00
|
|
|
struct lws *wsi = lws_container_of(p, struct lws,
|
2019-03-20 07:39:55 +08:00
|
|
|
tls.dll_pending_tls);
|
2018-11-05 14:43:50 +08:00
|
|
|
|
2019-08-26 18:41:40 +01:00
|
|
|
if (wsi->position_in_fds_table >= 0) {
|
|
|
|
|
|
2020-12-12 06:21:40 +00:00
|
|
|
pt->fds[wsi->position_in_fds_table].revents = (short)(
|
|
|
|
|
pt->fds[wsi->position_in_fds_table].revents |
|
|
|
|
|
(pt->fds[wsi->position_in_fds_table].events &
|
|
|
|
|
LWS_POLLIN));
|
2020-05-18 06:49:01 +01:00
|
|
|
if (pt->fds[wsi->position_in_fds_table].revents &
|
|
|
|
|
LWS_POLLIN)
|
|
|
|
|
/*
|
|
|
|
|
* We're not going to remove the wsi from the
|
|
|
|
|
* pending tls list. The processing will have
|
|
|
|
|
* to do it if he exhausts the pending tls.
|
|
|
|
|
*/
|
|
|
|
|
forced = 1;
|
2019-08-26 18:41:40 +01:00
|
|
|
}
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
|
2018-11-05 14:43:50 +08:00
|
|
|
} lws_end_foreach_dll_safe(p, p1);
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
#endif
|
2018-04-11 13:39:42 +08:00
|
|
|
|
2018-03-02 14:22:49 +08:00
|
|
|
lws_pt_unlock(pt);
|
|
|
|
|
|
ah owns rxbuf
This is intended to solve a longstanding problem with the
relationship between http/1.1 keep-alive and the service
loop.
Ah now contain an rx buffer which is used during header
processing, and the ah may not be detached from the wsi
until the rx buffer is exhausted.
Having the rx buffer in the ah means we can delay using the
rx until a later service loop.
Ah which have pending rx force POLLIN service on the wsi
they are attached to automatically, so we can interleave
general service / connections with draining each ah rx
buffer.
The possible http/1.1 situations and their dispositions are:
1) exactly one set of http headers come. After processing,
the ah is detached since no pending rx left. If more
headers come later, a fresh ah is aqcuired when available
and the rx flow control blocks the read until then.
2) more that one whole set of headers come and we remain in
http mode (no upgrade). The ah is left attached and
returns to the service loop after the first set of headers.
We will get forced service due to the ah having pending
content (respecting flowcontrol) and process the pending
rx in the ah. If we use it all up, we will detach the
ah.
3) one set of http headers come with ws traffic appended.
We service the headers, do the upgrade, and keep the ah
until the remaining ws content is used. When we
exhausted the ws traffix in the ah rx buffer, we
detach the ah.
Since there can be any amount of http/1.1 pipelining on a
connection, and each may be expensive to service, it's now
enforced there is a return to the service loop after each
header set is serviced on a connection.
When I added the forced service for ah with pending buffering,
I added support for it to the windows plat code. However this
is untested.
Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
|
|
|
return forced;
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-02 08:32:23 +00:00
|
|
|
int
|
2018-04-11 13:39:42 +08:00
|
|
|
lws_service_fd_tsi(struct lws_context *context, struct lws_pollfd *pollfd,
|
|
|
|
|
int tsi)
|
|
|
|
|
{
|
2019-08-19 09:31:17 +02:00
|
|
|
struct lws_context_per_thread *pt;
|
2018-04-11 13:39:42 +08:00
|
|
|
struct lws *wsi;
|
2021-08-31 05:06:06 +01:00
|
|
|
char cow = 0;
|
2014-04-03 07:36:41 +08:00
|
|
|
|
2020-11-16 19:32:58 +00:00
|
|
|
if (!context || context->service_no_longer_possible)
|
2018-04-30 09:16:04 +08:00
|
|
|
return -1;
|
|
|
|
|
|
2019-08-19 09:31:17 +02:00
|
|
|
pt = &context->pt[tsi];
|
|
|
|
|
|
2020-11-16 19:32:58 +00:00
|
|
|
if (pt->event_loop_pt_unused)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2018-11-14 20:04:14 +08:00
|
|
|
if (!pollfd) {
|
2019-08-09 10:12:09 +01:00
|
|
|
/*
|
|
|
|
|
* calling with NULL pollfd for periodic background processing
|
|
|
|
|
* is no longer needed and is now illegal.
|
|
|
|
|
*/
|
|
|
|
|
assert(pollfd);
|
|
|
|
|
return -1;
|
2018-11-14 20:04:14 +08:00
|
|
|
}
|
2019-03-20 07:39:55 +08:00
|
|
|
assert(lws_socket_is_valid(pollfd->fd));
|
|
|
|
|
|
2014-04-03 07:36:41 +08:00
|
|
|
/* no, here to service a socket descriptor */
|
2015-11-02 20:34:12 +08:00
|
|
|
wsi = wsi_from_fd(context, pollfd->fd);
|
2015-12-06 05:52:09 +08:00
|
|
|
if (!wsi)
|
2014-04-03 07:36:41 +08:00
|
|
|
/* not lws connection ... leave revents alone and return */
|
|
|
|
|
return 0;
|
|
|
|
|
|
2019-02-23 05:41:30 +08:00
|
|
|
#if LWS_MAX_SMP > 1
|
|
|
|
|
if (wsi->undergoing_init_from_other_pt)
|
|
|
|
|
/*
|
|
|
|
|
* Temporary situation that other service thread is initializing
|
|
|
|
|
* this wsi right now for use on our service thread.
|
|
|
|
|
*/
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-04-03 07:36:41 +08:00
|
|
|
/*
|
|
|
|
|
* so that caller can tell we handled, past here we need to
|
|
|
|
|
* zero down pollfd->revents after handling
|
|
|
|
|
*/
|
|
|
|
|
|
2021-02-15 14:17:52 +00:00
|
|
|
/*
|
|
|
|
|
* Whatever the situation with buffered rx packets, or explicitly read-
|
|
|
|
|
* and-buffered rx going to be handled before we want to acknowledge the
|
|
|
|
|
* socket is gone, any sign of HUP always immediately means no more tx
|
|
|
|
|
* is possible.
|
|
|
|
|
*/
|
2014-04-03 07:36:41 +08:00
|
|
|
|
2021-03-10 14:50:53 +00:00
|
|
|
if ((pollfd->revents & LWS_POLLHUP) == LWS_POLLHUP) {
|
2021-02-15 14:17:52 +00:00
|
|
|
wsi->socket_is_permanently_unusable = 1;
|
2014-04-03 07:36:41 +08:00
|
|
|
|
2021-02-15 14:17:52 +00:00
|
|
|
if (!(pollfd->revents & pollfd->events & LWS_POLLIN)) {
|
|
|
|
|
|
|
|
|
|
/* ... there are no pending rx packets waiting... */
|
|
|
|
|
|
|
|
|
|
if (!lws_buflist_total_len(&wsi->buflist)) {
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* ... nothing stashed in the buflist either,
|
|
|
|
|
* so acknowledge the wsi is done
|
|
|
|
|
*/
|
|
|
|
|
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "Session Socket %d dead",
|
|
|
|
|
pollfd->fd);
|
2021-02-15 14:17:52 +00:00
|
|
|
|
|
|
|
|
goto close_and_handled;
|
|
|
|
|
}
|
2021-01-06 15:10:03 +00:00
|
|
|
|
2021-02-15 14:17:52 +00:00
|
|
|
/*
|
|
|
|
|
* ... in fact we have some unread rx buffered in the
|
|
|
|
|
* input buflist. Hold off the closing a bit...
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
lws_set_timeout(wsi, PENDING_TIMEOUT_CLOSE_ACK, 3);
|
2021-01-06 15:10:03 +00:00
|
|
|
}
|
2014-04-03 07:36:41 +08:00
|
|
|
}
|
2015-12-17 15:35:41 +08:00
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
if (pollfd->revents & LWS_POLLOUT)
|
|
|
|
|
wsi->sock_send_blocking = FALSE;
|
2015-11-08 12:10:26 +08:00
|
|
|
#endif
|
2014-04-03 07:36:41 +08:00
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
#if defined(LWS_WITH_TLS)
|
2018-05-02 18:35:58 +08:00
|
|
|
if (lwsi_state(wsi) == LRS_SHUTDOWN &&
|
|
|
|
|
lws_is_ssl(wsi) && wsi->tls.ssl) {
|
2018-03-11 11:26:06 +08:00
|
|
|
switch (__lws_tls_shutdown(wsi)) {
|
2017-10-18 09:41:44 +08:00
|
|
|
case LWS_SSL_CAPABLE_DONE:
|
|
|
|
|
case LWS_SSL_CAPABLE_ERROR:
|
2017-04-06 19:37:14 +02:00
|
|
|
goto close_and_handled;
|
2017-09-29 11:27:58 +08:00
|
|
|
|
2017-10-18 09:41:44 +08:00
|
|
|
case LWS_SSL_CAPABLE_MORE_SERVICE_READ:
|
|
|
|
|
case LWS_SSL_CAPABLE_MORE_SERVICE_WRITE:
|
|
|
|
|
case LWS_SSL_CAPABLE_MORE_SERVICE:
|
2017-04-06 19:37:14 +02:00
|
|
|
goto handled;
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-03-10 07:46:05 +08:00
|
|
|
#endif
|
2021-08-31 05:06:06 +01:00
|
|
|
|
|
|
|
|
if ((pollfd->revents & LWS_POLLOUT) == LWS_POLLOUT &&
|
|
|
|
|
wsi->tls_read_wanted_write) {
|
|
|
|
|
/*
|
|
|
|
|
* If this wsi has a pending WANT_WRITE from SSL_read(), it has
|
|
|
|
|
* asked for a callback on writeable so it can retry the read.
|
|
|
|
|
*
|
|
|
|
|
* Let's consume the POLLOUT by turning it into a POLLIIN, and
|
|
|
|
|
* setting a flag to request a new writeable
|
|
|
|
|
*/
|
|
|
|
|
wsi->tls_read_wanted_write = 0;
|
|
|
|
|
pollfd->revents &= ~(LWS_POLLOUT);
|
|
|
|
|
pollfd->revents |= LWS_POLLIN;
|
|
|
|
|
cow = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-25 09:00:08 +08:00
|
|
|
wsi->could_have_pending = 0; /* clear back-to-back write detection */
|
2020-01-23 11:12:28 +00:00
|
|
|
pt->inside_lws_service = 1;
|
2017-03-10 07:46:05 +08:00
|
|
|
|
2014-04-03 07:36:41 +08:00
|
|
|
/* okay, what we came here to do... */
|
|
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
/* if we got here, we should have wire protocol ops set on the wsi */
|
|
|
|
|
assert(wsi->role_ops);
|
2018-04-02 11:55:17 +08:00
|
|
|
|
2018-04-11 13:39:42 +08:00
|
|
|
// lwsl_notice("%s: %s: wsistate 0x%x\n", __func__, wsi->role_ops->name,
|
|
|
|
|
// wsi->wsistate);
|
2017-10-24 11:59:44 +08:00
|
|
|
|
roles: compress role ops structs
role ops are usually only sparsely filled, there are currently 20
function pointers but several roles only fill in two. No single
role has more than 14 of the ops. On a 32/64 bit build this part
of the ops struct takes a fixed 80 / 160 bytes then.
First reduce the type of the callback reason part from uint16_t to
uint8_t, this saves 12 bytes unconditionally.
Change to a separate function pointer array with a nybble index
array, it costs 10 bytes for the index and a pointer to the
separate array, for 32-bit the cost is
2 + (4 x ops_used)
and for 64-bit
6 + (8 x ops_used)
for 2 x ops_used it means 32-bit: 10 vs 80 / 64-bit: 22 vs 160
For a typical system with h1 (9), h2 (14), listen (2), netlink (2),
pipe (1), raw_skt (3), ws (12), == 43 ops_used out of 140, it means
the .rodata for this reduced from 32-bit: 560 -> 174 (386 byte
saving) and 64-bit: 1120 -> 350 (770 byte saving)
This doesn't account for the changed function ops calling code, two
ways were tried, a preprocessor macro and explicit functions
For an x86_64 gcc 10 build with most options, release mode,
.text + .rodata
before patch: 553282
accessor macro: 552714 (568 byte saving)
accessor functions: 553674 (392 bytes worse than without patch)
therefore we went with the macros
2020-10-19 13:55:21 +01:00
|
|
|
switch (lws_rops_func_fidx(wsi->role_ops, LWS_ROPS_handle_POLLIN).
|
|
|
|
|
handle_POLLIN(pt, wsi, pollfd)) {
|
2018-04-17 15:35:15 +08:00
|
|
|
case LWS_HPI_RET_WSI_ALREADY_DIED:
|
2020-01-23 11:12:28 +00:00
|
|
|
pt->inside_lws_service = 0;
|
2018-04-11 13:39:42 +08:00
|
|
|
return 1;
|
|
|
|
|
case LWS_HPI_RET_HANDLED:
|
|
|
|
|
break;
|
2018-04-17 15:35:15 +08:00
|
|
|
case LWS_HPI_RET_PLEASE_CLOSE_ME:
|
2020-08-31 09:27:16 +01:00
|
|
|
//lwsl_notice("%s: %s pollin says please close me\n", __func__,
|
|
|
|
|
// wsi->role_ops->name);
|
2018-04-11 13:39:42 +08:00
|
|
|
close_and_handled:
|
2021-06-28 05:05:57 +01:00
|
|
|
lwsl_wsi_debug(wsi, "Close and handled");
|
2018-04-11 13:39:42 +08:00
|
|
|
lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS,
|
|
|
|
|
"close_and_handled");
|
2018-04-30 09:16:04 +08:00
|
|
|
#if defined(_DEBUG) && defined(LWS_WITH_LIBUV)
|
2018-04-19 10:08:48 +08:00
|
|
|
/*
|
|
|
|
|
* confirm close has no problem being called again while
|
|
|
|
|
* it waits for libuv service to complete the first async
|
|
|
|
|
* close
|
|
|
|
|
*/
|
2020-08-27 15:37:14 +01:00
|
|
|
if (!strcmp(context->event_loop_ops->name, "libuv"))
|
2018-04-19 10:08:48 +08:00
|
|
|
lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS,
|
|
|
|
|
"close_and_handled uv repeat test");
|
|
|
|
|
#endif
|
2017-10-24 11:59:44 +08:00
|
|
|
/*
|
2018-04-11 13:39:42 +08:00
|
|
|
* pollfd may point to something else after the close
|
|
|
|
|
* due to pollfd swapping scheme on delete on some platforms
|
|
|
|
|
* we can't clear revents now because it'd be the wrong guy's
|
|
|
|
|
* revents
|
2016-03-20 11:59:53 +08:00
|
|
|
*/
|
2020-01-23 11:12:28 +00:00
|
|
|
pt->inside_lws_service = 0;
|
2018-04-02 11:55:17 +08:00
|
|
|
return 1;
|
2018-04-11 13:39:42 +08:00
|
|
|
default:
|
|
|
|
|
assert(0);
|
|
|
|
|
}
|
|
|
|
|
#if defined(LWS_WITH_TLS)
|
2014-04-03 07:36:41 +08:00
|
|
|
handled:
|
2018-04-11 13:39:42 +08:00
|
|
|
#endif
|
2014-04-03 07:36:41 +08:00
|
|
|
pollfd->revents = 0;
|
2021-08-31 05:06:06 +01:00
|
|
|
if (cow)
|
|
|
|
|
lws_callback_on_writable(wsi);
|
2020-01-23 11:12:28 +00:00
|
|
|
pt->inside_lws_service = 0;
|
2018-04-11 13:39:42 +08:00
|
|
|
|
|
|
|
|
return 0;
|
2014-04-03 07:36:41 +08:00
|
|
|
}
|
|
|
|
|
|
2020-01-02 08:32:23 +00:00
|
|
|
int
|
2016-01-19 03:34:24 +08:00
|
|
|
lws_service_fd(struct lws_context *context, struct lws_pollfd *pollfd)
|
|
|
|
|
{
|
|
|
|
|
return lws_service_fd_tsi(context, pollfd, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-02 08:32:23 +00:00
|
|
|
int
|
2015-12-04 11:08:32 +08:00
|
|
|
lws_service(struct lws_context *context, int timeout_ms)
|
2014-04-03 07:36:41 +08:00
|
|
|
{
|
2019-08-19 09:31:17 +02:00
|
|
|
struct lws_context_per_thread *pt;
|
2018-05-02 19:27:29 +08:00
|
|
|
int n;
|
|
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
|
return 1;
|
|
|
|
|
|
2019-08-19 09:31:17 +02:00
|
|
|
pt = &context->pt[0];
|
2018-05-02 19:27:29 +08:00
|
|
|
pt->inside_service = 1;
|
|
|
|
|
|
2018-04-29 10:44:36 +08:00
|
|
|
if (context->event_loop_ops->run_pt) {
|
|
|
|
|
/* we are configured for an event loop */
|
|
|
|
|
context->event_loop_ops->run_pt(context, 0);
|
|
|
|
|
|
2018-05-02 19:27:29 +08:00
|
|
|
pt->inside_service = 0;
|
|
|
|
|
|
2018-04-29 10:44:36 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
2018-05-02 19:27:29 +08:00
|
|
|
n = lws_plat_service(context, timeout_ms);
|
|
|
|
|
|
2021-01-06 15:08:22 +00:00
|
|
|
if (n != -1)
|
|
|
|
|
pt->inside_service = 0;
|
2018-05-02 19:27:29 +08:00
|
|
|
|
|
|
|
|
return n;
|
2014-04-03 07:36:41 +08:00
|
|
|
}
|
|
|
|
|
|
2020-01-02 08:32:23 +00:00
|
|
|
int
|
2016-01-19 03:34:24 +08:00
|
|
|
lws_service_tsi(struct lws_context *context, int timeout_ms, int tsi)
|
|
|
|
|
{
|
2019-08-19 09:31:17 +02:00
|
|
|
struct lws_context_per_thread *pt;
|
2018-05-02 19:27:29 +08:00
|
|
|
int n;
|
|
|
|
|
|
2019-08-19 09:31:17 +02:00
|
|
|
if (!context)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
pt = &context->pt[tsi];
|
2018-05-02 19:27:29 +08:00
|
|
|
pt->inside_service = 1;
|
2018-11-15 16:33:54 +08:00
|
|
|
#if LWS_MAX_SMP > 1
|
|
|
|
|
pt->self = pthread_self();
|
|
|
|
|
#endif
|
2018-05-02 19:27:29 +08:00
|
|
|
|
2018-04-29 10:44:36 +08:00
|
|
|
if (context->event_loop_ops->run_pt) {
|
|
|
|
|
/* we are configured for an event loop */
|
|
|
|
|
context->event_loop_ops->run_pt(context, tsi);
|
|
|
|
|
|
2018-05-02 19:27:29 +08:00
|
|
|
pt->inside_service = 0;
|
|
|
|
|
|
2018-04-29 10:44:36 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-02 19:27:29 +08:00
|
|
|
n = _lws_plat_service_tsi(context, timeout_ms, tsi);
|
|
|
|
|
|
|
|
|
|
pt->inside_service = 0;
|
|
|
|
|
|
|
|
|
|
return n;
|
2016-01-19 03:34:24 +08:00
|
|
|
}
|