Mirrors/libwebsockets
1
0
Fork 0
mirror of https://github.com/warmcat/libwebsockets.git synced 2025-03-09 00:00:04 +01:00
Code Issues Releases Wiki Activity
libwebsockets/lib/core-net/output.c

386 lines
9.7 KiB
C
Raw Permalink Normal View History

refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
/*
* libwebsockets - small server side websockets and web server implementation
*
license: switch LGPLv2.1+SLE parts to MIT
2019-08-14 10:44:14 +01:00
* Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
*
license: switch LGPLv2.1+SLE parts to MIT
2019-08-14 10:44:14 +01:00
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
*
license: switch LGPLv2.1+SLE parts to MIT
2019-08-14 10:44:14 +01:00
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
*
license: switch LGPLv2.1+SLE parts to MIT
2019-08-14 10:44:14 +01:00
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
*/
private.h: rename to contain dir Having unique private header names is a requirement of a particular platform build system it's desirable to work with
2019-08-15 10:49:52 +01:00
#include "private-lib-core.h"
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
reflect send completeness in lws_write return under load, writing packet sizes to the socket that are normally fine can do partial writes, eg asking to write 4096 may only take 2800 of it and return 2800 from the actual send. Until now lws assumed that if it was safe to send, it could take any size buffer, that's not the case under load. This patch changes lws_write to return the amount actually taken... that and the meaning of it becomes tricky when dealing with compressed links, the amount taken and the amount sent differ. Also there is no way to recover at the moment from a protocol-encoded frame only being partially accepted... however for http file send content it can and does recover now. Small frames don't have to take any care about it but large atomic sends (> 2K) have been seen to fail under load. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-23 10:50:10 +08:00
/*
add explicit error for partial send This patch adds code to handle the situation that a prepared user buffer could not all be sent on the socket at once. There are two kinds of situation to handle 1) User code handles it: The connection only has extensions active that do not rewrite the buffer. In this case, the patch caused libwebsocket_write() to simply return the amount of user buffer that was consumed (this is specifically the amount of user buffer used in sending what was accepted, nothing else). So user code can just advance its buffer that much and resume sending when the socket is writable again. This continues the frame rather than starting a new one or new fragment. 2) The connections has extensions active which actually send something quite different than what the user buffer contains, for example a compression extension. In this case, libwebsockets will dynamically malloc a buffer to contain a copy of the remaining unsent data, request notifiction when writeable again, and automatically spill and free this buffer with the highest priority before passing on the writable notification to anything else. For this situation, the call to write will return that it used the whole user buffer, even though part is still rebuffered. This patch should enable libwebsockets to detect the two cases and take the appropriate action. There are also two choices for user code to deal with partial sends. 1) Leave the no_buffer_all_partial_tx member in the protocol struct at zero. The library will dyamically buffer anything you send that did not get completely written to the socket, and automatically spill it next time the socket is writable. You can use this method if your sent frames are relatvely small and unlikely to get truncated anyway. 2) Set the no_buffer_all_partial_tx member in the protocol struct. User code now needs to take care of the return value from libwebsocket_write() and deal with resending the remainder if not all of the requested amount got sent. You should use this method if you are sending large messages and want to maximize throughput and efficiency. Since the new member no_buffer_all_partial_tx will be zero by default, this patch will auto-rebuffer any partial sends by default. That's good for most cases but if you attempt to send large blocks, make sure you follow option 2) above. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-10-17 08:09:19 +08:00
* notice this returns number of bytes consumed, or -1
reflect send completeness in lws_write return under load, writing packet sizes to the socket that are normally fine can do partial writes, eg asking to write 4096 may only take 2800 of it and return 2800 from the actual send. Until now lws assumed that if it was safe to send, it could take any size buffer, that's not the case under load. This patch changes lws_write to return the amount actually taken... that and the meaning of it becomes tricky when dealing with compressed links, the amount taken and the amount sent differ. Also there is no way to recover at the moment from a protocol-encoded frame only being partially accepted... however for http file send content it can and does recover now. Small frames don't have to take any care about it but large atomic sends (> 2K) have been seen to fail under load. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-23 10:50:10 +08:00
*/
detailed latency stats Remove LWS_LATENCY. Add the option LWS_WITH_DETAILED_LATENCY, allowing lws to collect very detailed information on every read and write, and allow the user code to provide a callback to process events.
2019-08-23 16:10:36 +01:00
int
lws_issue_raw(struct lws *wsi, unsigned char *buf, size_t len)
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
{
lws_get_context not _ctx Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-17 18:25:25 +08:00
struct lws_context *context = lws_get_context(wsi);
NO_EXTENSIONS fixes Trac #52 Signed-off-by: Andy Green <andy.green@linaro.org>
2013-12-10 21:15:00 +08:00
size_t real_len = len;
threadpool
2018-09-02 14:35:37 +08:00
unsigned int n, m;
whitespace trailing mass cleanout Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-14 08:52:03 +08:00
ss: server: h1, h2, ws basic support Add initial support for defining servers using Secure Streams policy and api semantics. Serving h1, h2 and ws should be functional, the new minimal example shows a combined http + SS server with an incrementing ws message shown in the browser over tls, in around 200 lines of user code. NOP out anything to do with plugins, they're not currently used. Update the docs correspondingly.
2020-07-27 10:03:12 +01:00
/*
docs: add README-debugging.md and provide example points for decrypted traffic handling Some general debugging advice but also really clarify the official way of how to dump what is going out and coming in directly from the tls tunnel, so you can see the actual data unencrypted.
2020-07-30 16:23:59 +01:00
* If you're looking to dump data being sent down the tls tunnel, see
* lws_ssl_capable_write() in lib/tls/mbedtls/mbedtls-ssl.c or
* lib/tls/openssl/openssl-ssl.c.
*
* There's also a corresponding lws_ssl_capable_read() in those files
* where you can enable a dump of decrypted data as soon as it was
* read.
ss: server: h1, h2, ws basic support Add initial support for defining servers using Secure Streams policy and api semantics. Serving h1, h2 and ws should be functional, the new minimal example shows a combined http + SS server with an incrementing ws message shown in the browser over tls, in around 200 lines of user code. NOP out anything to do with plugins, they're not currently used. Update the docs correspondingly.
2020-07-27 10:03:12 +01:00
*/
close should flush any truncated send before really closing Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:25:24 +08:00
/* just ignore sends after we cleared the truncation buffer */
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
if (lwsi_state(wsi) == LRS_FLUSHING_BEFORE_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
!lws_has_buffered_out(wsi)
#if defined(LWS_WITH_HTTP_STREAM_COMPRESSION)
&& !wsi->http.comp_ctx.may_have_more
#endif
)
appveyor: Enable 64-bit build with OpenSSL and HTTP2 Fix warnings found from that Introduce lws_ptr_diff(head, tail) helper to normalize pointers to char *, do the subtraction and cast the result to int.
2017-10-25 08:00:23 +08:00
return (int)len;
handle EAGAIN during send This patch deploys the truncated send work to buffer output in case either send() or the SSL send return a temporary "unable to send" condition even though they signalled as writeable. I added a by-default #if 0 test jig which enforces only half of what you want to send is sendable, this is working when enabled. One subtle change is that the pipe reports choked if there is any pending remaining truncated send. Otherwise it should be transparent. Hopefully... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-12-09 14:16:17 +08:00
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
if (buf && lws_has_buffered_out(wsi)) {
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_info(wsi, "** prot: %s, incr buflist_out by %lu",
wsi->a.protocol->name, (unsigned long)len);
json dump vhost Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-14 15:07:44 +08:00
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
/*
* already buflist ahead of this, add it on the tail of the
* buflist, then ignore it for now and act like we're flushing
* the buflist...
*/
jwe
2018-12-13 20:05:12 +08:00
if (lws_buflist_append_segment(&wsi->buflist_out, buf, len))
return -1;
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
buf = NULL;
len = 0;
}
if (wsi->buflist_out) {
/* we have to drain the earliest buflist_out stuff first */
len = lws_buflist_next_segment_len(&wsi->buflist_out, &buf);
real_len = len;
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
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_debug(wsi, "draining %d", (int)len);
handle EAGAIN during send This patch deploys the truncated send work to buffer output in case either send() or the SSL send return a temporary "unable to send" condition even though they signalled as writeable. I added a by-default #if 0 test jig which enforces only half of what you want to send is sendable, this is working when enabled. One subtle change is that the pipe reports choked if there is any pending remaining truncated send. Otherwise it should be transparent. Hopefully... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-12-09 14:16:17 +08:00
}
autobahn fixes This replaces the old test-app for echo with separate client and server minimal versions. The autobahn test script is made more autonomous and tests both client and server.
2018-04-20 10:33:23 +08:00
clean: coverity
2018-08-23 11:48:17 +08:00
if (!len || !buf)
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
return 0;
mux children: generalize helpers out of h2 implementation This should be a NOP for h2 support and only affects internal apis. But it lets us reuse the working and reliable h2 mux arrangements directly in other protocols later, and share code so building for h2 + new protocols can take advantage of common mux child handling struct and code. Break out common mux handling struct into its own type. Convert all uses of members that used to be in wsi->h2 to wsi->mux Audit all references to the members and break out generic helpers for anything that is useful for other mux-capable protocols to reuse wsi->mux related features.
2019-12-23 11:31:57 +00:00
if (!wsi->mux_substream && !lws_socket_is_valid(wsi->desc.sockfd))
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_err(wsi, "invalid sock");
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
clean signed mismatches and protect ssl specific code https://github.com/warmcat/libwebsockets/issues/466 Signed-off-by: Andy Green <andy.green@linaro.org>
2016-03-18 23:55:59 +08:00
/* limit sending */
fakewsi: replace with smaller substructure Currently we always reserve a fakewsi per pt so events that don't have a related actual wsi, like vhost-protocol-init or vhost cert init via protocol callback can make callbacks that look reasonable to user protocol handler code expecting a valid wsi every time. This patch splits out stuff that user callbacks often unconditionally expect to be in a wsi, like context pointer, vhost pointer etc into a substructure, which is composed into struct lws at the top of it. Internal references (struct lws is opaque, so there are only internal references) are all updated to go via the substructre, the compiler should make that a NOP. Helpers are added when fakewsi is used and referenced. If not PLAT_FREERTOS, we continue to provide a full fakewsi in the pt as before, although the helpers improve consistency by zeroing down the substructure. There is a huge amount of user code out there over the last 10 years that did not always have the minimal examples to follow, some of it does some unexpected things. If it is PLAT_FREERTOS, that is a newer thing in lws and users have the benefit of being able to follow the minimal examples' approach. For PLAT_FREERTOS we don't reserve the fakewsi in the pt any more, saving around 800 bytes. The helpers then create a struct lws_a (the substructure) on the stack, zero it down (but it is only like 4 pointers) and prepare it with whatever we know like the context. Then we cast it to a struct lws * and use it in the user protocol handler call. In this case, the remainder of the struct lws is undefined. However the amount of old protocol handlers that might touch things outside of the substructure in PLAT_FREERTOS is very limited compared to legacy lws user code and the saving is significant on constrained devices. User handlers should not be touching everything in a wsi every time anyway, there are several cases where there is no valid wsi to do the call with. Dereference of things outside the substructure should only happen when the callback reason shows there is a valid wsi bound to the activity (as in all the minimal examples).
2020-07-19 08:33:46 +01:00
if (wsi->a.protocol->tx_packet_size)
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (unsigned int)wsi->a.protocol->tx_packet_size;
esp32: separate factory setup
2017-03-16 10:46:31 +08:00
else {
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (unsigned int)wsi->a.protocol->rx_buffer_size;
esp32: separate factory setup
2017-03-16 10:46:31 +08:00
if (!n)
n = context->pt_serv_buf_size;
}
output size trimming with default rxbuf fix 5e203f78e21ee3313d763d8ee6d499fa0163f51a accidentally trashed the "zero rz_buffer_size means 4096" handling for tx chunking. Signed-off-by: Andy Green <andy@warmcat.com>
2016-05-15 08:59:48 +08:00
n += LWS_PRE + 4;
clean signed mismatches and protect ssl specific code https://github.com/warmcat/libwebsockets/issues/466 Signed-off-by: Andy Green <andy.green@linaro.org>
2016-03-18 23:55:59 +08:00
if (n > len)
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (unsigned int)len;
lws_write restrict chunk size
2016-03-18 15:02:27 +08:00
clean more whitespace 2 Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-06 05:52:09 +08:00
/* nope, send it on the socket directly */
threadpool
2018-09-02 14:35:37 +08:00
Fault injection add lws_xos: xoshiro256 PRNG
2021-03-16 13:32:05 +00:00
if (lws_fi(&wsi->fic, "sendfail"))
m = (unsigned int)LWS_SSL_CAPABLE_ERROR;
else
m = (unsigned int)lws_ssl_capable_write(wsi, buf, n);
logs: log contexts
2021-06-18 07:28:23 +01:00
lwsl_wsi_info(wsi, "ssl_capable_write (%d) says %d", n, m);
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
truncated: detect and flag any write on a wsi that could have pending truncated
2017-12-07 07:20:47 +08:00
/* something got written, it can have been truncated now */
wsi->could_have_pending = 1;
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
switch ((int)m) {
refactor add ssl read write single implementation Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-06 06:26:35 +01:00
case LWS_SSL_CAPABLE_ERROR:
trac 89 add flag on fatal send fail to use simple close Signed-off-by: Andy Green <andy.green@linaro.org>
2014-10-16 08:23:46 +08:00
/* we're going to close, let close know sends aren't possible */
wsi->socket_is_permanently_unusable = 1;
refactor add ssl read write single implementation Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-06 06:26:35 +01:00
return -1;
case LWS_SSL_CAPABLE_MORE_SERVICE:
truncated: detect and flag any write on a wsi that could have pending truncated
2017-12-07 07:20:47 +08:00
/*
* nothing got sent, not fatal. Retry the whole thing later,
* ie, implying treat it was a truncated send so it gets
* retried
*/
threadpool
2018-09-02 14:35:37 +08:00
m = 0;
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
break;
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
}
autobahn fixes This replaces the old test-app for echo with separate client and server minimal versions. The autobahn test script is made more autonomous and tests both client and server.
2018-04-20 10:33:23 +08:00
COVA10081: ensure m can never be negative
2019-07-13 11:54:40 -07:00
if ((int)m < 0)
m = 0;
add explicit error for partial send This patch adds code to handle the situation that a prepared user buffer could not all be sent on the socket at once. There are two kinds of situation to handle 1) User code handles it: The connection only has extensions active that do not rewrite the buffer. In this case, the patch caused libwebsocket_write() to simply return the amount of user buffer that was consumed (this is specifically the amount of user buffer used in sending what was accepted, nothing else). So user code can just advance its buffer that much and resume sending when the socket is writable again. This continues the frame rather than starting a new one or new fragment. 2) The connections has extensions active which actually send something quite different than what the user buffer contains, for example a compression extension. In this case, libwebsockets will dynamically malloc a buffer to contain a copy of the remaining unsent data, request notifiction when writeable again, and automatically spill and free this buffer with the highest priority before passing on the writable notification to anything else. For this situation, the call to write will return that it used the whole user buffer, even though part is still rebuffered. This patch should enable libwebsockets to detect the two cases and take the appropriate action. There are also two choices for user code to deal with partial sends. 1) Leave the no_buffer_all_partial_tx member in the protocol struct at zero. The library will dyamically buffer anything you send that did not get completely written to the socket, and automatically spill it next time the socket is writable. You can use this method if your sent frames are relatvely small and unlikely to get truncated anyway. 2) Set the no_buffer_all_partial_tx member in the protocol struct. User code now needs to take care of the return value from libwebsocket_write() and deal with resending the remainder if not all of the requested amount got sent. You should use this method if you are sending large messages and want to maximize throughput and efficiency. Since the new member no_buffer_all_partial_tx will be zero by default, this patch will auto-rebuffer any partial sends by default. That's good for most cases but if you attempt to send large blocks, make sure you follow option 2) above. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-10-17 08:09:19 +08:00
/*
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
* we were sending this from buflist_out? Then not sending everything
* is a small matter of advancing ourselves only by the amount we did
* send in the buflist.
add explicit error for partial send This patch adds code to handle the situation that a prepared user buffer could not all be sent on the socket at once. There are two kinds of situation to handle 1) User code handles it: The connection only has extensions active that do not rewrite the buffer. In this case, the patch caused libwebsocket_write() to simply return the amount of user buffer that was consumed (this is specifically the amount of user buffer used in sending what was accepted, nothing else). So user code can just advance its buffer that much and resume sending when the socket is writable again. This continues the frame rather than starting a new one or new fragment. 2) The connections has extensions active which actually send something quite different than what the user buffer contains, for example a compression extension. In this case, libwebsockets will dynamically malloc a buffer to contain a copy of the remaining unsent data, request notifiction when writeable again, and automatically spill and free this buffer with the highest priority before passing on the writable notification to anything else. For this situation, the call to write will return that it used the whole user buffer, even though part is still rebuffered. This patch should enable libwebsockets to detect the two cases and take the appropriate action. There are also two choices for user code to deal with partial sends. 1) Leave the no_buffer_all_partial_tx member in the protocol struct at zero. The library will dyamically buffer anything you send that did not get completely written to the socket, and automatically spill it next time the socket is writable. You can use this method if your sent frames are relatvely small and unlikely to get truncated anyway. 2) Set the no_buffer_all_partial_tx member in the protocol struct. User code now needs to take care of the return value from libwebsocket_write() and deal with resending the remainder if not all of the requested amount got sent. You should use this method if you are sending large messages and want to maximize throughput and efficiency. Since the new member no_buffer_all_partial_tx will be zero by default, this patch will auto-rebuffer any partial sends by default. That's good for most cases but if you attempt to send large blocks, make sure you follow option 2) above. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-10-17 08:09:19 +08:00
*/
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
if (lws_has_buffered_out(wsi)) {
threadpool
2018-09-02 14:35:37 +08:00
if (m) {
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_info(wsi, "partial adv %d (vs %ld)",
m, (long)real_len);
threadpool
2018-09-02 14:35:37 +08:00
lws_buflist_use_segment(&wsi->buflist_out, m);
http: enlarge headers buffers since they may meet large headers from vhost config
2018-08-25 12:27:00 +08:00
}
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
if (!lws_has_buffered_out(wsi)) {
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_info(wsi, "buflist_out flushed");
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
m = (unsigned int)real_len;
refactor mode and states into roles and states
2018-04-02 11:55:17 +08:00
if (lwsi_state(wsi) == LRS_FLUSHING_BEFORE_CLOSE) {
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_info(wsi, "*signalling to close now");
close should flush any truncated send before really closing Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:25:24 +08:00
return -1; /* retry closing now */
fixes for close flush Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 17:06:59 +08:00
}
http: defer transaction completed if partial pending This is only helpful for http/1... the real solution is cut up sending large things.
2018-06-16 10:38:17 +08:00
lws_raw_transaction_completed This provides a way to defer closing if the output buflist has unsent content for the wsi, until the buflist is drained. It doesn't make any assumption about the content being related to http, so you can use it on raw. It follows the semantics of the http transaction completed, ie if (lws_raw_transaction_completed(wsi)) return -1 return 0;
2018-12-01 06:45:23 +08:00
if (wsi->close_when_buffered_out_drained) {
wsi->close_when_buffered_out_drained = 0;
return -1;
}
http: defer transaction completed if partial pending This is only helpful for http/1... the real solution is cut up sending large things.
2018-06-16 10:38:17 +08:00
#if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2)
clean: internally use LWS_WITH_CLIENT and _SERVER Remove some more things in LWS_WITH_SERVER=0 case
2019-08-18 05:04:15 +01:00
#if defined(LWS_WITH_SERVER)
http: defer transaction completed if partial pending This is only helpful for http/1... the real solution is cut up sending large things.
2018-06-16 10:38:17 +08:00
if (wsi->http.deferred_transaction_completed) {
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_notice(wsi, "partial completed, doing "
"deferred transaction completed");
http: defer transaction completed if partial pending This is only helpful for http/1... the real solution is cut up sending large things.
2018-06-16 10:38:17 +08:00
wsi->http.deferred_transaction_completed = 0;
issue_raw: translate transaction_completed decision about close into local semantics via Chanson Shen https://libwebsockets.org/pipermail/libwebsockets/2018-September/007672.html
2018-09-20 07:06:51 +08:00
return lws_http_transaction_completed(wsi) ?
-1 : (int)real_len;
http: defer transaction completed if partial pending This is only helpful for http/1... the real solution is cut up sending large things.
2018-06-16 10:38:17 +08:00
}
#endif
ws: make sure we understand frame finished when buflist_out flushed When lws_write as many bytes as user can until function returns not all sent, the next user`s lws_write call will write wrong frame to the other end. This will cause connection be close by the other side.
2020-03-04 17:39:11 +08:00
#endif
#if defined(LWS_ROLE_WS)
/* Since buflist_out flushed, we're not inside a frame any more */
if (wsi->ws)
wsi->ws->inside_frame = 0;
http: defer transaction completed if partial pending This is only helpful for http/1... the real solution is cut up sending large things.
2018-06-16 10:38:17 +08:00
#endif
truncated send always callback on writeable Suggested by a Windows log where leaf.jpg meets EAGAIN and after issuing the truncated send buffer, never sends any more https://github.com/warmcat/libwebsockets/issues/111#issuecomment-39873129 Added note in README.coding about WRITEABLE callbacks able to be generated by lws. Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 11:23:18 +08:00
}
/* always callback on writeable */
public api remove superfluous context params API BREAK Extend the cleanout caused by wsi having a context pointer into the public api. There's no point keeping the 1.5 compatibility work, we have changed the api in several places and rebuilt wasn't going to be enough a while ago. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-16 18:19:08 +08:00
lws_callback_on_writable(wsi);
add explicit error for partial send This patch adds code to handle the situation that a prepared user buffer could not all be sent on the socket at once. There are two kinds of situation to handle 1) User code handles it: The connection only has extensions active that do not rewrite the buffer. In this case, the patch caused libwebsocket_write() to simply return the amount of user buffer that was consumed (this is specifically the amount of user buffer used in sending what was accepted, nothing else). So user code can just advance its buffer that much and resume sending when the socket is writable again. This continues the frame rather than starting a new one or new fragment. 2) The connections has extensions active which actually send something quite different than what the user buffer contains, for example a compression extension. In this case, libwebsockets will dynamically malloc a buffer to contain a copy of the remaining unsent data, request notifiction when writeable again, and automatically spill and free this buffer with the highest priority before passing on the writable notification to anything else. For this situation, the call to write will return that it used the whole user buffer, even though part is still rebuffered. This patch should enable libwebsockets to detect the two cases and take the appropriate action. There are also two choices for user code to deal with partial sends. 1) Leave the no_buffer_all_partial_tx member in the protocol struct at zero. The library will dyamically buffer anything you send that did not get completely written to the socket, and automatically spill it next time the socket is writable. You can use this method if your sent frames are relatvely small and unlikely to get truncated anyway. 2) Set the no_buffer_all_partial_tx member in the protocol struct. User code now needs to take care of the return value from libwebsocket_write() and deal with resending the remainder if not all of the requested amount got sent. You should use this method if you are sending large messages and want to maximize throughput and efficiency. Since the new member no_buffer_all_partial_tx will be zero by default, this patch will auto-rebuffer any partial sends by default. That's good for most cases but if you attempt to send large blocks, make sure you follow option 2) above. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-10-17 08:09:19 +08:00
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
return (int)m;
add explicit error for partial send This patch adds code to handle the situation that a prepared user buffer could not all be sent on the socket at once. There are two kinds of situation to handle 1) User code handles it: The connection only has extensions active that do not rewrite the buffer. In this case, the patch caused libwebsocket_write() to simply return the amount of user buffer that was consumed (this is specifically the amount of user buffer used in sending what was accepted, nothing else). So user code can just advance its buffer that much and resume sending when the socket is writable again. This continues the frame rather than starting a new one or new fragment. 2) The connections has extensions active which actually send something quite different than what the user buffer contains, for example a compression extension. In this case, libwebsockets will dynamically malloc a buffer to contain a copy of the remaining unsent data, request notifiction when writeable again, and automatically spill and free this buffer with the highest priority before passing on the writable notification to anything else. For this situation, the call to write will return that it used the whole user buffer, even though part is still rebuffered. This patch should enable libwebsockets to detect the two cases and take the appropriate action. There are also two choices for user code to deal with partial sends. 1) Leave the no_buffer_all_partial_tx member in the protocol struct at zero. The library will dyamically buffer anything you send that did not get completely written to the socket, and automatically spill it next time the socket is writable. You can use this method if your sent frames are relatvely small and unlikely to get truncated anyway. 2) Set the no_buffer_all_partial_tx member in the protocol struct. User code now needs to take care of the return value from libwebsocket_write() and deal with resending the remainder if not all of the requested amount got sent. You should use this method if you are sending large messages and want to maximize throughput and efficiency. Since the new member no_buffer_all_partial_tx will be zero by default, this patch will auto-rebuffer any partial sends by default. That's good for most cases but if you attempt to send large blocks, make sure you follow option 2) above. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-10-17 08:09:19 +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
#if defined(LWS_WITH_HTTP_STREAM_COMPRESSION)
if (wsi->http.comp_ctx.may_have_more)
lws_callback_on_writable(wsi);
#endif
threadpool
2018-09-02 14:35:37 +08:00
if (m == real_len)
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
/* what we just sent went out cleanly */
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
return (int)m;
add explicit error for partial send This patch adds code to handle the situation that a prepared user buffer could not all be sent on the socket at once. There are two kinds of situation to handle 1) User code handles it: The connection only has extensions active that do not rewrite the buffer. In this case, the patch caused libwebsocket_write() to simply return the amount of user buffer that was consumed (this is specifically the amount of user buffer used in sending what was accepted, nothing else). So user code can just advance its buffer that much and resume sending when the socket is writable again. This continues the frame rather than starting a new one or new fragment. 2) The connections has extensions active which actually send something quite different than what the user buffer contains, for example a compression extension. In this case, libwebsockets will dynamically malloc a buffer to contain a copy of the remaining unsent data, request notifiction when writeable again, and automatically spill and free this buffer with the highest priority before passing on the writable notification to anything else. For this situation, the call to write will return that it used the whole user buffer, even though part is still rebuffered. This patch should enable libwebsockets to detect the two cases and take the appropriate action. There are also two choices for user code to deal with partial sends. 1) Leave the no_buffer_all_partial_tx member in the protocol struct at zero. The library will dyamically buffer anything you send that did not get completely written to the socket, and automatically spill it next time the socket is writable. You can use this method if your sent frames are relatvely small and unlikely to get truncated anyway. 2) Set the no_buffer_all_partial_tx member in the protocol struct. User code now needs to take care of the return value from libwebsocket_write() and deal with resending the remainder if not all of the requested amount got sent. You should use this method if you are sending large messages and want to maximize throughput and efficiency. Since the new member no_buffer_all_partial_tx will be zero by default, this patch will auto-rebuffer any partial sends by default. That's good for most cases but if you attempt to send large blocks, make sure you follow option 2) above. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-10-17 08:09:19 +08:00
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
/*
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
* We were not able to send everything... and we were not sending from
* an existing buflist_out. So we are starting a fresh buflist_out, by
* buffering the unsent remainder on it.
* (it will get first priority next time the socket is writable).
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
*/
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_debug(wsi, "new partial sent %d from %lu total",
m, (unsigned long)real_len);
add explicit error for partial send This patch adds code to handle the situation that a prepared user buffer could not all be sent on the socket at once. There are two kinds of situation to handle 1) User code handles it: The connection only has extensions active that do not rewrite the buffer. In this case, the patch caused libwebsocket_write() to simply return the amount of user buffer that was consumed (this is specifically the amount of user buffer used in sending what was accepted, nothing else). So user code can just advance its buffer that much and resume sending when the socket is writable again. This continues the frame rather than starting a new one or new fragment. 2) The connections has extensions active which actually send something quite different than what the user buffer contains, for example a compression extension. In this case, libwebsockets will dynamically malloc a buffer to contain a copy of the remaining unsent data, request notifiction when writeable again, and automatically spill and free this buffer with the highest priority before passing on the writable notification to anything else. For this situation, the call to write will return that it used the whole user buffer, even though part is still rebuffered. This patch should enable libwebsockets to detect the two cases and take the appropriate action. There are also two choices for user code to deal with partial sends. 1) Leave the no_buffer_all_partial_tx member in the protocol struct at zero. The library will dyamically buffer anything you send that did not get completely written to the socket, and automatically spill it next time the socket is writable. You can use this method if your sent frames are relatvely small and unlikely to get truncated anyway. 2) Set the no_buffer_all_partial_tx member in the protocol struct. User code now needs to take care of the return value from libwebsocket_write() and deal with resending the remainder if not all of the requested amount got sent. You should use this method if you are sending large messages and want to maximize throughput and efficiency. Since the new member no_buffer_all_partial_tx will be zero by default, this patch will auto-rebuffer any partial sends by default. That's good for most cases but if you attempt to send large blocks, make sure you follow option 2) above. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-10-17 08:09:19 +08:00
COVA11294: check mpi_write_binary retcode
2019-07-13 12:01:39 -07:00
if (lws_buflist_append_segment(&wsi->buflist_out, buf + m,
real_len - m) < 0)
return -1;
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#if defined(LWS_WITH_UDP)
udp: convert to sa46 Let's stop using sockaddr and migrate to lws_sockaddr46 so the udp path works more the same as the tcp / uds client connect path.
2020-10-14 08:55:40 +01:00
if (lws_wsi_is_udp(wsi))
udp
2018-03-24 08:07:00 +08:00
/* stash original destination for fulfilling UDP partials */
udp: convert to sa46 Let's stop using sockaddr and migrate to lws_sockaddr46 so the udp path works more the same as the tcp / uds client connect path.
2020-10-14 08:55:40 +01:00
wsi->udp->sa46_pending = wsi->udp->sa46;
alpn: assemble defaults from roles and allow override Since new roles may be incompatible with http, add support for alpn names at the role struct, automatic generation of the default list of alpn names that servers advertise, and the ability to override the used alpn names per-vhost and per- client connection. This not only lets you modulate visibility or use of h2, but also enables vhosts that only offer non-http roles, as well as restricting http role vhosts to only alpn identifiers related to http roles.
2018-04-12 15:56:38 +08:00
#endif
udp
2018-03-24 08:07:00 +08:00
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
/* since something buffered, force it to get another chance to send */
public api remove superfluous context params API BREAK Extend the cleanout caused by wsi having a context pointer into the public api. There's no point keeping the 1.5 compatibility work, we have changed the api in several places and rebuilt wasn't going to be enough a while ago. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-16 18:19:08 +08:00
lws_callback_on_writable(wsi);
add explicit error for partial send This patch adds code to handle the situation that a prepared user buffer could not all be sent on the socket at once. There are two kinds of situation to handle 1) User code handles it: The connection only has extensions active that do not rewrite the buffer. In this case, the patch caused libwebsocket_write() to simply return the amount of user buffer that was consumed (this is specifically the amount of user buffer used in sending what was accepted, nothing else). So user code can just advance its buffer that much and resume sending when the socket is writable again. This continues the frame rather than starting a new one or new fragment. 2) The connections has extensions active which actually send something quite different than what the user buffer contains, for example a compression extension. In this case, libwebsockets will dynamically malloc a buffer to contain a copy of the remaining unsent data, request notifiction when writeable again, and automatically spill and free this buffer with the highest priority before passing on the writable notification to anything else. For this situation, the call to write will return that it used the whole user buffer, even though part is still rebuffered. This patch should enable libwebsockets to detect the two cases and take the appropriate action. There are also two choices for user code to deal with partial sends. 1) Leave the no_buffer_all_partial_tx member in the protocol struct at zero. The library will dyamically buffer anything you send that did not get completely written to the socket, and automatically spill it next time the socket is writable. You can use this method if your sent frames are relatvely small and unlikely to get truncated anyway. 2) Set the no_buffer_all_partial_tx member in the protocol struct. User code now needs to take care of the return value from libwebsocket_write() and deal with resending the remainder if not all of the requested amount got sent. You should use this method if you are sending large messages and want to maximize throughput and efficiency. Since the new member no_buffer_all_partial_tx will be zero by default, this patch will auto-rebuffer any partial sends by default. That's good for most cases but if you attempt to send large blocks, make sure you follow option 2) above. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-10-17 08:09:19 +08:00
appveyor: Enable 64-bit build with OpenSSL and HTTP2 Fix warnings found from that Introduce lws_ptr_diff(head, tail) helper to normalize pointers to char *, do the subtraction and cast the result to int.
2017-10-25 08:00:23 +08:00
return (int)real_len;
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
}
detailed latency stats Remove LWS_LATENCY. Add the option LWS_WITH_DETAILED_LATENCY, allowing lws to collect very detailed information on every read and write, and allow the user code to provide a callback to process events.
2019-08-23 16:10:36 +01:00
int
lws_write(struct lws *wsi, unsigned char *buf, size_t len,
enum lws_write_protocol wp)
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
{
detailed latency stats Remove LWS_LATENCY. Add the option LWS_WITH_DETAILED_LATENCY, allowing lws to collect very detailed information on every read and write, and allow the user code to provide a callback to process events.
2019-08-23 16:10:36 +01:00
int m;
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
lws_write: report and reject suspicious lengths
2017-05-08 10:49:10 +08:00
if ((int)len < 0) {
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_err(wsi, "suspicious len int %d, ulong %lu",
(int)len, (unsigned long)len);
lws_write: report and reject suspicious lengths
2017-05-08 10:49:10 +08:00
return -1;
}
lws access log option and lwsws conf This adds the ability to store apache-compatible logs to a file given at vhost-creation time. lwsws conf can set it per-vhost using "access-log": "<filepath>" The feature defaults to disabled at cmake, it can be set independently but LWS_WITH_LWSWS set it on. Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-15 12:00:23 +08:00
#ifdef LWS_WITH_ACCESS_LOG
refactor: most preparation for -DLWS_ROLE_H1=0
2018-04-27 19:16:50 +08:00
wsi->http.access_log.sent += len;
lws access log option and lwsws conf This adds the ability to store apache-compatible logs to a file given at vhost-creation time. lwsws conf can set it per-vhost using "access-log": "<filepath>" The feature defaults to disabled at cmake, it can be set independently but LWS_WITH_LWSWS set it on. Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-15 12:00:23 +08:00
#endif
refactor role ops This only refactors internal architecture and representations, the user api is unaffected.
2018-04-11 13:39:42 +08:00
assert(wsi->role_ops);
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_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
m = lws_issue_raw(wsi, buf, len);
else
m = lws_rops_func_fidx(wsi->role_ops, LWS_ROPS_write_role_protocol).
write_role_protocol(wsi, buf, len, &wp);
detailed latency stats Remove LWS_LATENCY. Add the option LWS_WITH_DETAILED_LATENCY, allowing lws to collect very detailed information on every read and write, and allow the user code to provide a callback to process events.
2019-08-23 16:10:36 +01:00
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
#if defined(LWS_WITH_SYS_METRICS)
if (wsi->a.vhost)
lws_metric_event(wsi->a.vhost->mt_traffic_tx, (char)
(m < 0 ? METRES_NOGO : METRES_GO), len);
detailed latency stats Remove LWS_LATENCY. Add the option LWS_WITH_DETAILED_LATENCY, allowing lws to collect very detailed information on every read and write, and allow the user code to provide a callback to process events.
2019-08-23 16:10:36 +01:00
#endif
return m;
refactor output.c Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-16 12:21:29 +08:00
}
detailed latency stats Remove LWS_LATENCY. Add the option LWS_WITH_DETAILED_LATENCY, allowing lws to collect very detailed information on every read and write, and allow the user code to provide a callback to process events.
2019-08-23 16:10:36 +01:00
int
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
lws_ssl_capable_read_no_ssl(struct lws *wsi, unsigned char *buf, size_t len)
refactor add ssl read write single implementation Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-06 06:26:35 +01:00
{
h2: post buflist: track rx_content_length On h2 server POST, there's a race to see if the POST body is going to be received coalesced with the headers. The problem is on h2, we can't action the stream http request or body until the stream is writeable, since we may start issuing the response right away; there's already DEFERRING_ACTION state to manage this. And indeed, the coalesced, not-immediately-actionable POST body is buflisted properly. However when we come to action the POST using buflisted data, we don't follow the same pattern as dealing with the incoming data immediately. This patch aligns the pattern dumping the buflist content to track expected rx_content_length and handle BODY_COMPLETION if we got to the end of it, along with removal from the pt list of wsi with pending buflists if we used it up.
2021-01-18 14:20:37 +00:00
int n = 0, en;
LWS_WITH_STATS
2017-05-07 10:02:03 +08:00
nossl recv: always respond to 0 length read as shutdown
2019-03-21 06:47:54 +08:00
errno = 0;
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#if defined(LWS_WITH_UDP)
udp
2018-03-24 08:07:00 +08:00
if (lws_wsi_is_udp(wsi)) {
udp: convert to sa46 Let's stop using sockaddr and migrate to lws_sockaddr46 so the udp path works more the same as the tcp / uds client connect path.
2020-10-14 08:55:40 +01:00
socklen_t slt = sizeof(wsi->udp->sa46);
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (int)recvfrom(wsi->desc.sockfd, (char *)buf,
#if defined(WIN32)
(int)
#endif
len, 0,
udp: convert to sa46 Let's stop using sockaddr and migrate to lws_sockaddr46 so the udp path works more the same as the tcp / uds client connect path.
2020-10-14 08:55:40 +01:00
sa46_sockaddr(&wsi->udp->sa46), &slt);
udp
2018-03-24 08:07:00 +08:00
} else
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#endif
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (int)recv(wsi->desc.sockfd, (char *)buf,
#if defined(WIN32)
(int)
#endif
len, 0);
h2: post buflist: track rx_content_length On h2 server POST, there's a race to see if the POST body is going to be received coalesced with the headers. The problem is on h2, we can't action the stream http request or body until the stream is writeable, since we may start issuing the response right away; there's already DEFERRING_ACTION state to manage this. And indeed, the coalesced, not-immediately-actionable POST body is buflisted properly. However when we come to action the POST using buflisted data, we don't follow the same pattern as dealing with the incoming data immediately. This patch aligns the pattern dumping the buflist content to track expected rx_content_length and handle BODY_COMPLETION if we got to the end of it, along with removal from the pt list of wsi with pending buflists if we used it up.
2021-01-18 14:20:37 +00:00
en = LWS_ERRNO;
recv revert treating zero as hangup While checking with ab, I found commit 30cdb3ac8f24a4c289a3b4e8a41d6c5f2e6ec959 Author: Justin Chen <justinchen00@github.invalid.com> Date: Thu Apr 14 21:40:53 2016 +0800 recv treat zero return as error https://github.com/warmcat/libwebsockets/issues/475 turned ab performance to crap, reverting it made everything fast again. recv manpage says there is three ways to get zero returned 1) When a stream socket peer has performed an orderly shutdown, the return value will be 0 (the traditional "end-of-file" return). 2) Datagram sockets in various domains (e.g., the UNIX and Internet domains) permit zero-length datagrams. When such a datagram is received, the return value is 0. 3) The value 0 may also be returned if the requested number of bytes to receive from a stream socket was 0. we can't just assume it means the peer shut down. If the peer shut down, then the event loop should get an event on the socket like POLLHUP and deal with it that way. So the patch mentioned above is simply reverted here. Signed-off-by: Andy Green <andy@warmcat.com>
2016-05-05 09:06:09 +08:00
if (n >= 0) {
http proxy: client: unix socket support This allows the client stuff to understand that addresses beginning with '+' represent unix sockets. If the first character after the '+' is '@', it understands that the '@' should be read as '\0', in order to use Linux "abstract namespace" sockets. Further the lws_parse_uri() helper is extended to understand the convention that an address starting with + is a unix socket, and treats the socket path as delimited by ':', eg http://+/var/run/mysocket:/my/path HTTP Proxy is updated to allow mounts to these unix socket paths. Proxy connections go out on h1, but are dynamically translated to h1 or h2 on the incoming side. Proxy usage of libhubbub is separated out... LWS_WITH_HTTP_PROXY is on by default, and LWS_WITH_HUBBUB is off by default.
2018-09-04 08:06:46 +08:00
unix_skt: handle 0 length read as close This was commented during the metrics patch for some reason... commenting it breaks UDS -> web serving proxying. Uncomment it and see what the other problem is..
2021-03-19 15:30:43 +00:00
if (!n && wsi->unix_skt)
goto do_err;
http proxy: client: unix socket support This allows the client stuff to understand that addresses beginning with '+' represent unix sockets. If the first character after the '+' is '@', it understands that the '@' should be read as '\0', in order to use Linux "abstract namespace" sockets. Further the lws_parse_uri() helper is extended to understand the convention that an address starting with + is a unix socket, and treats the socket path as delimited by ':', eg http://+/var/run/mysocket:/my/path HTTP Proxy is updated to allow mounts to these unix socket paths. Proxy connections go out on h1, but are dynamically translated to h1 or h2 on the incoming side. Proxy usage of libhubbub is separated out... LWS_WITH_HTTP_PROXY is on by default, and LWS_WITH_HUBBUB is off by default.
2018-09-04 08:06:46 +08:00
nossl recv: always respond to 0 length read as shutdown
2019-03-21 06:47:54 +08:00
/*
* See https://libwebsockets.org/
* pipermail/libwebsockets/2019-March/007857.html
*/
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
if (!n && !wsi->unix_skt)
goto do_err;
nossl recv: always respond to 0 length read as shutdown
2019-03-21 06:47:54 +08:00
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
#if defined(LWS_WITH_SYS_METRICS) && defined(LWS_WITH_SERVER)
fakewsi: replace with smaller substructure Currently we always reserve a fakewsi per pt so events that don't have a related actual wsi, like vhost-protocol-init or vhost cert init via protocol callback can make callbacks that look reasonable to user protocol handler code expecting a valid wsi every time. This patch splits out stuff that user callbacks often unconditionally expect to be in a wsi, like context pointer, vhost pointer etc into a substructure, which is composed into struct lws at the top of it. Internal references (struct lws is opaque, so there are only internal references) are all updated to go via the substructre, the compiler should make that a NOP. Helpers are added when fakewsi is used and referenced. If not PLAT_FREERTOS, we continue to provide a full fakewsi in the pt as before, although the helpers improve consistency by zeroing down the substructure. There is a huge amount of user code out there over the last 10 years that did not always have the minimal examples to follow, some of it does some unexpected things. If it is PLAT_FREERTOS, that is a newer thing in lws and users have the benefit of being able to follow the minimal examples' approach. For PLAT_FREERTOS we don't reserve the fakewsi in the pt any more, saving around 800 bytes. The helpers then create a struct lws_a (the substructure) on the stack, zero it down (but it is only like 4 pointers) and prepare it with whatever we know like the context. Then we cast it to a struct lws * and use it in the user protocol handler call. In this case, the remainder of the struct lws is undefined. However the amount of old protocol handlers that might touch things outside of the substructure in PLAT_FREERTOS is very limited compared to legacy lws user code and the saving is significant on constrained devices. User handlers should not be touching everything in a wsi every time anyway, there are several cases where there is no valid wsi to do the call with. Dereference of things outside the substructure should only happen when the callback reason shows there is a valid wsi bound to the activity (as in all the minimal examples).
2020-07-19 08:33:46 +01:00
if (wsi->a.vhost)
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
lws_metric_event(wsi->a.vhost->mt_traffic_rx,
METRES_GO /* rx */, (unsigned int)n);
debloat: remove things from being built by default that should be conditional
2019-08-18 06:29:34 +01:00
#endif
udp
2018-03-24 08:07:00 +08:00
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
return n;
plugin lws server status Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-15 14:01:29 +08:00
}
refactor role ops This only refactors internal architecture and representations, the user api is unaffected.
2018-04-11 13:39:42 +08:00
h2: post buflist: track rx_content_length On h2 server POST, there's a race to see if the POST body is going to be received coalesced with the headers. The problem is on h2, we can't action the stream http request or body until the stream is writeable, since we may start issuing the response right away; there's already DEFERRING_ACTION state to manage this. And indeed, the coalesced, not-immediately-actionable POST body is buflisted properly. However when we come to action the POST using buflisted data, we don't follow the same pattern as dealing with the incoming data immediately. This patch aligns the pattern dumping the buflist content to track expected rx_content_length and handle BODY_COMPLETION if we got to the end of it, along with removal from the pt list of wsi with pending buflists if we used it up.
2021-01-18 14:20:37 +00:00
if (en == LWS_EAGAIN ||
en == LWS_EWOULDBLOCK ||
en == LWS_EINTR)
allow EAGAIN and friends on straight read
2015-10-15 21:21:06 +08:00
return LWS_SSL_CAPABLE_MORE_SERVICE;
refactor role ops This only refactors internal architecture and representations, the user api is unaffected.
2018-04-11 13:39:42 +08:00
lws_metrics There are a few build options that are trying to keep and report various statistics - DETAILED_LATENCY - SERVER_STATUS - WITH_STATS remove all those and establish a generic rplacement, lws_metrics. lws_metrics makes its stats available via an lws_system ops function pointer that the user code can set. Openmetrics export is supported, for, eg, prometheus scraping.
2021-01-06 15:08:22 +00:00
do_err:
#if defined(LWS_WITH_SYS_METRICS) && defined(LWS_WITH_SERVER)
if (wsi->a.vhost)
lws_metric_event(wsi->a.vhost->mt_traffic_rx, METRES_NOGO, 0u);
#endif
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_info(wsi, "error on reading from skt : %d, errno %d", n, en);
h2: post buflist: track rx_content_length On h2 server POST, there's a race to see if the POST body is going to be received coalesced with the headers. The problem is on h2, we can't action the stream http request or body until the stream is writeable, since we may start issuing the response right away; there's already DEFERRING_ACTION state to manage this. And indeed, the coalesced, not-immediately-actionable POST body is buflisted properly. However when we come to action the POST using buflisted data, we don't follow the same pattern as dealing with the incoming data immediately. This patch aligns the pattern dumping the buflist content to track expected rx_content_length and handle BODY_COMPLETION if we got to the end of it, along with removal from the pt list of wsi with pending buflists if we used it up.
2021-01-18 14:20:37 +00:00
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
return LWS_SSL_CAPABLE_ERROR;
refactor add ssl read write single implementation Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-06 06:26:35 +01:00
}
detailed latency stats Remove LWS_LATENCY. Add the option LWS_WITH_DETAILED_LATENCY, allowing lws to collect very detailed information on every read and write, and allow the user code to provide a callback to process events.
2019-08-23 16:10:36 +01:00
int
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
lws_ssl_capable_write_no_ssl(struct lws *wsi, unsigned char *buf, size_t len)
refactor add ssl read write single implementation Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-06 06:26:35 +01:00
{
mbed3 workable plus or minus mbed3 net stack bug https://github.com/ARMmbed/sockets/issues/35 Signed-off-by: Andy Green <andy.green@linaro.org>
2015-11-08 12:10:26 +08:00
int n = 0;
optee: other plat fixes
2019-01-11 17:14:04 +08:00
#if defined(LWS_PLAT_OPTEE)
mbedtls: finer-grained enable checks and OP-TEE
2019-01-11 13:14:32 +08:00
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
optee: other plat fixes
2019-01-11 17:14:04 +08:00
#endif
mbed3 plat Signed-off-by: Andy Green <andy.green@linaro.org>
2015-11-02 20:34:12 +08:00
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#if defined(LWS_WITH_UDP)
udp
2018-03-24 08:07:00 +08:00
if (lws_wsi_is_udp(wsi)) {
Fault injection add lws_xos: xoshiro256 PRNG
2021-03-16 13:32:05 +00:00
if (lws_fi(&wsi->fic, "udp_tx_loss")) {
/* pretend it was sent */
n = (int)(ssize_t)len;
goto post_send;
lws_retry: udp support
2019-09-08 08:08:55 +01:00
}
client: rfc6724 dns results sorting RFC6724 defines an ipv6-centric DNS result sorting algorithm, that takes route and source address route information for the results given by the DNS resolution, and sorts them in order of preferability, which defines the order they should be tried in. If LWS_WITH_NETLINK, then lws takes care about collecting and monitoring the interface, route and source address information, and uses it to perform the RFC6724 sorting to re-sort the DNS before trying to make the connections.
2020-09-20 09:14:46 +01:00
partial: replace ad-hoc code with a wsi buflist_out Various kinds of input stashing were replaced with a single buflist before v3.0... this patch replaces the partial send arrangements with its own buflist in the same way. Buflists as the name says are growable lists of allocations in a linked-list that take care of book-keeping what's added and removed (even if what is removed is less than the current buffer on the list). The immediate result is that we no longer have to freak out if we had a partial buffered and new output is coming... we can just pile it on the end of the buflist and keep draining the front of it. Likewise we no longer need to be rabid about reporting multiple attempts to send stuff without going back to the event loop, although not doing that will introduce inefficiencies we don't have to term it "illegal" any more. Since buflists have proven reliable on the input side and the logic for dealing with truncated "non-network events" was already there this internal-only change should be relatively self-contained.
2018-08-20 12:02:26 +08:00
if (lws_has_buffered_out(wsi))
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (int)sendto(wsi->desc.sockfd, (const char *)buf,
#if defined(WIN32)
(int)
#endif
udp: convert to sa46 Let's stop using sockaddr and migrate to lws_sockaddr46 so the udp path works more the same as the tcp / uds client connect path.
2020-10-14 08:55:40 +01:00
len, 0, sa46_sockaddr(&wsi->udp->sa46_pending),
sa46_socklen(&wsi->udp->sa46_pending));
udp
2018-03-24 08:07:00 +08:00
else
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (int)sendto(wsi->desc.sockfd, (const char *)buf,
#if defined(WIN32)
(int)
#endif
udp: convert to sa46 Let's stop using sockaddr and migrate to lws_sockaddr46 so the udp path works more the same as the tcp / uds client connect path.
2020-10-14 08:55:40 +01:00
len, 0, sa46_sockaddr(&wsi->udp->sa46),
sa46_socklen(&wsi->udp->sa46));
udp
2018-03-24 08:07:00 +08:00
} else
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#endif
minimal-raw-serial Add a minimal example showing how to set up, send and receive on a serial tty in the event loop.
2019-12-08 16:34:13 +00:00
if (wsi->role_ops->file_handle)
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (int)write((int)(lws_intptr_t)wsi->desc.filefd, buf,
#if defined(WIN32)
(int)
#endif
len);
minimal-raw-serial Add a minimal example showing how to set up, send and receive on a serial tty in the event loop.
2019-12-08 16:34:13 +00:00
else
type comparisons: fixes This is a huge patch that should be a global NOP. For unix type platforms it enables -Wconversion to issue warnings (-> error) for all automatic casts that seem less than ideal but are normally concealed by the toolchain. This is things like passing an int to a size_t argument. Once enabled, I went through all args on my default build (which build most things) and tried to make the removed default cast explicit. With that approach it neither change nor bloat the code, since it compiles to whatever it was doing before, just with the casts made explicit... in a few cases I changed some length args from int to size_t but largely left the causes alone. From now on, new code that is relying on less than ideal casting will complain and nudge me to improve it by warnings.
2020-12-12 06:21:40 +00:00
n = (int)send(wsi->desc.sockfd, (char *)buf,
#if defined(WIN32)
(int)
#endif
len, MSG_NOSIGNAL);
reduce debug logging mark socket dead when pollert Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-27 08:50:31 +08:00
// lwsl_info("%s: sent len %d result %d", __func__, len, n);
lws_retry: udp support
2019-09-08 08:08:55 +01:00
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#if defined(LWS_WITH_UDP)
lws_retry: udp support
2019-09-08 08:08:55 +01:00
post_send:
LWS_WITH_UDP
2019-09-30 09:42:38 -07:00
#endif
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
if (n >= 0)
return n;
if (LWS_ERRNO == LWS_EAGAIN ||
LWS_ERRNO == LWS_EWOULDBLOCK ||
LWS_ERRNO == LWS_EINTR) {
ESP32 platform This is enough for all the test app features to work on ESP32 without SSL.
2017-02-18 17:26:40 +08:00
if (LWS_ERRNO == LWS_EWOULDBLOCK) {
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
lws_set_blocking_send(wsi);
ESP32 platform This is enough for all the test app features to work on ESP32 without SSL.
2017-02-18 17:26:40 +08:00
}
refactor add ssl read write single implementation Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-06 06:26:35 +01:00
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
return LWS_SSL_CAPABLE_MORE_SERVICE;
}
whitespace trailing mass cleanout Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-14 08:52:03 +08:00
logs: more internal conversion to log_cx
2021-06-28 05:05:57 +01:00
lwsl_wsi_debug(wsi, "ERROR writing len %d to skt fd %d err %d / errno %d",
(int)(ssize_t)len, wsi->desc.sockfd, n, LWS_ERRNO);
h2 ws: fixes against chrome
2018-03-11 11:26:06 +08:00
clean=various ifdef reduction Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-10 14:08:10 +08:00
return LWS_SSL_CAPABLE_ERROR;
refactor add ssl read write single implementation Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-06 06:26:35 +01:00
}
refactor role ops This only refactors internal architecture and representations, the user api is unaffected.
2018-04-11 13:39:42 +08:00
detailed latency stats Remove LWS_LATENCY. Add the option LWS_WITH_DETAILED_LATENCY, allowing lws to collect very detailed information on every read and write, and allow the user code to provide a callback to process events.
2019-08-23 16:10:36 +01:00
int
api rationalization: eliminate all libwebsocket[s]_ prefixes This nukes all the oldstyle prefixes except in the compatibility code. struct libwebsockets becomes struct lws too. The api docs are updated accordingly as are the READMEs that mention those apis. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-04 11:08:32 +08:00
lws_ssl_pending_no_ssl(struct lws *wsi)
fix #309. Receive large messages over WSS Read the full incoming TLS/SSL record at once in libwebsocket_service_fd(). SSL_read() is called until no more pending data for the current record is buffered in SSL. SSL_read() is never requested more than the pending data size for the current record to ensure that the fd is not read again for new data, which would be copied in the SSL buffer otherwise.
2015-08-19 16:23:33 +02:00
{
mbed3 warning cleaning Signed-off-by: Andy Green <andy.green@linaro.org>
2015-11-02 13:10:33 +08:00
(void)wsi;
freertos: rename esp32 plat to freertos
2019-08-18 10:35:43 +01:00
#if defined(LWS_PLAT_FREERTOS)
esp32: reapply pending count just for esp32
2017-05-07 08:19:55 +08:00
return 100;
#else
non-ssl: return 0 on pending https://github.com/warmcat/libwebsockets/issues/887
2017-05-03 21:28:26 +08:00
return 0;
esp32: reapply pending count just for esp32
2017-05-07 08:19:55 +08:00
#endif
fix #309. Receive large messages over WSS Read the full incoming TLS/SSL record at once in libwebsocket_service_fd(). SSL_read() is called until no more pending data for the current record is buffered in SSL. SSL_read() is never requested more than the pending data size for the current record to ensure that the fd is not read again for new data, which would be copied in the SSL buffer otherwise.
2015-08-19 16:23:33 +02:00
}
Reference in a new issue Copy permalink