Mirrors/libwebsockets
1
0
Fork 0
mirror of https://github.com/warmcat/libwebsockets.git synced 2025-03-16 00:00:07 +01:00
Code Issues Releases Wiki Activity
libwebsockets/lib/roles/http/server/parsers.c

1140 lines
26 KiB
C
Raw Normal View History

break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
/*
* libwebsockets - small server side websockets and web server implementation
coding-style-cleanups.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-13 10:03:47 +00:00
*
refactor role ops This only refactors internal architecture and representations, the user api is unaffected.
2018-04-11 13:39:42 +08:00
* Copyright (C) 2010-2018 Andy Green <andy@warmcat.com>
break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation:
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*/
#include "private-libwebsockets.h"
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
static const unsigned char lextable[] = {
refactor role ops This only refactors internal architecture and representations, the user api is unaffected.
2018-04-11 13:39:42 +08:00
#include "../lextable.h"
add lexical parser for headers Profiling what happens during the ab test, one of the hotspots was strcasecmp in a loop looking for header name matches each time. This patch introduces a lexical parser that creates a state machine in 276 bytes that encodes all the known header names. The fsm is walked bytewise as chaacters come in... most states do not need any recursion to match or fail. The state machine output is cut-and-pasted into parsers.c as an unsigned char array. The fsm generator is a bit rough and ready, included in the tree but not built since normal mortals won't need to touch it. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-18 01:55:48 +08:00
};
upgrade and improve storage efficiency of minilex Until now minilex has done fine with providing a simple and fast header decode state machine. But for HTTP2.0, new headers must be added and it is already on the limit of table branching in 1 byte (already using +0xf8 of a max limit of 0xff). This changes the minilex format to improve storage size without loss of decode efficiency. It reduces the curent lws header table from 546 -> 403 bytes and upgrades the ability to increase table size by allowing jumps to increase from the old limit of +255 states to +65535 states, which should be enough for anything we ever want to do. The max number of terminals is also increased from 128 to 2048. Signed-off-by: Andy Green <andy.green@linaro.org>
2014-03-09 11:49:21 +08:00
#define FAIL_CHAR 0x08
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
static struct allocated_headers *
_lws_create_ah(struct lws_context_per_thread *pt, ah_data_idx_t data_size)
{
struct allocated_headers *ah = lws_zalloc(sizeof(*ah), "ah struct");
if (!ah)
return NULL;
ah->data = lws_malloc(data_size, "ah data");
if (!ah->data) {
lws_free(ah);
return NULL;
}
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
ah->next = pt->http.ah_list;
pt->http.ah_list = ah;
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
ah->data_length = data_size;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
pt->http.ah_pool_length++;
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
lwsl_info("%s: created ah %p (size %d): pool length %d\n", __func__,
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
ah, (int)data_size, pt->http.ah_pool_length);
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
return ah;
}
int
_lws_destroy_ah(struct lws_context_per_thread *pt, struct allocated_headers *ah)
{
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
lws_start_foreach_llp(struct allocated_headers **, a, pt->http.ah_list) {
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
if ((*a) == ah) {
*a = ah->next;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
pt->http.ah_pool_length--;
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
lwsl_info("%s: freed ah %p : pool length %d\n",
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
__func__, ah, pt->http.ah_pool_length);
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
if (ah->data)
lws_free(ah->data);
lws_free(ah);
return 0;
}
} lws_end_foreach_llp(a, next);
return 1;
}
client: fix redirects and allow ssl / non-ssl redirects
2017-02-09 15:25:01 +08:00
void
_lws_header_table_reset(struct allocated_headers *ah)
{
/* init the ah to reflect no headers or data have appeared yet */
memset(ah->frag_index, 0, sizeof(ah->frag_index));
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
memset(ah->frags, 0, sizeof(ah->frags));
client: fix redirects and allow ssl / non-ssl redirects
2017-02-09 15:25:01 +08:00
ah->nfrag = 0;
ah->pos = 0;
ah->http_response = 0;
}
lws_header_table_reset: make caller responsibility to clear down ah rx buffer There are two kinds of reaason to call lws_header_table_reset(), one is we are reallocating a destroyed ah to another wsi, and the other is we are moving to the next pipelined header set still on the same wsi, and we need a "weaker" reset that only clears down the state related to the header parsing, not everything about the ah context including the ah rx buffer. This patch moves the ah rxbuffer rxpos and rxlen resetting out of lws_header_table_reset() and to be the responsibility of the caller. Callers who are moving the ah to another wsi are patched to deal with resetting rxpos and rxlen and lws_http_transaction_completed() who only resets the ah when moving to the next pipelined headers, no longer wrongly clears the ah rxbuf. https://github.com/warmcat/libwebsockets/issues/638
2016-09-29 10:31:06 +08:00
// doesn't scrub the ah rxbuffer by default, parent must do if needed
ah http1.1 deal with pipelined headers properly Connections must hold an ah for the whole time they are processing one header set, even if eg, the headers are fragmented and it involves network roundtrip times. However on http1.1 / keepalive, it must drop the ah when there are no more header sets to deal with, and reacquire the ah later when more data appears. It's because the time between header sets / http1.1 requests is unbounded and the ah would be tied up forever. But in the case that we got pipelined http1.1 requests, even partial already buffered, we must keep the ah, resetting it instead of dropping it. Because we store the rx data conveniently in a per-tsi buffer since it only does one thing at a time per thread, we cannot go back to the event loop to await a new ah inside one service action. But no problem since we definitely already have an ah, let's just reuse it at http completion time if more rx is already buffered. NB: attack.sh makes request with echo | nc, this accidentally sends a trailing '\n' from the echo showing this problem. With this patch attack.sh can complete well. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-30 11:43:10 +08:00
void
smp: fixes
2018-03-02 14:22:49 +08:00
__lws_header_table_reset(struct lws *wsi, int autoservice)
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
{
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
struct allocated_headers *ah = wsi->http.ah;
adopt readbuf do service Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-27 11:42:22 +08:00
struct lws_context_per_thread *pt;
struct lws_pollfd *pfd;
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
/* if we have the idea we're resetting 'our' ah, must be bound to one */
assert(ah);
/* ah also concurs with ownership */
assert(ah->wsi == wsi);
lws_reset_header_table dont reset NULL This is only a temporary, fragile solution. https://github.com/warmcat/libwebsockets/issues/416 Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-09 09:15:02 +08:00
client: fix redirects and allow ssl / non-ssl redirects
2017-02-09 15:25:01 +08:00
_lws_header_table_reset(ah);
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->parser_state = WSI_TOKEN_NAME_PART;
ah->lextable_pos = 0;
serving: protect file sending from downgrading to waiting pipelined headers https://github.com/warmcat/libwebsockets/issues/946
2017-06-27 10:07:34 +08:00
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
/* since we will restart the ah, our new headers are not completed */
ah reset: enforce reset of parsing_complete
2017-06-28 09:55:34 +08:00
wsi->hdr_parsing_completed = 0;
adopt variant with preamble rx Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-24 11:05:56 +08:00
ah: allow configurable ah hold timeout
2017-07-26 11:49:41 +08:00
/* while we hold the ah, keep a timeout on the wsi */
smp: fixes
2018-03-02 14:22:49 +08:00
__lws_set_timeout(wsi, PENDING_TIMEOUT_HOLDING_AH,
ah: allow configurable ah hold timeout
2017-07-26 11:49:41 +08:00
wsi->vhost->timeout_secs_ah_idle);
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
time(&ah->assigned);
refactor: absorb other caches into buflist 1) Remove the whole ah rxbuf and put things on to the wsi buflist This eliminates the whole detachability thing based on ah rxbuf state... ah can always be detached. 2) Remove h2 scratch and put it on the wsi buflist 3) Remove preamble_rx and use the wsi buflist This was used in the case adopted sockets had already been read. Basically there are now only three forced service scenarios - something in buflist (and not in state LRS_DEFERRING_ACTION) - tls layer has buffered rx - extension has buffered rx This is a net removal of around 400 lines of special-casing.
2018-04-17 15:35:15 +08:00
if (lws_buflist_next_segment_len(&wsi->buflist, NULL) &&
autoservice) {
lwsl_debug("%s: service on readbuf ah\n", __func__);
pt = &wsi->context->pt[(int)wsi->tsi];
/*
* Unlike a normal connect, we have the headers already
* (or the first part of them anyway)
*/
pfd = &pt->fds[wsi->position_in_fds_table];
pfd->revents |= LWS_POLLIN;
lwsl_err("%s: calling service\n", __func__);
lws_service_fd_tsi(wsi->context, pfd, wsi->tsi);
adopt variant with preamble rx Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-24 11:05:56 +08:00
}
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
}
smp: fixes
2018-03-02 14:22:49 +08:00
void
lws_header_table_reset(struct lws *wsi, int autoservice)
{
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
lws_pt_lock(pt, __func__);
__lws_header_table_reset(wsi, autoservice);
lws_pt_unlock(pt);
}
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
static void
_lws_header_ensure_we_are_on_waiting_list(struct lws *wsi)
{
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
struct lws_pollargs pa;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
struct lws **pwsi = &pt->http.ah_wait_list;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
while (*pwsi) {
if (*pwsi == wsi)
return;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
pwsi = &(*pwsi)->http.ah_wait_list;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
}
lwsl_info("%s: wsi: %p\n", __func__, wsi);
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah_wait_list = pt->http.ah_wait_list;
pt->http.ah_wait_list = wsi;
pt->http.ah_wait_list_length++;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
/* we cannot accept input then */
_lws_change_pollfd(wsi, LWS_POLLIN, 0, &pa);
}
static int
__lws_remove_from_ah_waiting_list(struct lws *wsi)
{
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
struct lws **pwsi =&pt->http.ah_wait_list;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
while (*pwsi) {
if (*pwsi == wsi) {
lwsl_info("%s: wsi %p\n", __func__, wsi);
/* point prev guy to our next */
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
*pwsi = wsi->http.ah_wait_list;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
/* we shouldn't point anywhere now */
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah_wait_list = NULL;
pt->http.ah_wait_list_length--;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
return 1;
}
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
pwsi = &(*pwsi)->http.ah_wait_list;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
}
return 0;
}
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
int LWS_WARN_UNUSED_RESULT
adopt readbuf do service Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-27 11:42:22 +08:00
lws_header_table_attach(struct lws *wsi, int autoservice)
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
{
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
struct lws_context *context = wsi->context;
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
struct lws_pollargs pa;
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
int n;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
lwsl_info("%s: wsi %p: ah %p (tsi %d, count = %d) in\n", __func__,
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
(void *)wsi, (void *)wsi->http.ah, wsi->tsi,
pt->http.ah_count_in_use);
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
lws_pt_lock(pt, __func__);
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
/* if we are already bound to one, just clear it down */
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (wsi->http.ah) {
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
lwsl_info("%s: cleardown\n", __func__);
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
goto reset;
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
}
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
n = pt->http.ah_count_in_use == context->max_http_header_pool;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
#if defined(LWS_WITH_PEER_LIMITS)
if (!n) {
n = lws_peer_confirm_ah_attach_ok(context, wsi->peer);
if (n)
lws_stats_atomic_bump(wsi->context, pt,
LWSSTATS_C_PEER_LIMIT_AH_DENIED, 1);
}
#endif
if (n) {
/*
* Pool is either all busy, or we don't want to give this
* particular guy an ah right now...
*
* Make sure we are on the waiting list, and return that we
* weren't able to provide the ah
*/
_lws_header_ensure_we_are_on_waiting_list(wsi);
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
goto bail;
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
}
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
__lws_remove_from_ah_waiting_list(wsi);
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah = _lws_create_ah(pt, context->max_http_header_data);
if (!wsi->http.ah) { /* we could not create an ah */
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
_lws_header_ensure_we_are_on_waiting_list(wsi);
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
goto bail;
}
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->in_use = 1;
wsi->http.ah->wsi = wsi; /* mark our owner */
pt->http.ah_count_in_use++;
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
#if defined(LWS_WITH_PEER_LIMITS) && (defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2))
lws_context_lock(context); /* <====================================== */
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
if (wsi->peer)
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->peer->http.count_ah++;
lws_context_unlock(context); /* ====================================> */
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
#endif
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
_lws_change_pollfd(wsi, 0, LWS_POLLIN, &pa);
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
esp32: group tracking
2017-05-16 19:35:55 +08:00
lwsl_info("%s: did attach wsi %p: ah %p: count %d (on exit)\n", __func__,
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
(void *)wsi, (void *)wsi->http.ah, pt->http.ah_count_in_use);
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
reset:
smp: fixes
2018-03-02 14:22:49 +08:00
__lws_header_table_reset(wsi, autoservice);
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
lws_pt_unlock(pt);
client accept connection request even if no free ah It can join the free ah list and pick up client connect processing later when the ah becomes available; this simplifies the code doing the request since he won't have to deal with unexpected failures / retries based on dynamic ah availability. To do this though we have to handle that the connect_info members may not have scope that lets them still exist after we return from the first connect call, we stash them in a malloc'd buffer so the connect processing can have them much later even so. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-29 14:19:16 +08:00
#ifndef LWS_NO_CLIENT
refactor mode and states into roles and states
2018-04-02 11:55:17 +08:00
if (lwsi_role_client(wsi) && lwsi_state(wsi) == LRS_UNCONNECTED)
client handle connection fail at second phase properly Signed-off-by: Andy Green <andy@warmcat.com>
2016-05-08 16:58:18 +08:00
if (!lws_client_connect_via_info2(wsi))
/* our client connect has failed, the wsi
* has been closed
*/
return -1;
client accept connection request even if no free ah It can join the free ah list and pick up client connect processing later when the ah becomes available; this simplifies the code doing the request since he won't have to deal with unexpected failures / retries based on dynamic ah availability. To do this though we have to handle that the connect_info members may not have scope that lets them still exist after we return from the first connect call, we stash them in a malloc'd buffer so the connect processing can have them much later even so. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-29 14:19:16 +08:00
#endif
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
return 0;
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
bail:
lws_pt_unlock(pt);
return 1;
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
}
pthreads: more locking
2018-03-05 16:49:28 +08:00
int __lws_header_table_detach(struct lws *wsi, int autoservice)
Adding header table free function to make sure we free cleanly everywhere.
2014-11-07 11:20:59 +08:00
{
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
struct lws_context *context = wsi->context;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
struct allocated_headers *ah = wsi->http.ah;
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
struct lws_pollargs pa;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
struct lws **pwsi, **pwsi_eligible;
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
time_t now;
ah: enforce waiting list detach
2017-07-19 04:06:15 +08:00
__lws_remove_from_ah_waiting_list(wsi);
ah: require parsing complete before detach Introduce helpers to force to detachable state and to test the ah is in a detachable state. Require not only the ah rx buffer is all used, but that the wsi has completed a full set of headers.
2017-06-28 12:13:13 +08:00
if (!ah)
return 0;
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
lwsl_info("%s: wsi %p: ah %p (tsi=%d, count = %d)\n", __func__,
ah detach: don't print held time if actually detached Confusingly an ah held time was printed for a previously detached ah. Clear down the time field when detaching the ah so this can't happen any more.
2016-07-19 09:38:48 +08:00
(void *)wsi, (void *)ah, wsi->tsi,
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
pt->http.ah_count_in_use);
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
improve timeout and ah list comments Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-25 21:39:01 +08:00
/* we did have an ah attached */
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
time(&now);
ah detach: don't print held time if actually detached Confusingly an ah held time was printed for a previously detached ah. Clear down the time field when detaching the ah so this can't happen any more.
2016-07-19 09:38:48 +08:00
if (ah->assigned && now - ah->assigned > 3) {
ah pool lifetime use dynamic rxpos Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-19 11:47:52 +08:00
/*
* we're detaching the ah, but it was held an
* unreasonably long time
*/
refactor: absorb other caches into buflist 1) Remove the whole ah rxbuf and put things on to the wsi buflist This eliminates the whole detachability thing based on ah rxbuf state... ah can always be detached. 2) Remove h2 scratch and put it on the wsi buflist 3) Remove preamble_rx and use the wsi buflist This was used in the case adopted sockets had already been read. Basically there are now only three forced service scenarios - something in buflist (and not in state LRS_DEFERRING_ACTION) - tls layer has buffered rx - extension has buffered rx This is a net removal of around 400 lines of special-casing.
2018-04-17 15:35:15 +08:00
lwsl_debug("%s: wsi %p: ah held %ds, role/state 0x%x 0x%x,"
smp: h2 children must go on same tsi as parent We can't have a situation where stream wsis inside an h2 connection are serviced by different threads than the actual parent connection.
2018-04-27 12:49:42 +08:00
"\n", __func__, wsi, (int)(now - ah->assigned),
refactor: absorb other caches into buflist 1) Remove the whole ah rxbuf and put things on to the wsi buflist This eliminates the whole detachability thing based on ah rxbuf state... ah can always be detached. 2) Remove h2 scratch and put it on the wsi buflist 3) Remove preamble_rx and use the wsi buflist This was used in the case adopted sockets had already been read. Basically there are now only three forced service scenarios - something in buflist (and not in state LRS_DEFERRING_ACTION) - tls layer has buffered rx - extension has buffered rx This is a net removal of around 400 lines of special-casing.
2018-04-17 15:35:15 +08:00
lwsi_role(wsi), lwsi_state(wsi));
ah pool lifetime use dynamic rxpos Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-19 11:47:52 +08:00
}
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
ah detach: don't print held time if actually detached Confusingly an ah held time was printed for a previously detached ah. Clear down the time field when detaching the ah so this can't happen any more.
2016-07-19 09:38:48 +08:00
ah->assigned = 0;
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
/* if we think we're detaching one, there should be one in use */
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
assert(pt->http.ah_count_in_use > 0);
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
/* and this specific one should have been in use */
ah detach: don't print held time if actually detached Confusingly an ah held time was printed for a previously detached ah. Clear down the time field when detaching the ah so this can't happen any more.
2016-07-19 09:38:48 +08:00
assert(ah->in_use);
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
memset(&wsi->http.ah, 0, sizeof(wsi->http.ah));
smp: h2 children must go on same tsi as parent We can't have a situation where stream wsis inside an h2 connection are serviced by different threads than the actual parent connection.
2018-04-27 12:49:42 +08:00
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
#if defined(LWS_WITH_PEER_LIMITS)
smp: h2 children must go on same tsi as parent We can't have a situation where stream wsis inside an h2 connection are serviced by different threads than the actual parent connection.
2018-04-27 12:49:42 +08:00
if (ah->wsi)
lws_peer_track_ah_detach(context, wsi->peer);
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
#endif
smp: h2 children must go on same tsi as parent We can't have a situation where stream wsis inside an h2 connection are serviced by different threads than the actual parent connection.
2018-04-27 12:49:42 +08:00
ah->wsi = NULL; /* no owner */
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
pwsi = &pt->http.ah_wait_list;
ah: enforce waiting list detach
2017-07-19 04:06:15 +08:00
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
/* oh there is nobody on the waiting list... leave the ah unattached */
if (!*pwsi)
goto nobody_usable_waiting;
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
/*
* at least one wsi on the same tsi is waiting, give it to oldest guy
* who is allowed to take it (if any)
*/
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
lwsl_info("pt wait list %p\n", *pwsi);
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
wsi = NULL;
pwsi_eligible = NULL;
while (*pwsi) {
#if defined(LWS_WITH_PEER_LIMITS)
/* are we willing to give this guy an ah? */
if (!lws_peer_confirm_ah_attach_ok(context, (*pwsi)->peer))
#endif
{
wsi = *pwsi;
pwsi_eligible = pwsi;
}
#if defined(LWS_WITH_PEER_LIMITS)
else
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (!(*pwsi)->http.ah_wait_list)
coverity fixes
2017-09-23 13:27:11 +08:00
lws_stats_atomic_bump(context, pt,
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
LWSSTATS_C_PEER_LIMIT_AH_DENIED, 1);
#endif
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
pwsi = &(*pwsi)->http.ah_wait_list;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
}
if (!wsi) /* everybody waiting already has too many ah... */
goto nobody_usable_waiting;
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
lwsl_info("%s: last eligible wsi in wait list %p\n", __func__, wsi);
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah = ah;
ah owns rxbuf This is intended to solve a longstanding problem with the relationship between http/1.1 keep-alive and the service loop. Ah now contain an rx buffer which is used during header processing, and the ah may not be detached from the wsi until the rx buffer is exhausted. Having the rx buffer in the ah means we can delay using the rx until a later service loop. Ah which have pending rx force POLLIN service on the wsi they are attached to automatically, so we can interleave general service / connections with draining each ah rx buffer. The possible http/1.1 situations and their dispositions are: 1) exactly one set of http headers come. After processing, the ah is detached since no pending rx left. If more headers come later, a fresh ah is aqcuired when available and the rx flow control blocks the read until then. 2) more that one whole set of headers come and we remain in http mode (no upgrade). The ah is left attached and returns to the service loop after the first set of headers. We will get forced service due to the ah having pending content (respecting flowcontrol) and process the pending rx in the ah. If we use it all up, we will detach the ah. 3) one set of http headers come with ws traffic appended. We service the headers, do the upgrade, and keep the ah until the remaining ws content is used. When we exhausted the ws traffix in the ah rx buffer, we detach the ah. Since there can be any amount of http/1.1 pipelining on a connection, and each may be expensive to service, it's now enforced there is a return to the service loop after each header set is serviced on a connection. When I added the forced service for ah with pending buffering, I added support for it to the windows plat code. However this is untested. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-15 12:37:04 +08:00
ah->wsi = wsi; /* new owner */
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
smp: fixes
2018-03-02 14:22:49 +08:00
__lws_header_table_reset(wsi, autoservice);
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
#if defined(LWS_WITH_PEER_LIMITS) && (defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2))
smp: h2 children must go on same tsi as parent We can't have a situation where stream wsis inside an h2 connection are serviced by different threads than the actual parent connection.
2018-04-27 12:49:42 +08:00
lws_context_lock(context); /* <====================================== */
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
if (wsi->peer)
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->peer->http.count_ah++;
smp: h2 children must go on same tsi as parent We can't have a situation where stream wsis inside an h2 connection are serviced by different threads than the actual parent connection.
2018-04-27 12:49:42 +08:00
lws_context_unlock(context); /* ====================================> */
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
#endif
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
client fixups after esp8266
2016-08-07 08:33:08 +08:00
/* clients acquire the ah and then insert themselves in fds table... */
if (wsi->position_in_fds_table != -1) {
lwsl_info("%s: Enabling %p POLLIN\n", __func__, wsi);
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
/* he has been stuck waiting for an ah, but now his wait is
* over, let him progress */
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
client fixups after esp8266
2016-08-07 08:33:08 +08:00
_lws_change_pollfd(wsi, 0, LWS_POLLIN, &pa);
}
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
/* point prev guy to next guy in list instead */
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
*pwsi_eligible = wsi->http.ah_wait_list;
improve timeout and ah list comments Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-25 21:39:01 +08:00
/* the guy who got one is out of the list */
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah_wait_list = NULL;
pt->http.ah_wait_list_length--;
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
client accept connection request even if no free ah It can join the free ah list and pick up client connect processing later when the ah becomes available; this simplifies the code doing the request since he won't have to deal with unexpected failures / retries based on dynamic ah availability. To do this though we have to handle that the connect_info members may not have scope that lets them still exist after we return from the first connect call, we stash them in a malloc'd buffer so the connect processing can have them much later even so. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-29 14:19:16 +08:00
#ifndef LWS_NO_CLIENT
refactor mode and states into roles and states
2018-04-02 11:55:17 +08:00
if (lwsi_role_client(wsi) && lwsi_state(wsi) == LRS_UNCONNECTED) {
HTTP_PROXY: make usable
2017-06-12 13:36:24 +08:00
lws_pt_unlock(pt);
client handle connection fail at second phase properly Signed-off-by: Andy Green <andy@warmcat.com>
2016-05-08 16:58:18 +08:00
if (!lws_client_connect_via_info2(wsi)) {
/* our client connect has failed, the wsi
* has been closed
*/
return -1;
}
HTTP_PROXY: make usable
2017-06-12 13:36:24 +08:00
return 0;
}
client accept connection request even if no free ah It can join the free ah list and pick up client connect processing later when the ah becomes available; this simplifies the code doing the request since he won't have to deal with unexpected failures / retries based on dynamic ah availability. To do this though we have to handle that the connect_info members may not have scope that lets them still exist after we return from the first connect call, we stash them in a malloc'd buffer so the connect processing can have them much later even so. Signed-off-by: Andy Green <andy.green@linaro.org>
2016-02-29 14:19:16 +08:00
#endif
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
assert(!!pt->http.ah_wait_list_length == !!(lws_intptr_t)pt->http.ah_wait_list);
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
bail:
esp8266 initial support
2016-07-23 14:18:25 +08:00
lwsl_info("%s: wsi %p: ah %p (tsi=%d, count = %d)\n", __func__,
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
(void *)wsi, (void *)ah, pt->tid, pt->http.ah_count_in_use);
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
Subject: [PATCH] Use custom allocator Signed-off-by: Alejandro Mery <amery@geeks.cl>
2014-12-04 23:59:35 +01:00
return 0;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
nobody_usable_waiting:
lwsl_info("%s: nobody usable waiting\n", __func__);
ah pool: change to dynamic linked list For some targets like ESP32, the ah pool is mainly sitting idle wasting memory. For HTTP/2, if the client sends a series of pipelined headers on different SIDs that exist simultaneously, there is no way to stall the headers to wait for an ah, because we must read the stream for stuff like WINDOW_UPDATE on the other streams. In both these cases having the ability to free unused ah completely and allocate more dynamically if there is memory is useful, so this patch makes the ah pool an initially-empty linked list that allocates on demand up to the "max pool size" limit from the context info. When nobody wants an ah, it is freed (if someone was waiting for it, it is directly reused). For ESP32 it means no large, permanent alloc when lws starts and dynamic alloc according to how many streams the client opens, which can be controlled by SETTINGS.
2017-10-06 16:07:57 +08:00
_lws_destroy_ah(pt, ah);
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
pt->http.ah_count_in_use--;
LWS_WITH_PEER_LIMITS Introduces an optional, settable restriction on the number of simultaneous wsi connections and ah that a single peer IP can obtain. The default is disabled for build, and if enabled, unlimited. However when enabled at CMake, setting info.ip_limit_ah and / or info.ip_limit_wsi at context creation time will enforce the limits. Connections past the info.ip_limit_wsi limit are dropped, and connections needing an ah are forced to stay in the ah waiting list even when ah are available, while the peer is at the number of ah in info.ip_limit_ah.
2017-09-14 13:14:11 +08:00
goto bail;
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
}
Adding header table free function to make sure we free cleanly everywhere.
2014-11-07 11:20:59 +08:00
pthreads: more locking
2018-03-05 16:49:28 +08:00
int lws_header_table_detach(struct lws *wsi, int autoservice)
{
struct lws_context *context = wsi->context;
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
int n;
lws_pt_lock(pt, __func__);
n = __lws_header_table_detach(wsi, autoservice);
lws_pt_unlock(pt);
return n;
}
uridecoding lws_hdr_fragment_length Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-19 07:35:23 +08:00
LWS_VISIBLE int
lws_hdr_fragment_length(struct lws *wsi, enum lws_token_indexes h, int frag_idx)
{
int n;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (!wsi->http.ah)
lws-meta
2017-07-19 04:39:14 +08:00
return 0;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
n = wsi->http.ah->frag_index[h];
uridecoding lws_hdr_fragment_length Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-19 07:35:23 +08:00
if (!n)
return 0;
do {
if (!frag_idx)
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
return wsi->http.ah->frags[n].len;
n = wsi->http.ah->frags[n].nfrag;
uridecoding lws_hdr_fragment_length Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-19 07:35:23 +08:00
} while (frag_idx-- && n);
return 0;
}
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_VISIBLE int lws_hdr_total_length(struct lws *wsi, enum lws_token_indexes h)
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
{
int n;
int len = 0;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (!wsi->http.ah)
lws-meta
2017-07-19 04:39:14 +08:00
return 0;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
n = wsi->http.ah->frag_index[h];
refactor out most NO_EXTENSIONS Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-02 19:45:42 +08:00
if (!n)
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
return 0;
do {
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
len += wsi->http.ah->frags[n].len;
n = wsi->http.ah->frags[n].nfrag;
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
} while (n);
return len;
}
introduce lws_hdr_copy_fragment This adds a public API variant of the header copy api that lets you choose which fragment you want copied. Normally you want the existing one that aggregates the fragments. But it can be useful to get each part in turn (that corresponds to the content provided by each duplicated header normally). Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 22:59:23 +08:00
LWS_VISIBLE int lws_hdr_copy_fragment(struct lws *wsi, char *dst, int len,
enum lws_token_indexes h, int frag_idx)
{
int n = 0;
lws-meta
2017-07-19 04:39:14 +08:00
int f;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (!wsi->http.ah)
lws-meta
2017-07-19 04:39:14 +08:00
return -1;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
f = wsi->http.ah->frag_index[h];
introduce lws_hdr_copy_fragment This adds a public API variant of the header copy api that lets you choose which fragment you want copied. Normally you want the existing one that aggregates the fragments. But it can be useful to get each part in turn (that corresponds to the content provided by each duplicated header normally). Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 22:59:23 +08:00
header fragment reject empty early Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-20 09:44:04 +08:00
if (!f)
return -1;
introduce lws_hdr_copy_fragment This adds a public API variant of the header copy api that lets you choose which fragment you want copied. Normally you want the existing one that aggregates the fragments. But it can be useful to get each part in turn (that corresponds to the content provided by each duplicated header normally). Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 22:59:23 +08:00
while (n < frag_idx) {
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
f = wsi->http.ah->frags[f].nfrag;
introduce lws_hdr_copy_fragment This adds a public API variant of the header copy api that lets you choose which fragment you want copied. Normally you want the existing one that aggregates the fragments. But it can be useful to get each part in turn (that corresponds to the content provided by each duplicated header normally). Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 22:59:23 +08:00
if (!f)
return -1;
n++;
}
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (wsi->http.ah->frags[f].len >= len)
introduce lws_hdr_copy_fragment This adds a public API variant of the header copy api that lets you choose which fragment you want copied. Normally you want the existing one that aggregates the fragments. But it can be useful to get each part in turn (that corresponds to the content provided by each duplicated header normally). Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 22:59:23 +08:00
return -1;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
memcpy(dst, wsi->http.ah->data + wsi->http.ah->frags[f].offset,
wsi->http.ah->frags[f].len);
dst[wsi->http.ah->frags[f].len] = '\0';
introduce lws_hdr_copy_fragment This adds a public API variant of the header copy api that lets you choose which fragment you want copied. Normally you want the existing one that aggregates the fragments. But it can be useful to get each part in turn (that corresponds to the content provided by each duplicated header normally). Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 22:59:23 +08:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
return wsi->http.ah->frags[f].len;
introduce lws_hdr_copy_fragment This adds a public API variant of the header copy api that lets you choose which fragment you want copied. Normally you want the existing one that aggregates the fragments. But it can be useful to get each part in turn (that corresponds to the content provided by each duplicated header normally). Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 22:59:23 +08:00
}
refactor needless context with wsi paramater passing Now we bit the bullet and gave each wsi an lws_context *, many internal apis that take both a context and wsi parameter only need the wsi. Also simplify parser code by making a temp var for allocated_headers * instead of the longwinded dereference chain everywhere. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 21:15:58 +08:00
LWS_VISIBLE int lws_hdr_copy(struct lws *wsi, char *dst, int len,
clean tidy the worst whitespace alignment probs due to mass token name length changes Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-04 11:30:53 +08:00
enum lws_token_indexes h)
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
{
int toklen = lws_hdr_total_length(wsi, h);
int n;
if (toklen >= len)
return -1;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (!wsi->http.ah)
lws-meta
2017-07-19 04:39:14 +08:00
return -1;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
n = wsi->http.ah->frag_index[h];
refactor out most NO_EXTENSIONS Signed-off-by: Andy Green <andy.green@linaro.org>
2014-04-02 19:45:42 +08:00
if (!n)
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
return 0;
do {
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (wsi->http.ah->frags[n].len >= len)
lws_hdr_copy: protect against garbage
2017-11-02 08:10:41 +08:00
return -1;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
strncpy(dst, &wsi->http.ah->data[wsi->http.ah->frags[n].offset],
wsi->http.ah->frags[n].len);
dst += wsi->http.ah->frags[n].len;
len -= wsi->http.ah->frags[n].len;
n = wsi->http.ah->frags[n].nfrag;
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
} while (n);
lws_hdr_copy: protect against garbage
2017-11-02 08:10:41 +08:00
*dst = '\0';
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
return toklen;
}
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
char *lws_hdr_simple_ptr(struct lws *wsi, enum lws_token_indexes h)
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
{
int n;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
n = wsi->http.ah->frag_index[h];
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
if (!n)
return NULL;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
return wsi->http.ah->data + wsi->http.ah->frags[n].offset;
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
}
add lexical parser for headers Profiling what happens during the ab test, one of the hotspots was strcasecmp in a loop looking for header name matches each time. This patch introduces a lexical parser that creates a state machine in 276 bytes that encodes all the known header names. The fsm is walked bytewise as chaacters come in... most states do not need any recursion to match or fail. The state machine output is cut-and-pasted into parsers.c as an unsigned char array. The fsm generator is a bit rough and ready, included in the tree but not built since normal mortals won't need to touch it. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-18 01:55:48 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
static int LWS_WARN_UNUSED_RESULT
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
lws_pos_in_bounds(struct lws *wsi)
{
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (wsi->http.ah->pos <
clean
2017-09-23 12:55:21 +08:00
(unsigned int)wsi->context->max_http_header_data)
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
return 0;
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if ((int)wsi->http.ah->pos == wsi->context->max_http_header_data) {
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
lwsl_err("Ran out of header data space\n");
return 1;
}
/*
* with these tests everywhere, it should never be able to exceed
clean
2017-09-23 12:55:21 +08:00
* the limit, only meet it
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
*/
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
lwsl_err("%s: pos %d, limit %d\n", __func__, wsi->http.ah->pos,
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
wsi->context->max_http_header_data);
assert(0);
return 1;
}
int LWS_WARN_UNUSED_RESULT
lws_hdr_simple_create(struct lws *wsi, enum lws_token_indexes h, const char *s)
client convert to new headers scheme eliminating mallocs This removes all the direct wsi members specific to clients, most of them are moved to being fake headers in the next 3-layer header scheme, c_port moves to being a member of the u.hdr unionized struct. It gets rid of a lot of fiddly mallocs and frees(), despite it adds a small internal API to create the fake headers, actually the patch deletes more than it adds... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 13:04:45 +08:00
{
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->nfrag++;
if (wsi->http.ah->nfrag == ARRAY_SIZE(wsi->http.ah->frags)) {
style cleanup This brings the library sources into compliance with checkpatch style except for three or four exceptions like WIN32 related stuff and one long string constant I don't want to break into multiple sprintf calls. There should be no functional or compilability change from all this (hopefully). Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 17:13:32 +08:00
lwsl_warn("More hdr frags than we can deal with, dropping\n");
client convert to new headers scheme eliminating mallocs This removes all the direct wsi members specific to clients, most of them are moved to being fake headers in the next 3-layer header scheme, c_port moves to being a member of the u.hdr unionized struct. It gets rid of a lot of fiddly mallocs and frees(), despite it adds a small internal API to create the fake headers, actually the patch deletes more than it adds... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 13:04:45 +08:00
return -1;
}
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->frag_index[h] = wsi->http.ah->nfrag;
client convert to new headers scheme eliminating mallocs This removes all the direct wsi members specific to clients, most of them are moved to being fake headers in the next 3-layer header scheme, c_port moves to being a member of the u.hdr unionized struct. It gets rid of a lot of fiddly mallocs and frees(), despite it adds a small internal API to create the fake headers, actually the patch deletes more than it adds... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 13:04:45 +08:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->frags[wsi->http.ah->nfrag].offset = wsi->http.ah->pos;
wsi->http.ah->frags[wsi->http.ah->nfrag].len = 0;
wsi->http.ah->frags[wsi->http.ah->nfrag].nfrag = 0;
client convert to new headers scheme eliminating mallocs This removes all the direct wsi members specific to clients, most of them are moved to being fake headers in the next 3-layer header scheme, c_port moves to being a member of the u.hdr unionized struct. It gets rid of a lot of fiddly mallocs and frees(), despite it adds a small internal API to create the fake headers, actually the patch deletes more than it adds... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 13:04:45 +08:00
do {
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
if (lws_pos_in_bounds(wsi))
client convert to new headers scheme eliminating mallocs This removes all the direct wsi members specific to clients, most of them are moved to being fake headers in the next 3-layer header scheme, c_port moves to being a member of the u.hdr unionized struct. It gets rid of a lot of fiddly mallocs and frees(), despite it adds a small internal API to create the fake headers, actually the patch deletes more than it adds... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 13:04:45 +08:00
return -1;
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->data[wsi->http.ah->pos++] = *s;
client convert to new headers scheme eliminating mallocs This removes all the direct wsi members specific to clients, most of them are moved to being fake headers in the next 3-layer header scheme, c_port moves to being a member of the u.hdr unionized struct. It gets rid of a lot of fiddly mallocs and frees(), despite it adds a small internal API to create the fake headers, actually the patch deletes more than it adds... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 13:04:45 +08:00
if (*s)
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->frags[wsi->http.ah->nfrag].len++;
client convert to new headers scheme eliminating mallocs This removes all the direct wsi members specific to clients, most of them are moved to being fake headers in the next 3-layer header scheme, c_port moves to being a member of the u.hdr unionized struct. It gets rid of a lot of fiddly mallocs and frees(), despite it adds a small internal API to create the fake headers, actually the patch deletes more than it adds... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 13:04:45 +08:00
} while (*s++);
return 0;
}
introduce LWS_WARN_UNUSED_RESULT Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-20 16:56:06 +08:00
static int LWS_WARN_UNUSED_RESULT
issue_char(struct lws *wsi, unsigned char c)
translate and protect uri test sever use uri path This translates %xx in the GET uri and removes /.. and /... type sequences along with translating // or /// etc to /. Since the result is hopefully secure, it also changes the test server to actually use the uri path pasted on a resource directory without whitelisting. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-11-10 15:15:21 +08:00
{
C89 tweaks as per #348.
2015-11-29 19:26:01 +08:00
unsigned short frag_len;
refactor needless context with wsi paramater passing Now we bit the bullet and gave each wsi an lws_context *, many internal apis that take both a context and wsi parameter only need the wsi. Also simplify parser code by making a temp var for allocated_headers * instead of the longwinded dereference chain everywhere. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 21:15:58 +08:00
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
if (lws_pos_in_bounds(wsi))
translate and protect uri test sever use uri path This translates %xx in the GET uri and removes /.. and /... type sequences along with translating // or /// etc to /. Since the result is hopefully secure, it also changes the test server to actually use the uri path pasted on a resource directory without whitelisting. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-11-10 15:15:21 +08:00
return -1;
Added optional per-header length limits: - libwebsockets.h: - * added struct lws_token_limits * added token limits pointer to lws_context_creation_info - private-libwebsockets.h: added token limits pointer to lws_context_creation_info - context.c: copy token limits in create_context - client.c / server.c: pass context when invoking libwebsocket_parse - parsers.c: - * libwebsocket_parse takes context pointer * issue_char takes context pointer and checks header length against context limits, if defined * issue_char returns 1 (not -1/0) for header too long, and spill: sets the state to WSI_TOKEN_SKIPPING
2014-06-29 00:25:19 -04:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
frag_len = wsi->http.ah->frags[wsi->http.ah->nfrag].len;
refactor needless context with wsi paramater passing Now we bit the bullet and gave each wsi an lws_context *, many internal apis that take both a context and wsi parameter only need the wsi. Also simplify parser code by making a temp var for allocated_headers * instead of the longwinded dereference chain everywhere. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 21:15:58 +08:00
/*
* If we haven't hit the token limit, just copy the character into
* the header
*/
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (frag_len < wsi->http.ah->current_token_limit) {
wsi->http.ah->data[wsi->http.ah->pos++] = c;
Terminate truncated header strings.
2015-11-29 19:24:04 +08:00
if (c)
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->frags[wsi->http.ah->nfrag].len++;
Terminate truncated header strings.
2015-11-29 19:24:04 +08:00
return 0;
}
refactor needless context with wsi paramater passing Now we bit the bullet and gave each wsi an lws_context *, many internal apis that take both a context and wsi parameter only need the wsi. Also simplify parser code by making a temp var for allocated_headers * instead of the longwinded dereference chain everywhere. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 21:15:58 +08:00
/* Insert a null character when we *hit* the limit: */
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
if (frag_len == wsi->http.ah->current_token_limit) {
unify bounds checking in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-21 10:57:39 +08:00
if (lws_pos_in_bounds(wsi))
parser issue_char audit Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-20 07:40:13 +08:00
return -1;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->data[wsi->http.ah->pos++] = '\0';
http header malloc pool implement pool Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-25 12:44:12 +08:00
lwsl_warn("header %i exceeds limit %d\n",
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
wsi->http.ah->parser_state,
wsi->http.ah->current_token_limit);
refactor needless context with wsi paramater passing Now we bit the bullet and gave each wsi an lws_context *, many internal apis that take both a context and wsi parameter only need the wsi. Also simplify parser code by making a temp var for allocated_headers * instead of the longwinded dereference chain everywhere. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 21:15:58 +08:00
}
Terminate truncated header strings.
2015-11-29 19:24:04 +08:00
return 1;
translate and protect uri test sever use uri path This translates %xx in the GET uri and removes /.. and /... type sequences along with translating // or /// etc to /. Since the result is hopefully secure, it also changes the test server to actually use the uri path pasted on a resource directory without whitelisting. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-11-10 15:15:21 +08:00
}
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
int
lws_parse_urldecode(struct lws *wsi, uint8_t *_c)
{
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
struct allocated_headers *ah = wsi->http.ah;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
unsigned int enc = 0;
uint8_t c = *_c;
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
// lwsl_notice("ah->ups %d\n", ah->ups);
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
/*
* PRIORITY 1
* special URI processing... convert %xx
*/
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
switch (ah->ues) {
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
case URIES_IDLE:
if (c == '%') {
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ues = URIES_SEEN_PERCENT;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
goto swallow;
}
break;
case URIES_SEEN_PERCENT:
if (char_to_hex(c) < 0)
/* illegal post-% char */
goto forbid;
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->esc_stash = c;
ah->ues = URIES_SEEN_PERCENT_H1;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
goto swallow;
case URIES_SEEN_PERCENT_H1:
if (char_to_hex(c) < 0)
/* illegal post-% char */
goto forbid;
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
*_c = (char_to_hex(ah->esc_stash) << 4) |
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
char_to_hex(c);
c = *_c;
enc = 1;
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ues = URIES_IDLE;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
break;
}
/*
* PRIORITY 2
* special URI processing...
* convert /.. or /... or /../ etc to /
* convert /./ to /
* convert // or /// etc to /
* leave /.dir or whatever alone
*/
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
switch (ah->ups) {
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
case URIPS_IDLE:
if (!c)
return -1;
/* genuine delimiter */
if ((c == '&' || c == ';') && !enc) {
if (issue_char(wsi, c) < 0)
return -1;
/* swallow the terminator */
ah->frags[ah->nfrag].len--;
/* link to next fragment */
ah->frags[ah->nfrag].nfrag = ah->nfrag + 1;
ah->nfrag++;
if (ah->nfrag >= ARRAY_SIZE(ah->frags))
goto excessive;
/* start next fragment after the & */
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->post_literal_equal = 0;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
ah->frags[ah->nfrag].offset = ah->pos;
ah->frags[ah->nfrag].len = 0;
ah->frags[ah->nfrag].nfrag = 0;
goto swallow;
}
/* uriencoded = in the name part, disallow */
if (c == '=' && enc &&
ah->frag_index[WSI_TOKEN_HTTP_URI_ARGS] &&
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
!ah->post_literal_equal) {
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
c = '_';
*_c =c;
}
/* after the real =, we don't care how many = */
if (c == '=' && !enc)
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->post_literal_equal = 1;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
/* + to space */
if (c == '+' && !enc) {
c = ' ';
*_c = c;
}
/* issue the first / always */
if (c == '/' && !ah->frag_index[WSI_TOKEN_HTTP_URI_ARGS])
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_SEEN_SLASH;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
break;
case URIPS_SEEN_SLASH:
/* swallow subsequent slashes */
if (c == '/')
goto swallow;
/* track and swallow the first . after / */
if (c == '.') {
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_SEEN_SLASH_DOT;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
goto swallow;
}
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_IDLE;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
break;
case URIPS_SEEN_SLASH_DOT:
/* swallow second . */
if (c == '.') {
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_SEEN_SLASH_DOT_DOT;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
goto swallow;
}
/* change /./ to / */
if (c == '/') {
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_SEEN_SLASH;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
goto swallow;
}
/* it was like /.dir ... regurgitate the . */
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_IDLE;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
if (issue_char(wsi, '.') < 0)
return -1;
break;
case URIPS_SEEN_SLASH_DOT_DOT:
/* /../ or /..[End of URI] --> backup to last / */
if (c == '/' || c == '?') {
/*
* back up one dir level if possible
* safe against header fragmentation because
* the method URI can only be in 1 fragment
*/
if (ah->frags[ah->nfrag].len > 2) {
ah->pos--;
ah->frags[ah->nfrag].len--;
do {
ah->pos--;
ah->frags[ah->nfrag].len--;
} while (ah->frags[ah->nfrag].len > 1 &&
ah->data[ah->pos] != '/');
}
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_SEEN_SLASH;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
if (ah->frags[ah->nfrag].len > 1)
break;
goto swallow;
}
/* /..[^/] ... regurgitate and allow */
if (issue_char(wsi, '.') < 0)
return -1;
if (issue_char(wsi, '.') < 0)
return -1;
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_IDLE;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
break;
}
if (c == '?' && !enc &&
refactor-eliminate-lws-union The union used to make a lot of sense to save space between mutually exclusive modes. But the fact the http2 struct contains the http1 struct as well as it appearing in the union means the http1 struct belongs outside the union. This patch - eliminates the union - puts the http_related struct directly in struct lws - removes http_related from h2 - puts h2 directly in struct lws if enabled for build - changes ws to be a pointer, allocated if we upgrade to ws (the ws part contains a 135 byte char array for ping / close) Again all of this is entirely private / internal and doesn't affect any apis.
2017-12-01 11:09:32 +08:00
!ah->frag_index[WSI_TOKEN_HTTP_URI_ARGS]) { /* start of URI args */
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
if (ah->ues != URIES_IDLE)
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
goto forbid;
/* seal off uri header */
if (issue_char(wsi, '\0') < 0)
return -1;
/* move to using WSI_TOKEN_HTTP_URI_ARGS */
ah->nfrag++;
if (ah->nfrag >= ARRAY_SIZE(ah->frags))
goto excessive;
ah->frags[ah->nfrag].offset = ah->pos;
ah->frags[ah->nfrag].len = 0;
ah->frags[ah->nfrag].nfrag = 0;
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->post_literal_equal = 0;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
ah->frag_index[WSI_TOKEN_HTTP_URI_ARGS] = ah->nfrag;
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->ups = URIPS_IDLE;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
goto swallow;
}
return LPUR_CONTINUE;
swallow:
return LPUR_SWALLOW;
forbid:
return LPUR_FORBID;
excessive:
return LPUR_EXCESSIVE;
}
static const unsigned char methods[] = {
WSI_TOKEN_GET_URI,
WSI_TOKEN_POST_URI,
WSI_TOKEN_OPTIONS_URI,
WSI_TOKEN_PUT_URI,
WSI_TOKEN_PATCH_URI,
WSI_TOKEN_DELETE_URI,
WSI_TOKEN_CONNECT,
WSI_TOKEN_HEAD_URI,
};
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/*
* possible returns:, -1 fail, 0 ok or 2, transition to raw
*/
introduce LWS_WARN_UNUSED_RESULT Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-20 16:56:06 +08:00
int LWS_WARN_UNUSED_RESULT
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
lws_parse(struct lws *wsi, unsigned char *buf, int *len)
break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
{
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
struct allocated_headers *ah = wsi->http.ah;
refactor needless context with wsi paramater passing Now we bit the bullet and gave each wsi an lws_context *, many internal apis that take both a context and wsi parameter only need the wsi. Also simplify parser code by making a temp var for allocated_headers * instead of the longwinded dereference chain everywhere. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 21:15:58 +08:00
struct lws_context *context = wsi->context;
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
unsigned int n, m;
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
unsigned char c;
int r, pos;
break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
refactor: move all ah and http specific vars to http private and conditional inclusion from there
2018-04-27 15:20:56 +08:00
assert(wsi->http.ah);
multithread stability Signed-off-by: Andy Green <andy.green@linaro.org>
2016-01-26 20:56:56 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
do {
(*len)--;
c = *buf++;
introduce x google mux very draft indeed This is initial x-google-mux support. It's disabled by default since it's very pre-alpha. 1) To enable it, reconfigure with --enable-x-google-mux 2) It conflicts with deflate-stream, use the -u switch on the test client to disable deflate-stream 3) It deviates from the google standard by sending full headers in the addchannel subcommand rather than just changed ones from original connect 4) Quota is not implemented yet 5) Close of subchannel is not really implemented yet 6) Google opcode 0xf is changed to 0x7 to account for v7 protocol changes to opcode layout However despite those caveats, in fact it can run the test client reliably over one socket (both dumb-increment and lws-mirror-protocol), you can open a browser on the same test server too and see the circles, etc. Signed-off-by: Andy Green <andy@warmcat.com>
2011-05-23 10:00:03 +01:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
switch (ah->parser_state) {
default:
break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
lwsl_parser("WSI_TOK_(%d) '%c'\n", ah->parser_state, c);
coding-style-cleanups.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-13 10:03:47 +00:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/* collect into malloc'd buffers */
/* optional initial space swallow */
if (!ah->frags[ah->frag_index[ah->parser_state]].len &&
c == ' ')
Add PATCH, PUT, DELETE methods AG: rewrite method code to use method arrays
2015-01-10 19:01:52 -08:00
break;
translate and protect uri test sever use uri path This translates %xx in the GET uri and removes /.. and /... type sequences along with translating // or /// etc to /. Since the result is hopefully secure, it also changes the test server to actually use the uri path pasted on a resource directory without whitelisting. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-11-10 15:15:21 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
for (m = 0; m < ARRAY_SIZE(methods); m++)
if (ah->parser_state == methods[m])
break;
if (m == ARRAY_SIZE(methods))
/* it was not any of the methods */
goto check_eol;
translate and protect uri test sever use uri path This translates %xx in the GET uri and removes /.. and /... type sequences along with translating // or /// etc to /. Since the result is hopefully secure, it also changes the test server to actually use the uri path pasted on a resource directory without whitelisting. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-11-10 15:15:21 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/* special URI processing... end at space */
HTTP Version, Keep-alive support, No-copy POST This is a squashed commit from https://github.com/andrew-canaday/libwebsockets, dev/http_keepalive branch (strategies changed a few times, so the commit history is clutteread). This branch is submitted for clarity, but the other can be used as a reference or alternative. * added **enum http_version** to track HTTP/1.0 vs HTTP/1.1 requests * added **enum http_connection_type** to track keep-alive vs close * replaced content_length_seen and body_index with **content_remain** * removed **post_buffer** (see handshake.c modifications) * removed post_buffer free * switch state to WSI_TOKEN_SKIPPING after URI is complete to store version * delete *spill* label (unused) * add vars to track HTTP version and connection type * HTTP version defaults to 1.0 * connection type defaults to 'close' for 1.0, keep-alive for 1.1 * additional checks in **cleanup:** label: * if HTTP version string is present and valid, set enum val appropriately * override connection default with the "Connection:" header, if present * set state to WSI_STATE_HTTP_BODY if content_length > 0 * return 0 on HTTP requests, unless LWS_CALLBACK_HTTP indicates otherwise * add vars to track remaining content_length and body chunk size * re-arrange switch case order to facilitate creation of jump-table * added new labels: * **read_ok**: normal location reach on break from switch; just return 0 * **http_complete**: check for keep-alive + init state, mode, hdr table * **http_new**: jump location for keep-alive when http_complete sees len>0 * after libwebsocket_parse, jump to one of those labels based on state * POST body handling: * don't bother iterating over input byte-by-byte or using memcpy * just pass the relevant portion of the context->service_buffer to callback
2014-07-13 01:07:36 -04:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (c == ' ') {
/* enforce starting with / */
if (!ah->frags[ah->nfrag].len)
if (issue_char(wsi, '/') < 0)
return -1;
if (ah->ups == URIPS_SEEN_SLASH_DOT_DOT) {
/*
* back up one dir level if possible
* safe against header fragmentation because
* the method URI can only be in 1 fragment
*/
if (ah->frags[ah->nfrag].len > 2) {
urldecode forbid malformed And update attack.sh to confirm the new test cases Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-07 10:08:35 +08:00
ah->pos--;
ah->frags[ah->nfrag].len--;
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
do {
ah->pos--;
ah->frags[ah->nfrag].len--;
} while (ah->frags[ah->nfrag].len > 1 &&
ah->data[ah->pos] != '/');
}
urldecode forbid malformed And update attack.sh to confirm the new test cases Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-07 10:08:35 +08:00
}
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/* begin parsing HTTP version: */
if (issue_char(wsi, '\0') < 0)
return -1;
ah->parser_state = WSI_TOKEN_HTTP;
goto start_fragment;
urldecode forbid malformed And update attack.sh to confirm the new test cases Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-07 10:08:35 +08:00
}
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
r = lws_parse_urldecode(wsi, &c);
switch (r) {
case LPUR_CONTINUE:
break;
case LPUR_SWALLOW:
goto swallow;
case LPUR_FORBID:
goto forbid;
case LPUR_EXCESSIVE:
goto excessive;
default:
HTTP Version, Keep-alive support, No-copy POST This is a squashed commit from https://github.com/andrew-canaday/libwebsockets, dev/http_keepalive branch (strategies changed a few times, so the commit history is clutteread). This branch is submitted for clarity, but the other can be used as a reference or alternative. * added **enum http_version** to track HTTP/1.0 vs HTTP/1.1 requests * added **enum http_connection_type** to track keep-alive vs close * replaced content_length_seen and body_index with **content_remain** * removed **post_buffer** (see handshake.c modifications) * removed post_buffer free * switch state to WSI_TOKEN_SKIPPING after URI is complete to store version * delete *spill* label (unused) * add vars to track HTTP version and connection type * HTTP version defaults to 1.0 * connection type defaults to 'close' for 1.0, keep-alive for 1.1 * additional checks in **cleanup:** label: * if HTTP version string is present and valid, set enum val appropriately * override connection default with the "Connection:" header, if present * set state to WSI_STATE_HTTP_BODY if content_length > 0 * return 0 on HTTP requests, unless LWS_CALLBACK_HTTP indicates otherwise * add vars to track remaining content_length and body chunk size * re-arrange switch case order to facilitate creation of jump-table * added new labels: * **read_ok**: normal location reach on break from switch; just return 0 * **http_complete**: check for keep-alive + init state, mode, hdr table * **http_new**: jump location for keep-alive when http_complete sees len>0 * after libwebsocket_parse, jump to one of those labels based on state * POST body handling: * don't bother iterating over input byte-by-byte or using memcpy * just pass the relevant portion of the context->service_buffer to callback
2014-07-13 01:07:36 -04:00
return -1;
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
}
Only check for '?' URI args during URI path parse
2014-07-19 06:58:53 +08:00
check_eol:
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/* bail at EOL */
if (ah->parser_state != WSI_TOKEN_CHALLENGE &&
c == '\x0d') {
if (ah->ues != URIES_IDLE)
goto forbid;
c = '\0';
ah->parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
lwsl_parser("*\n");
}
Only check for '?' URI args during URI path parse
2014-07-19 06:58:53 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
n = issue_char(wsi, c);
if ((int)n < 0)
return -1;
if (n > 0)
ah->parser_state = WSI_TOKEN_SKIPPING;
cleanup style in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2014-08-19 18:34:31 +08:00
translate and protect uri test sever use uri path This translates %xx in the GET uri and removes /.. and /... type sequences along with translating // or /// etc to /. Since the result is hopefully secure, it also changes the test server to actually use the uri path pasted on a resource directory without whitelisting. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-11-10 15:15:21 +08:00
swallow:
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/* per-protocol end of headers management */
introduce-new-04-headers-logic.patch Signed-off-by: Andy Green <andy@warmcat.com>
2011-01-18 15:39:02 +00:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (ah->parser_state == WSI_TOKEN_CHALLENGE)
goto set_parsing_complete;
break;
introduce x google mux very draft indeed This is initial x-google-mux support. It's disabled by default since it's very pre-alpha. 1) To enable it, reconfigure with --enable-x-google-mux 2) It conflicts with deflate-stream, use the -u switch on the test client to disable deflate-stream 3) It deviates from the google standard by sending full headers in the addchannel subcommand rather than just changed ones from original connect 4) Quota is not implemented yet 5) Close of subchannel is not really implemented yet 6) Google opcode 0xf is changed to 0x7 to account for v7 protocol changes to opcode layout However despite those caveats, in fact it can run the test client reliably over one socket (both dumb-increment and lws-mirror-protocol), you can open a browser on the same test server too and see the circles, etc. Signed-off-by: Andy Green <andy@warmcat.com>
2011-05-23 10:00:03 +01:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/* collecting and checking a name part */
case WSI_TOKEN_NAME_PART:
refactor mode and states into roles and states
2018-04-02 11:55:17 +08:00
lwsl_parser("WSI_TOKEN_NAME_PART '%c' 0x%02X (role=0x%x) "
"wsi->lextable_pos=%d\n", c, c, lwsi_role(wsi),
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
ah->lextable_pos);
if (c >= 'A' && c <= 'Z')
c += 'a' - 'A';
pos = ah->lextable_pos;
while (1) {
if (lextable[pos] & (1 << 7)) { /* 1-byte, fail on mismatch */
if ((lextable[pos] & 0x7f) != c) {
nope:
ah->lextable_pos = -1;
break;
}
/* fall thru */
pos++;
if (lextable[pos] == FAIL_CHAR)
goto nope;
ah->lextable_pos = pos;
break;
}
break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (lextable[pos] == FAIL_CHAR)
goto nope;
/* b7 = 0, end or 3-byte */
if (lextable[pos] < FAIL_CHAR) { /* terminal marker */
ah->lextable_pos = pos;
Add PATCH, PUT, DELETE methods AG: rewrite method code to use method arrays
2015-01-10 19:01:52 -08:00
break;
}
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (lextable[pos] == c) { /* goto */
ah->lextable_pos = pos + (lextable[pos + 1]) +
(lextable[pos + 2] << 8);
break;
}
/* fall thru goto */
pos += 3;
/* continue */
}
security harden http parser a bit Drop the connection during parsing for a few more cases that can't be legit. Take care about trying to free rxflow_buffer only if we reached a connmode where it exists Change behaviour on setting unknown HTTP method to kill connection Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-12 12:52:39 +08:00
/*
refactor mode and states into roles and states
2018-04-02 11:55:17 +08:00
* If it's h1, server needs to look out for unknown
* methods...
security harden http parser a bit Drop the connection during parsing for a few more cases that can't be legit. Take care about trying to free rxflow_buffer only if we reached a connmode where it exists Change behaviour on setting unknown HTTP method to kill connection Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-12 12:52:39 +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
if (ah->lextable_pos < 0 && lwsi_role_h1(wsi) &&
lwsi_role_server(wsi)) {
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/* this is not a header we know about */
for (m = 0; m < ARRAY_SIZE(methods); m++)
if (ah->frag_index[methods[m]]) {
/*
* already had the method, no idea what
* this crap from the client is, ignore
*/
ah->parser_state = WSI_TOKEN_SKIPPING;
break;
}
raw: enable server and client raw sockets
2017-03-07 16:06:05 +08:00
/*
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
* hm it's an unknown http method from a client in fact,
* it cannot be valid http
raw: enable server and client raw sockets
2017-03-07 16:06:05 +08:00
*/
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (m == ARRAY_SIZE(methods)) {
/*
* are we set up to accept raw in these cases?
*/
if (lws_check_opt(wsi->vhost->options,
LWS_SERVER_OPTION_FALLBACK_TO_RAW))
return 2; /* transition to raw */
raw: enable server and client raw sockets
2017-03-07 16:06:05 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
lwsl_info("Unknown method - dropping\n");
goto forbid;
}
break;
}
/*
* ...otherwise for a client, let him ignore unknown headers
* coming from the server
*/
if (ah->lextable_pos < 0) {
ah->parser_state = WSI_TOKEN_SKIPPING;
break;
Subject: [PATCH] Fix bug parsing unknown headers. Bug was introduced in 49f72aa45.
2015-01-30 12:04:43 +00:00
}
parser restrict unknown header paranoia to server methods Signed-off-by: Andy Green <andy.green@linaro.org>
2015-04-07 08:19:30 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (lextable[ah->lextable_pos] < FAIL_CHAR) {
/* terminal state */
leverage TOKEN_SKIPPING better in parser Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-04 09:24:18 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
n = ((unsigned int)lextable[ah->lextable_pos] << 8) |
lextable[ah->lextable_pos + 1];
add lexical parser for headers Profiling what happens during the ab test, one of the hotspots was strcasecmp in a loop looking for header name matches each time. This patch introduces a lexical parser that creates a state machine in 276 bytes that encodes all the known header names. The fsm is walked bytewise as chaacters come in... most states do not need any recursion to match or fail. The state machine output is cut-and-pasted into parsers.c as an unsigned char array. The fsm generator is a bit rough and ready, included in the tree but not built since normal mortals won't need to touch it. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-01-18 01:55:48 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
lwsl_parser("known hdr %d\n", n);
for (m = 0; m < ARRAY_SIZE(methods); m++)
if (n == methods[m] &&
ah->frag_index[methods[m]]) {
lwsl_warn("Duplicated method\n");
return -1;
}
security disallow repeated GET Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-12 13:10:19 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/*
* WSORIGIN is protocol equiv to ORIGIN,
* JWebSocket likes to send it, map to ORIGIN
*/
if (n == WSI_TOKEN_SWORIGIN)
n = WSI_TOKEN_ORIGIN;
map wsorigin on to origin at an early point and stop dupe header mem leaks Carlo wrote ''I'm interested to use the libwebsockets server (C based) with a Java websocket client. I was able to implement a Java websocket client based on JWebSocket library that works fine with the libwebsockets server, but I was obliged to patch the libwebsockets server in order to reach my goal. In particular I patched the handshake_00() function because JWebSocket library uses hixie 76 version. The problem was that the JWebSocket library sends only WSI_TOKEN_SWORIGIN token instead WSI_TOKEN_ORIGIN token. For this reason the handshake_00 failed because the token length of WSI_TOKEN_ORIGIN was 0. I have written a patch in order to control if at least one of the two tokens (WSI_TOKEN_SWORIGIN and WSI_TOKEN_ORIGIN) is defined. I have attached into the e-mail the patch. Probably it can be written better, but in any case I think that this problem should be fixed for client/server compatibility.'' I found a simpler approach which is convert WSORIGIN processing to go into ORIGIN token at the earliest point, then everything else can stay the same. I also noticed we would leak on duplicated headers and fixed that. Reported-by: Carlo PARATA <carlo.parata@st.com> Signed-off-by: Andy Green <andy@warmcat.com>
2012-04-03 17:02:20 +02:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
ah->parser_state = (enum lws_token_indexes)
(WSI_TOKEN_GET_URI + n);
ah->ups = URIPS_IDLE;
Reducing CPU cycles spent calculating per-header length limit.
2014-06-29 01:34:24 -04:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (context->token_limits)
ah->current_token_limit = context->
token_limits->token_limit[
ah->parser_state];
else
ah->current_token_limit =
wsi->context->max_http_header_data;
Reducing CPU cycles spent calculating per-header length limit.
2014-06-29 01:34:24 -04:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (ah->parser_state == WSI_TOKEN_CHALLENGE)
goto set_parsing_complete;
clean--fix-sigpipe.patch Signed-off-by: Andy Green <andy@warmcat.com>
2011-01-23 16:50:33 +00:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
goto start_fragment;
}
break;
make duplicate headers append instead of get ignored The code to prevent memory leaks caused by reallocating a wsi->utf8_token was also causing wsi->parser_state to not be updated, preventing the handshake from completing. This patch changes the logic to append to previous allocation which is correct behaviour actually. Signed-off-by: Nick Dowell <nick@nickdowell.com> Signed-off-by: Andy Green <andy@warmcat.com>
2012-04-05 10:31:48 +08:00
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
start_fragment:
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
ah->nfrag++;
http uri arguments process in fragments This makes the URI argument processing split each parameter into a "fragment". Processing header content as fragments already exists in lws, because it's legal to deliver header content by repeating the header. Now there's an api to access individual fragments, also add the code to the test server to print each URI argument separately. Adapt attack.sh to parse the fragments. Signed-off-by: Andy Green <andy.green@linaro.org>
2015-12-15 22:57:19 +08:00
excessive:
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (ah->nfrag == ARRAY_SIZE(ah->frags)) {
lwsl_warn("More hdr frags than we can deal with\n");
return -1;
}
break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
ah->frags[ah->nfrag].offset = ah->pos;
ah->frags[ah->nfrag].len = 0;
ah->frags[ah->nfrag].nfrag = 0;
ah->frags[ah->nfrag].flags = 2;
n = ah->frag_index[ah->parser_state];
if (!n) { /* first fragment */
ah->frag_index[ah->parser_state] = ah->nfrag;
ah->hdr_token_idx = ah->parser_state;
break;
}
/* continuation */
while (ah->frags[n].nfrag)
n = ah->frags[n].nfrag;
ah->frags[n].nfrag = ah->nfrag;
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (issue_char(wsi, ' ') < 0)
return -1;
improve minilex use external parsing header Clean up minilex Move the header output to stdout Introduce lexfile.h as the header output Use lexfile.h in both minilex itself and lws Add the following header support "Accept:", "If-Modified-Since:", "Accept-Encoding:", "Accept-Language:", "Pragma:", "Cache-Control:", "Authorization:", "Cookie:", "Content-Type:", "Date:", "Range:", "Referer:" Signed-off-by: Andy Green <andy.green@linaro.org>
2013-11-09 10:09:09 +08:00
break;
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
/* skipping arg part of a name we didn't recognize */
case WSI_TOKEN_SKIPPING:
lwsl_parser("WSI_TOKEN_SKIPPING '%c'\n", c);
coding-style-cleanups.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-13 10:03:47 +00:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
if (c == '\x0d')
ah->parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
break;
Support for HTTP POST. Rewritten by Andy Green to use chunks, add timeout, use extra states in handshake not parser. Signed-off-by: Andy Green <andy@warmcat.com>
2013-11-19 13:38:16 +01:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
case WSI_TOKEN_SKIPPING_SAW_CR:
lwsl_parser("WSI_TOKEN_SKIPPING_SAW_CR '%c'\n", c);
if (ah->ues != URIES_IDLE)
goto forbid;
if (c == '\x0a') {
ah->parser_state = WSI_TOKEN_NAME_PART;
ah->lextable_pos = 0;
} else
ah->parser_state = WSI_TOKEN_SKIPPING;
break;
/* we're done, ignore anything else */
simplify parsing complete Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-04 09:09:19 +08:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
case WSI_PARSING_COMPLETE:
lwsl_parser("WSI_PARSING_COMPLETE '%c'\n", c);
break;
}
Support for HTTP POST. Rewritten by Andy Green to use chunks, add timeout, use extra states in handshake not parser. Signed-off-by: Andy Green <andy@warmcat.com>
2013-11-19 13:38:16 +01:00
h1: header parsing optimizations
2018-03-07 18:15:17 +08:00
} while (*len);
coding-style-cleanups.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-13 10:03:47 +00:00
simplify parsing complete Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-04 09:09:19 +08:00
return 0;
set_parsing_complete:
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
if (ah->ues != URIES_IDLE)
urldecode forbid malformed And update attack.sh to confirm the new test cases Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-07 10:08:35 +08:00
goto forbid;
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
if (lws_hdr_total_length(wsi, WSI_TOKEN_UPGRADE)) {
style cleanup This brings the library sources into compliance with checkpatch style except for three or four exceptions like WIN32 related stuff and one long string constant I don't want to break into multiple sprintf calls. There should be no functional or compilability change from all this (hopefully). Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 17:13:32 +08:00
if (lws_hdr_total_length(wsi, WSI_TOKEN_VERSION))
refactor-eliminate-lws-union The union used to make a lot of sense to save space between mutually exclusive modes. But the fact the http2 struct contains the http1 struct as well as it appearing in the union means the http1 struct belongs outside the union. This patch - eliminates the union - puts the http_related struct directly in struct lws - removes http_related from h2 - puts h2 directly in struct lws if enabled for build - changes ws to be a pointer, allocated if we upgrade to ws (the ws part contains a 135 byte char array for ping / close) Again all of this is entirely private / internal and doesn't affect any apis.
2017-12-01 11:09:32 +08:00
wsi->rx_frame_type = /* temp for ws version index */
replace per header mallocs with single malloc 3 level struct This big patch replaces the malloc / realloc per header approach used until now with a single three-level struct that gets malloc'd during the header union phase and freed in one go when we transition to a different union phase. It's more expensive in that we malloc a bit more than 4Kbytes, but it's a lot cheaper in terms of malloc, frees, heap fragmentation, no reallocs, nothing to configure. It also moves from arrays of pointers (8 bytes on x86_64) to unsigned short offsets into the data array, (2 bytes on all platforms). The 3-level thing is all in one struct - array indexed by the header enum, pointing to first "fragment" index (ie, header type to fragment lookup, or 0 for none) - array of fragments indexes, enough for 2 x the number of known headers (fragment array... note that fragments can point to a "next" fragment if the same header is spread across multiple entries) - linear char array where the known header payload gets written (fragments point into null-terminated strings stored in here, only the known header content is stored) http headers can legally be split over multiple headers of the same name which should be concatenated. This scheme does not linearly conatenate them but uses a linked list in the fragment structs to link them. There are apis to get the total length and copy out a linear, concatenated version to a buffer. Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-10 18:02:31 +08:00
atoi(lws_hdr_simple_ptr(wsi, WSI_TOKEN_VERSION));
simplify parsing complete Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-04 09:09:19 +08:00
refactor-eliminate-lws-union The union used to make a lot of sense to save space between mutually exclusive modes. But the fact the http2 struct contains the http1 struct as well as it appearing in the union means the http1 struct belongs outside the union. This patch - eliminates the union - puts the http_related struct directly in struct lws - removes http_related from h2 - puts h2 directly in struct lws if enabled for build - changes ws to be a pointer, allocated if we upgrade to ws (the ws part contains a 135 byte char array for ping / close) Again all of this is entirely private / internal and doesn't affect any apis.
2017-12-01 11:09:32 +08:00
lwsl_parser("v%02d hdrs done\n", wsi->rx_frame_type);
headers deleted after websocket established Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-06 15:15:25 +09:00
}
refactor-struct-lws-hdr Migrate what used to be in lws_hdr_related into either the ah or the wsi, and eliminate it along with the three different ways used to access things inside it. Eg wsi->u.hdr.ah and wsi->u.http.ah become wsi->ah These changes are internal-only, in private-libwebsockets.h and lib.
2017-11-16 11:26:00 +08:00
ah->parser_state = WSI_PARSING_COMPLETE;
fix ssl reject path for freeing header allocation If the SSL connection failed before the headers came, we were not dealing with deallocating the header malloc. This takes care of it. Using CyaSSL, we are then valgrind-clean for ssl client and server. With OpenSSL, there is 88 bytes lost at init that never changes or gets recovered. AFAIK there's nothing to do about that. OpenSSL also blows these during operation ==1059== Conditional jump or move depends on uninitialised value(s) ==1059== at 0x4A0B131: bcmp (mc_replace_strmem.c:935) ==1059== by 0x3014CDDBA8: ??? (in /usr/lib64/libcrypto.so.1.0.1c) ==1059== by 0x3015430852: tls1_enc (in /usr/lib64/libssl.so.1.0.1c) ==1059== by 0x3015428CEC: ssl3_read_bytes (in /usr/lib64/libssl.so.1.0.1c) ==1059== by 0x30154264C5: ??? (in /usr/lib64/libssl.so.1.0.1c) ==1059== by 0x4C3C596: lws_server_socket_service (server.c:153) ==1059== by 0x4C32C1E: libwebsocket_service_fd (libwebsockets.c:927) ==1059== by 0x4C33270: libwebsocket_service (libwebsockets.c:1225) ==1059== by 0x401C84: main (in /usr/bin/libwebsockets-test-server) However googling around https://bugs.launchpad.net/ubuntu/+source/openssl/+bug/60021 http://www.openssl.org/support/faq.html#PROG13 (also the next FAQ down) it seems OpenSSL have a relaxed attitude to this and it's expected. It's interesting CyaSSL works fine but doesn't have that problem... Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-11 21:43:41 +08:00
wsi->hdr_parsing_completed = 1;
simplify parsing complete Signed-off-by: Andy Green <andy.green@linaro.org>
2013-02-04 09:09:19 +08:00
break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
return 0;
urldecode forbid malformed And update attack.sh to confirm the new test cases Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-07 10:08:35 +08:00
forbid:
lwsl_notice(" forbidding on uri sanitation\n");
lws_return_http_status(wsi, HTTP_STATUS_FORBIDDEN, NULL);
http2: make usable HTTP/2 support is now able to serve the test server, complete with websockets, from a single vhost. - This works the same with both OpenSSL and mbedTLS. - POST is now wired up and works (also for file upload). - CGI is wired up and works. - Redirect is adapted and works - lwsws works. - URI urldecode, sanitation and argument parsing wired up for :path valgrind clean (aside from openssl-style false uninit data usage in mbedtls send occasionally) h2spec reports: $ h2spec -h 127.0.0.1 -p 7681 -t -k -o 1 ... 145 tests, 145 passed, 0 skipped, 0 failed" Incorporates: - "https://github.com/warmcat/libwebsockets/pull/1039 Fixes issue with -Werror=unused-variable flag - https://github.com/sartura/libwebsockets/commit/2c843a1395bdca5c23b40d989f508fc96aa5ba3b ssl: fix infinite loop on client cert verification failure Signed-off-by: Petar Paradzik <petar.paradzik@sartura.hr>" Caused and fixes Coverity 184887 - 184892
2017-10-13 10:33:02 +08:00
urldecode forbid malformed And update attack.sh to confirm the new test cases Signed-off-by: Andy Green <andy@warmcat.com>
2016-04-07 10:08:35 +08:00
return -1;
break-out-lib-sources.patch Signed-off-by: Andy Green <andy@warmcat.com>
2010-11-08 20:20:42 +00:00
}
Reference in a new issue Copy permalink