You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1024 lines
26 KiB
1024 lines
26 KiB
/*
|
|
* libwebsockets - small server side websockets and web server implementation
|
|
*
|
|
* Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to
|
|
* deal in the Software without restriction, including without limitation the
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <private-lib-core.h>
|
|
|
|
#define LWS_CPYAPP(ptr, str) { strcpy(ptr, str); ptr += strlen(str); }
|
|
|
|
#if !defined(LWS_WITHOUT_EXTENSIONS)
|
|
static int
|
|
lws_extension_server_handshake(struct lws *wsi, char **p, int budget)
|
|
{
|
|
struct lws_context *context = wsi->context;
|
|
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
|
|
char ext_name[64], *args, *end = (*p) + budget - 1;
|
|
const struct lws_ext_options *opts, *po;
|
|
const struct lws_extension *ext;
|
|
struct lws_ext_option_arg oa;
|
|
int n, m, more = 1;
|
|
int ext_count = 0;
|
|
char ignore;
|
|
char *c;
|
|
|
|
/*
|
|
* Figure out which extensions the client has that we want to
|
|
* enable on this connection, and give him back the list
|
|
*/
|
|
if (!lws_hdr_total_length(wsi, WSI_TOKEN_EXTENSIONS))
|
|
return 0;
|
|
|
|
/*
|
|
* break down the list of client extensions
|
|
* and go through them
|
|
*/
|
|
|
|
if (lws_hdr_copy(wsi, (char *)pt->serv_buf, context->pt_serv_buf_size,
|
|
WSI_TOKEN_EXTENSIONS) < 0)
|
|
return 1;
|
|
|
|
c = (char *)pt->serv_buf;
|
|
lwsl_parser("WSI_TOKEN_EXTENSIONS = '%s'\n", c);
|
|
wsi->ws->count_act_ext = 0;
|
|
ignore = 0;
|
|
n = 0;
|
|
args = NULL;
|
|
|
|
/*
|
|
* We may get a simple request
|
|
*
|
|
* Sec-WebSocket-Extensions: permessage-deflate
|
|
*
|
|
* or an elaborated one with requested options
|
|
*
|
|
* Sec-WebSocket-Extensions: permessage-deflate; \
|
|
* server_no_context_takeover; \
|
|
* client_no_context_takeover
|
|
*/
|
|
|
|
while (more) {
|
|
|
|
if (c >= (char *)pt->serv_buf + 255)
|
|
return -1;
|
|
|
|
if (*c && (*c != ',' && *c != '\t')) {
|
|
if (*c == ';') {
|
|
ignore = 1;
|
|
if (!args)
|
|
args = c + 1;
|
|
}
|
|
if (ignore || *c == ' ') {
|
|
c++;
|
|
continue;
|
|
}
|
|
ext_name[n] = *c++;
|
|
if (n < (int)sizeof(ext_name) - 1)
|
|
n++;
|
|
continue;
|
|
}
|
|
ext_name[n] = '\0';
|
|
|
|
ignore = 0;
|
|
if (!*c)
|
|
more = 0;
|
|
else {
|
|
c++;
|
|
if (!n)
|
|
continue;
|
|
}
|
|
|
|
while (args && *args == ' ')
|
|
args++;
|
|
|
|
/* check a client's extension against our support */
|
|
|
|
ext = wsi->vhost->ws.extensions;
|
|
|
|
while (ext && ext->callback) {
|
|
|
|
if (strcmp(ext_name, ext->name)) {
|
|
ext++;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* oh, we do support this one he asked for... but let's
|
|
* confirm he only gave it once
|
|
*/
|
|
for (m = 0; m < wsi->ws->count_act_ext; m++)
|
|
if (wsi->ws->active_extensions[m] == ext) {
|
|
lwsl_info("ext mentioned twice\n");
|
|
return 1; /* shenanigans */
|
|
}
|
|
|
|
/*
|
|
* ask user code if it's OK to apply it on this
|
|
* particular connection + protocol
|
|
*/
|
|
m = (wsi->protocol->callback)(wsi,
|
|
LWS_CALLBACK_CONFIRM_EXTENSION_OKAY,
|
|
wsi->user_space, ext_name, 0);
|
|
|
|
/*
|
|
* zero return from callback means go ahead and allow
|
|
* the extension, it's what we get if the callback is
|
|
* unhandled
|
|
*/
|
|
if (m) {
|
|
ext++;
|
|
continue;
|
|
}
|
|
|
|
/* apply it */
|
|
|
|
ext_count++;
|
|
|
|
/* instantiate the extension on this conn */
|
|
|
|
wsi->ws->active_extensions[wsi->ws->count_act_ext] = ext;
|
|
|
|
/* allow him to construct his context */
|
|
|
|
if (ext->callback(lws_get_context(wsi), ext, wsi,
|
|
LWS_EXT_CB_CONSTRUCT,
|
|
(void *)&wsi->ws->act_ext_user[
|
|
wsi->ws->count_act_ext],
|
|
(void *)&opts, 0)) {
|
|
lwsl_info("ext %s failed construction\n",
|
|
ext_name);
|
|
ext_count--;
|
|
ext++;
|
|
|
|
continue;
|
|
}
|
|
|
|
if (ext_count > 1)
|
|
*(*p)++ = ',';
|
|
else
|
|
LWS_CPYAPP(*p,
|
|
"\x0d\x0aSec-WebSocket-Extensions: ");
|
|
*p += lws_snprintf(*p, (end - *p), "%s", ext_name);
|
|
|
|
/*
|
|
* The client may send a bunch of different option
|
|
* sets for the same extension, we are supposed to
|
|
* pick one we like the look of. The option sets are
|
|
* separated by comma.
|
|
*
|
|
* Actually we just either accept the first one or
|
|
* nothing.
|
|
*
|
|
* Go through the options trying to apply the
|
|
* recognized ones
|
|
*/
|
|
|
|
lwsl_info("ext args %s\n", args);
|
|
|
|
while (args && *args && *args != ',') {
|
|
while (*args == ' ')
|
|
args++;
|
|
po = opts;
|
|
while (po->name) {
|
|
/* only support arg-less options... */
|
|
if (po->type != EXTARG_NONE ||
|
|
strncmp(args, po->name,
|
|
strlen(po->name))) {
|
|
po++;
|
|
continue;
|
|
}
|
|
oa.option_name = NULL;
|
|
oa.option_index = (int)(po - opts);
|
|
oa.start = NULL;
|
|
oa.len = 0;
|
|
lwsl_info("setting '%s'\n", po->name);
|
|
if (!ext->callback(lws_get_context(wsi),
|
|
ext, wsi,
|
|
LWS_EXT_CB_OPTION_SET,
|
|
wsi->ws->act_ext_user[
|
|
wsi->ws->count_act_ext],
|
|
&oa, (end - *p))) {
|
|
|
|
*p += lws_snprintf(*p,
|
|
(end - *p),
|
|
"; %s", po->name);
|
|
lwsl_debug("adding option %s\n",
|
|
po->name);
|
|
}
|
|
po++;
|
|
}
|
|
while (*args && *args != ',' && *args != ';')
|
|
args++;
|
|
|
|
if (*args == ';')
|
|
args++;
|
|
}
|
|
|
|
wsi->ws->count_act_ext++;
|
|
lwsl_parser("cnt_act_ext <- %d\n",
|
|
wsi->ws->count_act_ext);
|
|
|
|
if (args && *args == ',')
|
|
more = 0;
|
|
|
|
ext++;
|
|
}
|
|
|
|
n = 0;
|
|
args = NULL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
int
|
|
lws_process_ws_upgrade2(struct lws *wsi)
|
|
{
|
|
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
|
|
#if defined(LWS_WITH_HTTP_BASIC_AUTH)
|
|
const struct lws_protocol_vhost_options *pvos = NULL;
|
|
const char *ws_prot_basic_auth = NULL;
|
|
|
|
|
|
/*
|
|
* Allow basic auth a look-in now we bound the wsi to the protocol.
|
|
*
|
|
* For vhost ws basic auth, it is "basic-auth": "path" as usual but
|
|
* applied to the protocol's entry in the vhost's "ws-protocols":
|
|
* section, as a pvo.
|
|
*/
|
|
|
|
pvos = lws_vhost_protocol_options(wsi->vhost, wsi->protocol->name);
|
|
if (pvos && pvos->options &&
|
|
!lws_pvo_get_str((void *)pvos->options, "basic-auth",
|
|
&ws_prot_basic_auth)) {
|
|
lwsl_info("%s: ws upgrade requires basic auth\n", __func__);
|
|
switch (lws_check_basic_auth(wsi, ws_prot_basic_auth, LWSAUTHM_DEFAULT
|
|
/* no callback based auth here */)) {
|
|
case LCBA_CONTINUE:
|
|
break;
|
|
case LCBA_FAILED_AUTH:
|
|
return lws_unauthorised_basic_auth(wsi);
|
|
case LCBA_END_TRANSACTION:
|
|
lws_return_http_status(wsi, HTTP_STATUS_FORBIDDEN, NULL);
|
|
return lws_http_transaction_completed(wsi);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* We are upgrading to ws, so http/1.1 + h2 and keepalive + pipelined
|
|
* header considerations about keeping the ah around no longer apply.
|
|
*
|
|
* However it's common for the first ws protocol data to have been
|
|
* coalesced with the browser upgrade request and to already be in the
|
|
* ah rx buffer.
|
|
*/
|
|
|
|
lws_pt_lock(pt, __func__);
|
|
|
|
if (!wsi->h2_stream_carries_ws)
|
|
lws_role_transition(wsi, LWSIFR_SERVER, LRS_ESTABLISHED,
|
|
&role_ops_ws);
|
|
|
|
lws_pt_unlock(pt);
|
|
|
|
/* allocate the ws struct for the wsi */
|
|
|
|
wsi->ws = lws_zalloc(sizeof(*wsi->ws), "ws struct");
|
|
if (!wsi->ws) {
|
|
lwsl_notice("OOM\n");
|
|
return 1;
|
|
}
|
|
|
|
if (lws_hdr_total_length(wsi, WSI_TOKEN_VERSION))
|
|
wsi->ws->ietf_spec_revision =
|
|
atoi(lws_hdr_simple_ptr(wsi, WSI_TOKEN_VERSION));
|
|
|
|
/* allocate wsi->user storage */
|
|
if (lws_ensure_user_space(wsi)) {
|
|
lwsl_notice("problem with user space\n");
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Give the user code a chance to study the request and
|
|
* have the opportunity to deny it
|
|
*/
|
|
if ((wsi->protocol->callback)(wsi,
|
|
LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION,
|
|
wsi->user_space,
|
|
lws_hdr_simple_ptr(wsi, WSI_TOKEN_PROTOCOL), 0)) {
|
|
lwsl_warn("User code denied connection\n");
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Perform the handshake according to the protocol version the
|
|
* client announced
|
|
*/
|
|
|
|
switch (wsi->ws->ietf_spec_revision) {
|
|
default:
|
|
lwsl_notice("Unknown client spec version %d\n",
|
|
wsi->ws->ietf_spec_revision);
|
|
wsi->ws->ietf_spec_revision = 13;
|
|
//return 1;
|
|
/* fallthru */
|
|
case 13:
|
|
#if defined(LWS_WITH_HTTP2)
|
|
if (wsi->h2_stream_carries_ws) {
|
|
if (lws_h2_ws_handshake(wsi)) {
|
|
lwsl_notice("h2 ws handshake failed\n");
|
|
return 1;
|
|
}
|
|
lws_role_transition(wsi,
|
|
LWSIFR_SERVER | LWSIFR_P_ENCAP_H2,
|
|
LRS_ESTABLISHED, &role_ops_ws);
|
|
|
|
/*
|
|
* There should be no validity checking since we
|
|
* are encapsulated in something else with its own
|
|
* validity checking
|
|
*/
|
|
|
|
__lws_sul_insert(&pt->pt_sul_owner, &wsi->sul_validity,
|
|
LWS_SET_TIMER_USEC_CANCEL);
|
|
} else
|
|
#endif
|
|
{
|
|
lwsl_parser("lws_parse calling handshake_04\n");
|
|
if (handshake_0405(wsi->context, wsi)) {
|
|
lwsl_notice("hs0405 has failed the connection\n");
|
|
return 1;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
lws_server_init_wsi_for_ws(wsi);
|
|
lwsl_parser("accepted v%02d connection\n", wsi->ws->ietf_spec_revision);
|
|
|
|
#if defined(LWS_WITH_ACCESS_LOG)
|
|
{
|
|
char *uptr = "unknown method", combo[128], dotstar[64];
|
|
int l = 14, meth = lws_http_get_uri_and_method(wsi, &uptr, &l);
|
|
|
|
if (wsi->h2_stream_carries_ws)
|
|
wsi->http.request_version = HTTP_VERSION_2;
|
|
|
|
wsi->http.access_log.response = 101;
|
|
|
|
lws_strnncpy(dotstar, uptr, l, sizeof(dotstar));
|
|
l = lws_snprintf(combo, sizeof(combo), "%s (%s)", dotstar,
|
|
wsi->protocol->name);
|
|
|
|
if (meth < 0)
|
|
meth = 0;
|
|
lws_prepare_access_log_info(wsi, combo, l, meth);
|
|
lws_access_log(wsi);
|
|
}
|
|
#endif
|
|
|
|
lwsl_info("%s: %p: dropping ah on ws upgrade\n", __func__, wsi);
|
|
lws_header_table_detach(wsi, 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lws_process_ws_upgrade(struct lws *wsi)
|
|
{
|
|
const struct lws_protocols *pcol = NULL;
|
|
char buf[128], name[64];
|
|
struct lws_tokenize ts;
|
|
lws_tokenize_elem e;
|
|
int n;
|
|
|
|
if (!wsi->protocol)
|
|
lwsl_err("NULL protocol at lws_read\n");
|
|
|
|
/*
|
|
* It's either websocket or h2->websocket
|
|
*
|
|
* If we are on h1, confirm we got the required "connection: upgrade"
|
|
* header. h2 / ws-over-h2 does not have this.
|
|
*/
|
|
|
|
#if defined(LWS_WITH_HTTP2)
|
|
if (!wsi->mux_substream) {
|
|
#endif
|
|
|
|
lws_tokenize_init(&ts, buf, LWS_TOKENIZE_F_COMMA_SEP_LIST |
|
|
LWS_TOKENIZE_F_DOT_NONTERM |
|
|
LWS_TOKENIZE_F_RFC7230_DELIMS |
|
|
LWS_TOKENIZE_F_MINUS_NONTERM);
|
|
n = lws_hdr_copy(wsi, buf, sizeof(buf) - 1, WSI_TOKEN_CONNECTION);
|
|
if (n <= 0)
|
|
goto bad_conn_format;
|
|
ts.len = n;
|
|
|
|
do {
|
|
e = lws_tokenize(&ts);
|
|
switch (e) {
|
|
case LWS_TOKZE_TOKEN:
|
|
if (!strncasecmp(ts.token, "upgrade", ts.token_len))
|
|
e = LWS_TOKZE_ENDED;
|
|
break;
|
|
|
|
case LWS_TOKZE_DELIMITER:
|
|
break;
|
|
|
|
default: /* includes ENDED */
|
|
bad_conn_format:
|
|
lwsl_err("%s: malformed or absent conn hdr\n",
|
|
__func__);
|
|
|
|
return 1;
|
|
}
|
|
} while (e > 0);
|
|
|
|
#if defined(LWS_WITH_HTTP2)
|
|
}
|
|
#endif
|
|
|
|
#if defined(LWS_WITH_HTTP_PROXY)
|
|
{
|
|
const struct lws_http_mount *hit;
|
|
int uri_len = 0, meth;
|
|
char *uri_ptr;
|
|
|
|
meth = lws_http_get_uri_and_method(wsi, &uri_ptr, &uri_len);
|
|
hit = lws_find_mount(wsi, uri_ptr, uri_len);
|
|
|
|
if (hit && (meth == LWSHUMETH_GET ||
|
|
meth == LWSHUMETH_CONNECT ||
|
|
meth == LWSHUMETH_COLON_PATH) &&
|
|
(hit->origin_protocol == LWSMPRO_HTTPS ||
|
|
hit->origin_protocol == LWSMPRO_HTTP))
|
|
/*
|
|
* We are an h1 ws upgrade on a urlpath that corresponds
|
|
* to a proxying mount. Don't try to deal with it
|
|
* locally, eg, we won't even have the right protocol
|
|
* handler since we're not the guy handling it, just a
|
|
* conduit.
|
|
*
|
|
* Instead open the related ongoing h1 connection
|
|
* according to the mount configuration and proxy
|
|
* whatever that has to say from now on.
|
|
*/
|
|
return lws_http_proxy_start(wsi, hit, uri_ptr, 1);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Select the first protocol we support from the list
|
|
* the client sent us.
|
|
*/
|
|
|
|
lws_tokenize_init(&ts, buf, LWS_TOKENIZE_F_COMMA_SEP_LIST |
|
|
LWS_TOKENIZE_F_MINUS_NONTERM |
|
|
LWS_TOKENIZE_F_DOT_NONTERM |
|
|
LWS_TOKENIZE_F_RFC7230_DELIMS);
|
|
n = lws_hdr_copy(wsi, buf, sizeof(buf) - 1, WSI_TOKEN_PROTOCOL);
|
|
if (n < 0) {
|
|
lwsl_err("%s: protocol list too long\n", __func__);
|
|
return 1;
|
|
}
|
|
ts.len = n;
|
|
if (!ts.len) {
|
|
int n = wsi->vhost->default_protocol_index;
|
|
/*
|
|
* Some clients only have one protocol and do not send the
|
|
* protocol list header... allow it and match to the vhost's
|
|
* default protocol (which itself defaults to zero).
|
|
*
|
|
* Setting the vhost default protocol index to -1 or anything
|
|
* more than the actual number of protocols on the vhost causes
|
|
* these "no protocol" ws connections to be rejected.
|
|
*/
|
|
|
|
if (n >= wsi->vhost->count_protocols) {
|
|
lwsl_notice("%s: rejecting ws upg with no protocol\n",
|
|
__func__);
|
|
|
|
return 1;
|
|
}
|
|
|
|
lwsl_info("%s: defaulting to prot handler %d\n", __func__, n);
|
|
|
|
lws_bind_protocol(wsi, &wsi->vhost->protocols[n],
|
|
"ws upgrade default pcol");
|
|
|
|
goto alloc_ws;
|
|
}
|
|
|
|
/* otherwise go through the user-provided protocol list */
|
|
|
|
do {
|
|
e = lws_tokenize(&ts);
|
|
switch (e) {
|
|
case LWS_TOKZE_TOKEN:
|
|
|
|
if (lws_tokenize_cstr(&ts, name, sizeof(name))) {
|
|
lwsl_err("%s: pcol name too long\n", __func__);
|
|
|
|
return 1;
|
|
}
|
|
lwsl_debug("checking %s\n", name);
|
|
pcol = lws_vhost_name_to_protocol(wsi->vhost, name);
|
|
if (pcol) {
|
|
/* if we know it, bind to it and stop looking */
|
|
lws_bind_protocol(wsi, pcol, "ws upg pcol");
|
|
e = LWS_TOKZE_ENDED;
|
|
}
|
|
break;
|
|
|
|
case LWS_TOKZE_DELIMITER:
|
|
case LWS_TOKZE_ENDED:
|
|
break;
|
|
|
|
default:
|
|
lwsl_err("%s: malformatted protocol list", __func__);
|
|
|
|
return 1;
|
|
}
|
|
} while (e > 0);
|
|
|
|
/* we didn't find a protocol he wanted? */
|
|
|
|
if (!pcol) {
|
|
lwsl_notice("No supported protocol \"%s\"\n", buf);
|
|
|
|
return 1;
|
|
}
|
|
|
|
alloc_ws:
|
|
|
|
return lws_process_ws_upgrade2(wsi);
|
|
}
|
|
|
|
int
|
|
handshake_0405(struct lws_context *context, struct lws *wsi)
|
|
{
|
|
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
|
|
struct lws_process_html_args args;
|
|
unsigned char hash[20];
|
|
int n, accept_len;
|
|
char *response;
|
|
char *p;
|
|
|
|
if (!lws_hdr_total_length(wsi, WSI_TOKEN_HOST) ||
|
|
!lws_hdr_total_length(wsi, WSI_TOKEN_KEY)) {
|
|
lwsl_info("handshake_04 missing pieces\n");
|
|
/* completed header processing, but missing some bits */
|
|
goto bail;
|
|
}
|
|
|
|
if (lws_hdr_total_length(wsi, WSI_TOKEN_KEY) >=
|
|
MAX_WEBSOCKET_04_KEY_LEN) {
|
|
lwsl_warn("Client key too long %d\n", MAX_WEBSOCKET_04_KEY_LEN);
|
|
goto bail;
|
|
}
|
|
|
|
/*
|
|
* since key length is restricted above (currently 128), cannot
|
|
* overflow
|
|
*/
|
|
n = sprintf((char *)pt->serv_buf,
|
|
"%s258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
|
|
lws_hdr_simple_ptr(wsi, WSI_TOKEN_KEY));
|
|
|
|
lws_SHA1(pt->serv_buf, n, hash);
|
|
|
|
accept_len = lws_b64_encode_string((char *)hash, 20,
|
|
(char *)pt->serv_buf, context->pt_serv_buf_size);
|
|
if (accept_len < 0) {
|
|
lwsl_warn("Base64 encoded hash too long\n");
|
|
goto bail;
|
|
}
|
|
|
|
/* allocate the per-connection user memory (if any) */
|
|
if (lws_ensure_user_space(wsi))
|
|
goto bail;
|
|
|
|
/* create the response packet */
|
|
|
|
/* make a buffer big enough for everything */
|
|
|
|
response = (char *)pt->serv_buf + MAX_WEBSOCKET_04_KEY_LEN +
|
|
256 + LWS_PRE;
|
|
p = response;
|
|
LWS_CPYAPP(p, "HTTP/1.1 101 Switching Protocols\x0d\x0a"
|
|
"Upgrade: WebSocket\x0d\x0a"
|
|
"Connection: Upgrade\x0d\x0a"
|
|
"Sec-WebSocket-Accept: ");
|
|
strcpy(p, (char *)pt->serv_buf);
|
|
p += accept_len;
|
|
|
|
/* we can only return the protocol header if:
|
|
* - one came in, and ... */
|
|
if (lws_hdr_total_length(wsi, WSI_TOKEN_PROTOCOL) &&
|
|
/* - it is not an empty string */
|
|
wsi->protocol->name &&
|
|
wsi->protocol->name[0]) {
|
|
const char *prot = wsi->protocol->name;
|
|
|
|
#if defined(LWS_WITH_HTTP_PROXY)
|
|
if (wsi->proxied_ws_parent && wsi->child_list)
|
|
prot = wsi->child_list->ws->actual_protocol;
|
|
#endif
|
|
|
|
LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Protocol: ");
|
|
p += lws_snprintf(p, 128, "%s", prot);
|
|
}
|
|
|
|
#if !defined(LWS_WITHOUT_EXTENSIONS)
|
|
/*
|
|
* Figure out which extensions the client has that we want to
|
|
* enable on this connection, and give him back the list.
|
|
*
|
|
* Give him a limited write bugdet
|
|
*/
|
|
if (lws_extension_server_handshake(wsi, &p, 192))
|
|
goto bail;
|
|
#endif
|
|
LWS_CPYAPP(p, "\x0d\x0a");
|
|
|
|
args.p = p;
|
|
args.max_len = lws_ptr_diff((char *)pt->serv_buf +
|
|
context->pt_serv_buf_size, p);
|
|
if (user_callback_handle_rxflow(wsi->protocol->callback, wsi,
|
|
LWS_CALLBACK_ADD_HEADERS,
|
|
wsi->user_space, &args, 0))
|
|
goto bail;
|
|
|
|
p = args.p;
|
|
|
|
/* end of response packet */
|
|
|
|
LWS_CPYAPP(p, "\x0d\x0a");
|
|
|
|
/* okay send the handshake response accepting the connection */
|
|
|
|
lwsl_parser("issuing resp pkt %d len\n",
|
|
lws_ptr_diff(p, response));
|
|
#if defined(DEBUG)
|
|
fwrite(response, 1, p - response, stderr);
|
|
#endif
|
|
n = lws_write(wsi, (unsigned char *)response, p - response,
|
|
LWS_WRITE_HTTP_HEADERS);
|
|
if (n != (p - response)) {
|
|
lwsl_info("%s: ERROR writing to socket %d\n", __func__, n);
|
|
goto bail;
|
|
}
|
|
|
|
/* alright clean up and set ourselves into established state */
|
|
|
|
lwsi_set_state(wsi, LRS_ESTABLISHED);
|
|
wsi->lws_rx_parse_state = LWS_RXPS_NEW;
|
|
|
|
{
|
|
const char * uri_ptr =
|
|
lws_hdr_simple_ptr(wsi, WSI_TOKEN_GET_URI);
|
|
int uri_len = lws_hdr_total_length(wsi, WSI_TOKEN_GET_URI);
|
|
const struct lws_http_mount *hit =
|
|
lws_find_mount(wsi, uri_ptr, uri_len);
|
|
if (hit && hit->cgienv &&
|
|
wsi->protocol->callback(wsi, LWS_CALLBACK_HTTP_PMO,
|
|
wsi->user_space, (void *)hit->cgienv, 0))
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
|
|
bail:
|
|
/* caller will free up his parsing allocations */
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Once we reach LWS_RXPS_WS_FRAME_PAYLOAD, we know how much
|
|
* to expect in that state and can deal with it in bulk more efficiently.
|
|
*/
|
|
|
|
static int
|
|
lws_ws_frame_rest_is_payload(struct lws *wsi, uint8_t **buf, size_t len)
|
|
{
|
|
struct lws_ext_pm_deflate_rx_ebufs pmdrx;
|
|
unsigned int avail = (unsigned int)len;
|
|
uint8_t *buffer = *buf, mask[4];
|
|
#if !defined(LWS_WITHOUT_EXTENSIONS)
|
|
unsigned int old_packet_length = (int)wsi->ws->rx_packet_length;
|
|
#endif
|
|
int n = 0;
|
|
|
|
/*
|
|
* With zlib, we can give it as much input as we like. The pmd
|
|
* extension will draw it down in chunks (default 1024).
|
|
*
|
|
* If we try to restrict how much we give it, because we must go
|
|
* back to the event loop each time, we will drop the remainder...
|
|
*/
|
|
|
|
#if !defined(LWS_WITHOUT_EXTENSIONS)
|
|
if (!wsi->ws->count_act_ext)
|
|
#endif
|
|
{
|
|
if (wsi->protocol->rx_buffer_size)
|
|
avail = (int)wsi->protocol->rx_buffer_size;
|
|
else
|
|
avail = wsi->context->pt_serv_buf_size;
|
|
}
|
|
|
|
/* do not consume more than we should */
|
|
if (avail > wsi->ws->rx_packet_length)
|
|
avail = (unsigned int)wsi->ws->rx_packet_length;
|
|
|
|
/* do not consume more than what is in the buffer */
|
|
if (avail > len)
|
|
avail = (unsigned int)len;
|
|
|
|
if (!avail)
|
|
return 0;
|
|
|
|
pmdrx.eb_in.token = buffer;
|
|
pmdrx.eb_in.len = avail;
|
|
pmdrx.eb_out.token = buffer;
|
|
pmdrx.eb_out.len = avail;
|
|
|
|
if (!wsi->ws->all_zero_nonce) {
|
|
|
|
for (n = 0; n < 4; n++)
|
|
mask[n] = wsi->ws->mask[(wsi->ws->mask_idx + n) & 3];
|
|
|
|
/* deal with 4-byte chunks using unwrapped loop */
|
|
n = avail >> 2;
|
|
while (n--) {
|
|
*(buffer) = *(buffer) ^ mask[0];
|
|
buffer++;
|
|
*(buffer) = *(buffer) ^ mask[1];
|
|
buffer++;
|
|
*(buffer) = *(buffer) ^ mask[2];
|
|
buffer++;
|
|
*(buffer) = *(buffer) ^ mask[3];
|
|
buffer++;
|
|
}
|
|
/* and the remaining bytes bytewise */
|
|
for (n = 0; n < (int)(avail & 3); n++) {
|
|
*(buffer) = *(buffer) ^ mask[n];
|
|
buffer++;
|
|
}
|
|
|
|
wsi->ws->mask_idx = (wsi->ws->mask_idx + avail) & 3;
|
|
}
|
|
|
|
lwsl_info("%s: using %d of raw input (total %d on offer)\n", __func__,
|
|
avail, (int)len);
|
|
|
|
(*buf) += avail;
|
|
len -= avail;
|
|
wsi->ws->rx_packet_length -= avail;
|
|
|
|
#if !defined(LWS_WITHOUT_EXTENSIONS)
|
|
n = lws_ext_cb_active(wsi, LWS_EXT_CB_PAYLOAD_RX, &pmdrx, 0);
|
|
lwsl_info("%s: ext says %d / ebuf_out.len %d\n", __func__, n,
|
|
pmdrx.eb_out.len);
|
|
|
|
/*
|
|
* ebuf may be pointing somewhere completely different now,
|
|
* it's the output
|
|
*/
|
|
|
|
if (n < 0) {
|
|
/*
|
|
* we may rely on this to get RX, just drop connection
|
|
*/
|
|
lwsl_notice("%s: LWS_EXT_CB_PAYLOAD_RX blew out\n", __func__);
|
|
wsi->socket_is_permanently_unusable = 1;
|
|
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* if we had an rx fragment right at the last compressed byte of the
|
|
* message, we can get a zero length inflated output, where no prior
|
|
* rx inflated output marked themselves with FIN, since there was
|
|
* raw ws payload still to drain at that time.
|
|
*
|
|
* Then we need to generate a zero length ws rx that can be understood
|
|
* as the message completion.
|
|
*/
|
|
|
|
if (!pmdrx.eb_out.len && /* zero-length inflation output */
|
|
n == PMDR_EMPTY_FINAL && /* nothing to drain from the inflator */
|
|
old_packet_length && /* we gave the inflator new input */
|
|
!wsi->ws->rx_packet_length && /* raw ws packet payload all gone */
|
|
wsi->ws->final && /* the raw ws packet is a FIN guy */
|
|
wsi->protocol->callback &&
|
|
!wsi->wsistate_pre_close) {
|
|
|
|
lwsl_ext("%s: issuing zero length FIN pkt\n", __func__);
|
|
|
|
if (user_callback_handle_rxflow(wsi->protocol->callback, wsi,
|
|
LWS_CALLBACK_RECEIVE,
|
|
wsi->user_space, NULL, 0))
|
|
return -1;
|
|
|
|
return avail;
|
|
}
|
|
|
|
/*
|
|
* If doing permessage-deflate, above was the only way to get a zero
|
|
* length receive. Otherwise we're more willing.
|
|
*/
|
|
if (wsi->ws->count_act_ext && !pmdrx.eb_out.len)
|
|
return avail;
|
|
|
|
if (n == PMDR_HAS_PENDING)
|
|
/* extension had more... main loop will come back */
|
|
lws_add_wsi_to_draining_ext_list(wsi);
|
|
else
|
|
lws_remove_wsi_from_draining_ext_list(wsi);
|
|
#endif
|
|
|
|
if (pmdrx.eb_out.len &&
|
|
wsi->ws->check_utf8 && !wsi->ws->defeat_check_utf8) {
|
|
if (lws_check_utf8(&wsi->ws->utf8,
|
|
pmdrx.eb_out.token,
|
|
pmdrx.eb_out.len)) {
|
|
lws_close_reason(wsi, LWS_CLOSE_STATUS_INVALID_PAYLOAD,
|
|
(uint8_t *)"bad utf8", 8);
|
|
goto utf8_fail;
|
|
}
|
|
|
|
/* we are ending partway through utf-8 character? */
|
|
if (!wsi->ws->rx_packet_length && wsi->ws->final &&
|
|
wsi->ws->utf8 && !n) {
|
|
lwsl_info("FINAL utf8 error\n");
|
|
lws_close_reason(wsi, LWS_CLOSE_STATUS_INVALID_PAYLOAD,
|
|
(uint8_t *)"partial utf8", 12);
|
|
|
|
utf8_fail:
|
|
lwsl_info("utf8 error\n");
|
|
lwsl_hexdump_info(pmdrx.eb_out.token, pmdrx.eb_out.len);
|
|
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (wsi->protocol->callback && !wsi->wsistate_pre_close)
|
|
if (user_callback_handle_rxflow(wsi->protocol->callback, wsi,
|
|
LWS_CALLBACK_RECEIVE,
|
|
wsi->user_space,
|
|
pmdrx.eb_out.token,
|
|
pmdrx.eb_out.len))
|
|
return -1;
|
|
|
|
wsi->ws->first_fragment = 0;
|
|
|
|
#if !defined(LWS_WITHOUT_EXTENSIONS)
|
|
lwsl_info("%s: input used %d, output %d, rem len %d, rx_draining_ext %d\n",
|
|
__func__, avail, pmdrx.eb_out.len, (int)len,
|
|
wsi->ws->rx_draining_ext);
|
|
#endif
|
|
|
|
return avail; /* how much we used from the input */
|
|
}
|
|
|
|
|
|
int
|
|
lws_parse_ws(struct lws *wsi, unsigned char **buf, size_t len)
|
|
{
|
|
unsigned char *bufin = *buf;
|
|
int m, bulk = 0;
|
|
|
|
lwsl_debug("%s: received %d byte packet\n", __func__, (int)len);
|
|
|
|
//lwsl_hexdump_notice(*buf, len);
|
|
|
|
/* let the rx protocol state machine have as much as it needs */
|
|
|
|
while (len) {
|
|
/*
|
|
* we were accepting input but now we stopped doing so
|
|
*/
|
|
if (wsi->rxflow_bitmap) {
|
|
lwsl_info("%s: doing rxflow, caching %d\n", __func__,
|
|
(int)len);
|
|
/*
|
|
* Since we cached the remaining available input, we
|
|
* can say we "consumed" it.
|
|
*
|
|
* But what about the case where the available input
|
|
* came out of the rxflow cache already? If we are
|
|
* effectively "putting it back in the cache", we have
|
|
* leave it where it is, already pointed to by the head.
|
|
*/
|
|
if (lws_rxflow_cache(wsi, *buf, 0, (int)len) ==
|
|
LWSRXFC_TRIMMED) {
|
|
/*
|
|
* We dealt with it by trimming the existing
|
|
* rxflow cache HEAD to account for what we used.
|
|
*
|
|
* indicate we didn't use anything to the caller
|
|
* so he doesn't do any consumed processing
|
|
*/
|
|
lwsl_info("%s: trimming inside rxflow cache\n",
|
|
__func__);
|
|
*buf = bufin;
|
|
} else
|
|
*buf += len;
|
|
|
|
return 1;
|
|
}
|
|
#if !defined(LWS_WITHOUT_EXTENSIONS)
|
|
if (wsi->ws->rx_draining_ext) {
|
|
lwsl_debug("%s: draining rx ext\n", __func__);
|
|
m = lws_ws_rx_sm(wsi, ALREADY_PROCESSED_IGNORE_CHAR, 0);
|
|
if (m < 0)
|
|
return -1;
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
/* consume payload bytes efficiently */
|
|
while (wsi->lws_rx_parse_state == LWS_RXPS_WS_FRAME_PAYLOAD &&
|
|
(wsi->ws->opcode == LWSWSOPC_TEXT_FRAME ||
|
|
wsi->ws->opcode == LWSWSOPC_BINARY_FRAME ||
|
|
wsi->ws->opcode == LWSWSOPC_CONTINUATION) &&
|
|
len) {
|
|
uint8_t *bin = *buf;
|
|
|
|
bulk = 1;
|
|
m = lws_ws_frame_rest_is_payload(wsi, buf, len);
|
|
assert((int)lws_ptr_diff(*buf, bin) <= (int)len);
|
|
len -= lws_ptr_diff(*buf, bin);
|
|
|
|
if (!m) {
|
|
|
|
break;
|
|
}
|
|
if (m < 0) {
|
|
lwsl_info("%s: rest_is_payload bailed\n",
|
|
__func__);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (!bulk) {
|
|
/* process the byte */
|
|
m = lws_ws_rx_sm(wsi, 0, *(*buf)++);
|
|
len--;
|
|
} else {
|
|
/*
|
|
* We already handled this byte in bulk, just deal
|
|
* with the ramifications
|
|
*/
|
|
#if !defined(LWS_WITHOUT_EXTENSIONS)
|
|
lwsl_debug("%s: coming out of bulk with len %d, "
|
|
"wsi->ws->rx_draining_ext %d\n",
|
|
__func__, (int)len,
|
|
wsi->ws->rx_draining_ext);
|
|
#endif
|
|
m = lws_ws_rx_sm(wsi, ALREADY_PROCESSED_IGNORE_CHAR |
|
|
ALREADY_PROCESSED_NO_CB, 0);
|
|
}
|
|
|
|
if (m < 0) {
|
|
lwsl_info("%s: lws_ws_rx_sm bailed %d\n", __func__,
|
|
bulk);
|
|
|
|
return -1;
|
|
}
|
|
|
|
bulk = 0;
|
|
}
|
|
|
|
lwsl_debug("%s: exit with %d unused\n", __func__, (int)len);
|
|
|
|
return 0;
|
|
}
|