2010-11-08 20:20:42 +00:00
|
|
|
/*
|
|
|
|
|
* libwebsockets - small server side websockets and web server implementation
|
2010-11-13 10:03:47 +00:00
|
|
|
*
|
2013-01-18 11:43:21 +08:00
|
|
|
* Copyright (C) 2010-2013 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"
|
|
|
|
|
|
2013-01-18 01:55:48 +08:00
|
|
|
unsigned char lextable[] = {
|
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
|
|
|
#include "lextable.h"
|
2013-01-18 01:55:48 +08:00
|
|
|
};
|
|
|
|
|
|
2014-03-09 11:49:21 +08:00
|
|
|
#define FAIL_CHAR 0x08
|
|
|
|
|
|
2013-01-18 01:55:48 +08:00
|
|
|
int lextable_decode(int pos, char c)
|
|
|
|
|
{
|
|
|
|
|
|
2014-03-09 11:49:21 +08:00
|
|
|
c = tolower(c);
|
2013-01-18 01:55:48 +08:00
|
|
|
|
2014-03-09 11:49:21 +08:00
|
|
|
while (1) {
|
|
|
|
|
if (lextable[pos] & (1 << 7)) { /* 1-byte, fail on mismatch */
|
|
|
|
|
if ((lextable[pos] & 0x7f) != c)
|
|
|
|
|
return -1;
|
|
|
|
|
/* fall thru */
|
|
|
|
|
pos++;
|
|
|
|
|
if (lextable[pos] == FAIL_CHAR)
|
|
|
|
|
return -1;
|
|
|
|
|
return pos;
|
2014-04-02 19:45:42 +08:00
|
|
|
}
|
2014-08-22 19:38:17 +08:00
|
|
|
|
|
|
|
|
if (lextable[pos] == FAIL_CHAR)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2014-04-02 19:45:42 +08:00
|
|
|
/* b7 = 0, end or 3-byte */
|
|
|
|
|
if (lextable[pos] < FAIL_CHAR) /* terminal marker */
|
|
|
|
|
return pos;
|
2014-03-09 11:49:21 +08:00
|
|
|
|
2014-04-02 19:45:42 +08:00
|
|
|
if (lextable[pos] == c) /* goto */
|
|
|
|
|
return pos + (lextable[pos + 1]) +
|
2014-03-09 11:49:21 +08:00
|
|
|
(lextable[pos + 2] << 8);
|
2014-04-02 19:45:42 +08:00
|
|
|
/* fall thru goto */
|
|
|
|
|
pos += 3;
|
|
|
|
|
/* continue */
|
2013-01-18 01:55: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
|
|
|
int lws_allocate_header_table(struct libwebsocket *wsi)
|
|
|
|
|
{
|
2014-11-07 15:28:35 -05:00
|
|
|
/* Be sure to free any existing header data to avoid mem leak: */
|
|
|
|
|
lws_free_header_table(wsi);
|
2014-12-04 23:59:35 +01:00
|
|
|
wsi->u.hdr.ah = lws_malloc(sizeof(*wsi->u.hdr.ah));
|
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 (wsi->u.hdr.ah == NULL) {
|
|
|
|
|
lwsl_err("Out of memory\n");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2013-02-11 17:13:32 +08:00
|
|
|
memset(wsi->u.hdr.ah->frag_index, 0, sizeof(wsi->u.hdr.ah->frag_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
|
|
|
wsi->u.hdr.ah->next_frag_index = 0;
|
|
|
|
|
wsi->u.hdr.ah->pos = 0;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-07 11:20:59 +08:00
|
|
|
int lws_free_header_table(struct libwebsocket *wsi)
|
|
|
|
|
{
|
2014-12-05 00:09:20 +01:00
|
|
|
lws_free2(wsi->u.hdr.ah);
|
|
|
|
|
wsi->u.hdr.ah = NULL;
|
2014-12-04 23:59:35 +01:00
|
|
|
return 0;
|
2014-11-07 11:20:59 +08:00
|
|
|
};
|
|
|
|
|
|
2013-03-30 09:52:21 +08:00
|
|
|
LWS_VISIBLE int lws_hdr_total_length(struct libwebsocket *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;
|
|
|
|
|
|
|
|
|
|
n = wsi->u.hdr.ah->frag_index[h];
|
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 {
|
|
|
|
|
len += wsi->u.hdr.ah->frags[n].len;
|
|
|
|
|
n = wsi->u.hdr.ah->frags[n].next_frag_index;
|
|
|
|
|
} while (n);
|
|
|
|
|
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-30 09:52:21 +08:00
|
|
|
LWS_VISIBLE int lws_hdr_copy(struct libwebsocket *wsi, char *dest, int len,
|
2013-02-11 17:13:32 +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;
|
|
|
|
|
|
|
|
|
|
n = wsi->u.hdr.ah->frag_index[h];
|
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 {
|
2013-02-11 17:13:32 +08:00
|
|
|
strcpy(dest,
|
|
|
|
|
&wsi->u.hdr.ah->data[wsi->u.hdr.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
|
|
|
dest += wsi->u.hdr.ah->frags[n].len;
|
|
|
|
|
n = wsi->u.hdr.ah->frags[n].next_frag_index;
|
|
|
|
|
} while (n);
|
|
|
|
|
|
|
|
|
|
return toklen;
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
char *lws_hdr_simple_ptr(struct libwebsocket *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;
|
|
|
|
|
|
|
|
|
|
n = wsi->u.hdr.ah->frag_index[h];
|
|
|
|
|
if (!n)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
return &wsi->u.hdr.ah->data[wsi->u.hdr.ah->frags[n].offset];
|
|
|
|
|
}
|
2013-01-18 01:55:48 +08:00
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
int lws_hdr_simple_create(struct libwebsocket *wsi,
|
|
|
|
|
enum lws_token_indexes h, const char *s)
|
2013-02-11 13:04:45 +08:00
|
|
|
{
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index++;
|
2013-02-11 17:13:32 +08:00
|
|
|
if (wsi->u.hdr.ah->next_frag_index ==
|
|
|
|
|
sizeof(wsi->u.hdr.ah->frags) / sizeof(wsi->u.hdr.ah->frags[0])) {
|
|
|
|
|
lwsl_warn("More hdr frags than we can deal with, dropping\n");
|
2013-02-11 13:04:45 +08:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
wsi->u.hdr.ah->frag_index[h] = wsi->u.hdr.ah->next_frag_index;
|
|
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].offset =
|
|
|
|
|
wsi->u.hdr.ah->pos;
|
2013-02-11 13:04:45 +08:00
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len = 0;
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].next_frag_index =
|
|
|
|
|
0;
|
2013-02-11 13:04:45 +08:00
|
|
|
|
|
|
|
|
do {
|
2013-02-11 17:13:32 +08:00
|
|
|
if (wsi->u.hdr.ah->pos == sizeof(wsi->u.hdr.ah->data)) {
|
2013-02-11 13:04:45 +08:00
|
|
|
lwsl_err("Ran out of header data space\n");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = *s;
|
|
|
|
|
if (*s)
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->u.hdr.ah->frags[
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index].len++;
|
2013-02-11 13:04:45 +08:00
|
|
|
} while (*s++);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-30 18:56:52 +08:00
|
|
|
static signed char char_to_hex(const char c)
|
2013-11-10 15:15:21 +08:00
|
|
|
{
|
|
|
|
|
if (c >= '0' && c <= '9')
|
|
|
|
|
return c - '0';
|
|
|
|
|
|
|
|
|
|
if (c >= 'a' && c <= 'f')
|
|
|
|
|
return c - 'a' + 10;
|
|
|
|
|
|
|
|
|
|
if (c >= 'A' && c <= 'F')
|
|
|
|
|
return c - 'A' + 10;
|
|
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-29 01:34:24 -04:00
|
|
|
static int issue_char(struct libwebsocket *wsi, unsigned char c)
|
2013-11-10 15:15:21 +08:00
|
|
|
{
|
|
|
|
|
if (wsi->u.hdr.ah->pos == sizeof(wsi->u.hdr.ah->data)) {
|
|
|
|
|
lwsl_warn("excessive header content\n");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2014-06-29 00:25:19 -04:00
|
|
|
|
2014-06-29 01:34:24 -04:00
|
|
|
if( wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len >=
|
|
|
|
|
wsi->u.hdr.current_token_limit) {
|
2014-06-29 00:25:19 -04:00
|
|
|
lwsl_warn("header %i exceeds limit\n", wsi->u.hdr.parser_state);
|
|
|
|
|
return 1;
|
|
|
|
|
};
|
|
|
|
|
|
2013-11-10 15:15:21 +08:00
|
|
|
wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = c;
|
|
|
|
|
if (c)
|
|
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len++;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-29 00:25:19 -04:00
|
|
|
int libwebsocket_parse(
|
|
|
|
|
struct libwebsocket_context *context,
|
|
|
|
|
struct libwebsocket *wsi, unsigned char c)
|
2010-11-08 20:20:42 +00:00
|
|
|
{
|
2015-01-10 19:01:52 -08:00
|
|
|
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,
|
|
|
|
|
};
|
|
|
|
|
int n, m;
|
2010-11-08 20:20:42 +00:00
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
switch (wsi->u.hdr.parser_state) {
|
2014-09-30 16:33:56 +08:00
|
|
|
default:
|
2011-05-23 10:00:03 +01:00
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
lwsl_parser("WSI_TOK_(%d) '%c'\n", wsi->u.hdr.parser_state, c);
|
2010-11-08 20:20:42 +00:00
|
|
|
|
|
|
|
|
/* collect into malloc'd buffers */
|
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
|
|
|
/* optional initial space swallow */
|
2013-02-11 17:13:32 +08:00
|
|
|
if (!wsi->u.hdr.ah->frags[wsi->u.hdr.ah->frag_index[
|
|
|
|
|
wsi->u.hdr.parser_state]].len && c == ' ')
|
2010-11-08 20:20:42 +00:00
|
|
|
break;
|
2010-11-13 10:03:47 +00:00
|
|
|
|
2015-01-10 19:01:52 -08:00
|
|
|
for (m = 0; m < ARRAY_SIZE(methods); m++)
|
|
|
|
|
if (wsi->u.hdr.parser_state == methods[m])
|
|
|
|
|
break;
|
|
|
|
|
if (m == ARRAY_SIZE(methods))
|
|
|
|
|
/* it was not any of the methods */
|
2013-11-10 15:15:21 +08:00
|
|
|
goto check_eol;
|
|
|
|
|
|
|
|
|
|
/* special URI processing... end at space */
|
|
|
|
|
|
|
|
|
|
if (c == ' ') {
|
|
|
|
|
/* enforce starting with / */
|
|
|
|
|
if (!wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len)
|
2014-06-29 01:34:24 -04:00
|
|
|
if (issue_char(wsi, '/') < 0)
|
2013-11-10 15:15:21 +08:00
|
|
|
return -1;
|
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
|
|
|
|
|
|
|
|
/* begin parsing HTTP version: */
|
|
|
|
|
if (issue_char(wsi, '\0') < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_HTTP;
|
|
|
|
|
goto start_fragment;
|
2010-11-08 20:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2013-11-10 15:15:21 +08:00
|
|
|
/* special URI processing... convert %xx */
|
|
|
|
|
|
|
|
|
|
switch (wsi->u.hdr.ues) {
|
|
|
|
|
case URIES_IDLE:
|
|
|
|
|
if (c == '%') {
|
|
|
|
|
wsi->u.hdr.ues = URIES_SEEN_PERCENT;
|
|
|
|
|
goto swallow;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case URIES_SEEN_PERCENT:
|
|
|
|
|
if (char_to_hex(c) < 0) {
|
|
|
|
|
/* regurgitate */
|
2014-06-29 01:34:24 -04:00
|
|
|
if (issue_char(wsi, '%') < 0)
|
2013-11-10 15:15:21 +08:00
|
|
|
return -1;
|
|
|
|
|
wsi->u.hdr.ues = URIES_IDLE;
|
|
|
|
|
/* continue on to assess c */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
wsi->u.hdr.esc_stash = c;
|
|
|
|
|
wsi->u.hdr.ues = URIES_SEEN_PERCENT_H1;
|
2013-11-11 06:14:52 +08:00
|
|
|
goto swallow;
|
2013-11-10 15:15:21 +08:00
|
|
|
|
|
|
|
|
case URIES_SEEN_PERCENT_H1:
|
|
|
|
|
if (char_to_hex(c) < 0) {
|
|
|
|
|
/* regurgitate */
|
2014-06-29 01:34:24 -04:00
|
|
|
issue_char(wsi, '%');
|
2013-11-10 15:15:21 +08:00
|
|
|
wsi->u.hdr.ues = URIES_IDLE;
|
|
|
|
|
/* regurgitate + assess */
|
2014-06-29 00:25:19 -04:00
|
|
|
if (libwebsocket_parse(context, wsi, wsi->u.hdr.esc_stash) < 0)
|
2013-11-10 15:15:21 +08:00
|
|
|
return -1;
|
|
|
|
|
/* continue on to assess c */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
c = (char_to_hex(wsi->u.hdr.esc_stash) << 4) |
|
|
|
|
|
char_to_hex(c);
|
2013-11-11 06:14:52 +08:00
|
|
|
wsi->u.hdr.ues = URIES_IDLE;
|
2013-11-10 15:15:21 +08:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* special URI processing...
|
2013-11-11 06:14:52 +08:00
|
|
|
* convert /.. or /... or /../ etc to /
|
|
|
|
|
* convert /./ to /
|
2013-11-10 15:15:21 +08:00
|
|
|
* convert // or /// etc to /
|
|
|
|
|
* leave /.dir or whatever alone
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
switch (wsi->u.hdr.ups) {
|
|
|
|
|
case URIPS_IDLE:
|
|
|
|
|
/* issue the first / always */
|
|
|
|
|
if (c == '/')
|
|
|
|
|
wsi->u.hdr.ups = URIPS_SEEN_SLASH;
|
|
|
|
|
break;
|
|
|
|
|
case URIPS_SEEN_SLASH:
|
|
|
|
|
/* swallow subsequent slashes */
|
|
|
|
|
if (c == '/')
|
|
|
|
|
goto swallow;
|
|
|
|
|
/* track and swallow the first . after / */
|
|
|
|
|
if (c == '.') {
|
|
|
|
|
wsi->u.hdr.ups = URIPS_SEEN_SLASH_DOT;
|
|
|
|
|
goto swallow;
|
2014-08-19 18:34:31 +08:00
|
|
|
}
|
|
|
|
|
wsi->u.hdr.ups = URIPS_IDLE;
|
2013-11-10 15:15:21 +08:00
|
|
|
break;
|
|
|
|
|
case URIPS_SEEN_SLASH_DOT:
|
|
|
|
|
/* swallow second . */
|
|
|
|
|
if (c == '.') {
|
2013-11-13 06:53:21 +08:00
|
|
|
/*
|
|
|
|
|
* back up one dir level if possible
|
|
|
|
|
* safe against header fragmentation because
|
|
|
|
|
* the method URI can only be in 1 fragment
|
|
|
|
|
*/
|
|
|
|
|
if (wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len > 2) {
|
|
|
|
|
wsi->u.hdr.ah->pos--;
|
|
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len--;
|
|
|
|
|
do {
|
|
|
|
|
wsi->u.hdr.ah->pos--;
|
|
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len--;
|
|
|
|
|
} while (wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len > 1 &&
|
|
|
|
|
wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos] != '/');
|
|
|
|
|
}
|
2013-11-10 15:15:21 +08:00
|
|
|
wsi->u.hdr.ups = URIPS_SEEN_SLASH_DOT_DOT;
|
|
|
|
|
goto swallow;
|
|
|
|
|
}
|
2013-11-11 06:14:52 +08:00
|
|
|
/* change /./ to / */
|
|
|
|
|
if (c == '/') {
|
|
|
|
|
wsi->u.hdr.ups = URIPS_SEEN_SLASH;
|
|
|
|
|
goto swallow;
|
|
|
|
|
}
|
2013-11-10 15:15:21 +08:00
|
|
|
/* it was like /.dir ... regurgitate the . */
|
|
|
|
|
wsi->u.hdr.ups = URIPS_IDLE;
|
2014-06-29 01:34:24 -04:00
|
|
|
issue_char(wsi, '.');
|
2013-11-10 15:15:21 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case URIPS_SEEN_SLASH_DOT_DOT:
|
|
|
|
|
/* swallow prior .. chars and any subsequent . */
|
|
|
|
|
if (c == '.')
|
|
|
|
|
goto swallow;
|
2013-11-11 06:14:52 +08:00
|
|
|
/* last issued was /, so another / == // */
|
|
|
|
|
if (c == '/')
|
|
|
|
|
goto swallow;
|
2014-08-19 18:34:31 +08:00
|
|
|
/* last we issued was / so SEEN_SLASH */
|
|
|
|
|
wsi->u.hdr.ups = URIPS_SEEN_SLASH;
|
2013-11-10 15:15:21 +08:00
|
|
|
break;
|
2013-11-13 07:45:17 +08:00
|
|
|
case URIPS_ARGUMENTS:
|
|
|
|
|
/* leave them alone */
|
|
|
|
|
break;
|
2013-11-10 15:15:21 +08:00
|
|
|
}
|
|
|
|
|
|
2013-11-13 07:45:17 +08:00
|
|
|
if (c == '?') { /* start of URI arguments */
|
|
|
|
|
/* seal off uri header */
|
|
|
|
|
wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = '\0';
|
|
|
|
|
|
|
|
|
|
/* move to using WSI_TOKEN_HTTP_URI_ARGS */
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index++;
|
|
|
|
|
wsi->u.hdr.ah->frags[
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index].offset =
|
|
|
|
|
wsi->u.hdr.ah->pos;
|
|
|
|
|
wsi->u.hdr.ah->frags[
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index].len = 0;
|
|
|
|
|
wsi->u.hdr.ah->frags[
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index].next_frag_index = 0;
|
|
|
|
|
|
|
|
|
|
wsi->u.hdr.ah->frag_index[WSI_TOKEN_HTTP_URI_ARGS] =
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index;
|
|
|
|
|
|
|
|
|
|
/* defeat normal uri path processing */
|
|
|
|
|
wsi->u.hdr.ups = URIPS_ARGUMENTS;
|
|
|
|
|
goto swallow;
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-19 06:58:53 +08:00
|
|
|
check_eol:
|
|
|
|
|
|
|
|
|
|
/* bail at EOL */
|
|
|
|
|
if (wsi->u.hdr.parser_state != WSI_TOKEN_CHALLENGE &&
|
|
|
|
|
c == '\x0d') {
|
|
|
|
|
c = '\0';
|
|
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
|
|
|
|
|
lwsl_parser("*\n");
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-19 18:34:31 +08:00
|
|
|
n = issue_char(wsi, c);
|
|
|
|
|
if (n < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
if (n > 0)
|
|
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
|
|
|
|
|
|
2013-11-10 15:15:21 +08:00
|
|
|
swallow:
|
2011-01-18 15:39:02 +00:00
|
|
|
/* per-protocol end of headers management */
|
|
|
|
|
|
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 (wsi->u.hdr.parser_state == WSI_TOKEN_CHALLENGE)
|
|
|
|
|
goto set_parsing_complete;
|
2011-05-23 10:00:03 +01:00
|
|
|
break;
|
|
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
/* collecting and checking a name part */
|
|
|
|
|
case WSI_TOKEN_NAME_PART:
|
2015-04-07 08:19:30 +08:00
|
|
|
lwsl_parser("WSI_TOKEN_NAME_PART '%c' (mode=%d)\n", c, wsi->mode);
|
2010-11-08 20:20:42 +00:00
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->u.hdr.lextable_pos =
|
|
|
|
|
lextable_decode(wsi->u.hdr.lextable_pos, c);
|
2015-04-07 08:19:30 +08:00
|
|
|
/*
|
|
|
|
|
* Server needs to look out for unknown methods...
|
|
|
|
|
*/
|
|
|
|
|
if (wsi->u.hdr.lextable_pos < 0 &&
|
|
|
|
|
wsi->mode == LWS_CONNMODE_HTTP_SERVING) {
|
2013-02-04 09:24:18 +08:00
|
|
|
/* this is not a header we know about */
|
2015-01-10 19:01:52 -08:00
|
|
|
for (m = 0; m < ARRAY_SIZE(methods); m++)
|
|
|
|
|
if (wsi->u.hdr.ah->frag_index[methods[m]]) {
|
|
|
|
|
/*
|
|
|
|
|
* already had the method, no idea what
|
2015-04-07 08:19:30 +08:00
|
|
|
* this crap from the client is, ignore
|
2015-01-10 19:01:52 -08:00
|
|
|
*/
|
|
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2013-02-12 12:52:39 +08:00
|
|
|
/*
|
2015-04-07 08:19:30 +08:00
|
|
|
* hm it's an unknown http method from a client in fact,
|
2013-02-12 12:52:39 +08:00
|
|
|
* treat as dangerous
|
|
|
|
|
*/
|
2015-01-30 12:04:43 +00:00
|
|
|
if (m == ARRAY_SIZE(methods)) {
|
|
|
|
|
lwsl_info("Unknown method - dropping\n");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2013-02-04 09:24:18 +08:00
|
|
|
}
|
2015-04-07 08:19:30 +08:00
|
|
|
/*
|
|
|
|
|
* ...otherwise for a client, let him ignore unknown headers
|
|
|
|
|
* coming from the server
|
|
|
|
|
*/
|
|
|
|
|
if (wsi->u.hdr.lextable_pos < 0) {
|
|
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-09 11:49:21 +08:00
|
|
|
if (lextable[wsi->u.hdr.lextable_pos] < FAIL_CHAR) {
|
2013-02-04 09:24:18 +08:00
|
|
|
/* terminal state */
|
|
|
|
|
|
2014-11-30 12:36:09 +08:00
|
|
|
n = ((unsigned int)lextable[wsi->u.hdr.lextable_pos] << 8) |
|
|
|
|
|
lextable[wsi->u.hdr.lextable_pos + 1];
|
2013-01-18 01:55:48 +08:00
|
|
|
|
2013-02-18 10:22:42 +08:00
|
|
|
lwsl_parser("known hdr %d\n", n);
|
2015-01-10 19:01:52 -08:00
|
|
|
for (m = 0; m < ARRAY_SIZE(methods); m++)
|
|
|
|
|
if (n == methods[m] &&
|
|
|
|
|
wsi->u.hdr.ah->frag_index[
|
|
|
|
|
methods[m]]) {
|
|
|
|
|
lwsl_warn("Duplicated method\n");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2013-02-12 13:10:19 +08:00
|
|
|
|
2012-04-03 17:02:20 +02:00
|
|
|
/*
|
|
|
|
|
* WSORIGIN is protocol equiv to ORIGIN,
|
|
|
|
|
* JWebSocket likes to send it, map to ORIGIN
|
|
|
|
|
*/
|
|
|
|
|
if (n == WSI_TOKEN_SWORIGIN)
|
|
|
|
|
n = WSI_TOKEN_ORIGIN;
|
|
|
|
|
|
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
|
|
|
wsi->u.hdr.parser_state = (enum lws_token_indexes)
|
|
|
|
|
(WSI_TOKEN_GET_URI + n);
|
2014-06-29 01:34:24 -04:00
|
|
|
|
2014-08-22 19:38:17 +08:00
|
|
|
if (context->token_limits)
|
|
|
|
|
wsi->u.hdr.current_token_limit =
|
2014-06-29 01:34:24 -04:00
|
|
|
context->token_limits->token_limit[wsi->u.hdr.parser_state];
|
2014-08-22 19:38:17 +08:00
|
|
|
else
|
2014-06-29 01:34:24 -04:00
|
|
|
wsi->u.hdr.current_token_limit = sizeof(wsi->u.hdr.ah->data);
|
|
|
|
|
|
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 (wsi->u.hdr.parser_state == WSI_TOKEN_CHALLENGE)
|
|
|
|
|
goto set_parsing_complete;
|
2011-01-23 16:50:33 +00: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
|
|
|
goto start_fragment;
|
|
|
|
|
}
|
|
|
|
|
break;
|
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:
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index++;
|
2013-02-11 17:13:32 +08:00
|
|
|
if (wsi->u.hdr.ah->next_frag_index ==
|
|
|
|
|
sizeof(wsi->u.hdr.ah->frags) /
|
|
|
|
|
sizeof(wsi->u.hdr.ah->frags[0])) {
|
|
|
|
|
lwsl_warn("More hdr frags than we can deal with\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 -1;
|
2010-11-08 20:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].offset =
|
|
|
|
|
wsi->u.hdr.ah->pos;
|
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
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len = 0;
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->u.hdr.ah->frags[
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index].next_frag_index = 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
|
|
|
|
|
|
|
|
n = wsi->u.hdr.ah->frag_index[wsi->u.hdr.parser_state];
|
|
|
|
|
if (!n) { /* first fragment */
|
|
|
|
|
wsi->u.hdr.ah->frag_index[wsi->u.hdr.parser_state] =
|
|
|
|
|
wsi->u.hdr.ah->next_frag_index;
|
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;
|
|
|
|
|
}
|
|
|
|
|
/* continuation */
|
|
|
|
|
while (wsi->u.hdr.ah->frags[n].next_frag_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
|
|
|
n = wsi->u.hdr.ah->frags[n].next_frag_index;
|
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
|
|
|
wsi->u.hdr.ah->frags[n].next_frag_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
|
|
|
wsi->u.hdr.ah->next_frag_index;
|
|
|
|
|
|
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
|
|
|
if (wsi->u.hdr.ah->pos == sizeof(wsi->u.hdr.ah->data)) {
|
|
|
|
|
lwsl_warn("excessive header content\n");
|
|
|
|
|
return -1;
|
2013-02-06 15:15:25 +09:00
|
|
|
}
|
2011-01-22 12:51:57 +00:00
|
|
|
|
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
|
|
|
wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = ' ';
|
|
|
|
|
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len++;
|
2013-02-04 09:24:18 +08:00
|
|
|
break;
|
2010-11-13 10:03:47 +00:00
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
/* skipping arg part of a name we didn't recognize */
|
|
|
|
|
case WSI_TOKEN_SKIPPING:
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("WSI_TOKEN_SKIPPING '%c'\n", c);
|
2013-11-19 13:38:16 +01:00
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
if (c == '\x0d')
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
|
2010-11-08 20:20:42 +00:00
|
|
|
break;
|
2013-02-04 09:09:19 +08:00
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
case WSI_TOKEN_SKIPPING_SAW_CR:
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("WSI_TOKEN_SKIPPING_SAW_CR '%c'\n", c);
|
2013-01-18 01:55:48 +08:00
|
|
|
if (c == '\x0a') {
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_NAME_PART;
|
|
|
|
|
wsi->u.hdr.lextable_pos = 0;
|
2013-01-18 01:55:48 +08:00
|
|
|
} else
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
|
2010-11-08 20:20:42 +00:00
|
|
|
break;
|
|
|
|
|
/* we're done, ignore anything else */
|
2013-11-19 13:38:16 +01:00
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
case WSI_PARSING_COMPLETE:
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("WSI_PARSING_COMPLETE '%c'\n", c);
|
2010-11-08 20:20:42 +00:00
|
|
|
break;
|
|
|
|
|
}
|
2010-11-13 10:03:47 +00:00
|
|
|
|
2013-02-04 09:09:19 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
set_parsing_complete:
|
|
|
|
|
|
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)) {
|
2013-02-11 17:13:32 +08:00
|
|
|
if (lws_hdr_total_length(wsi, WSI_TOKEN_VERSION))
|
2013-02-06 15:15:25 +09:00
|
|
|
wsi->ietf_spec_revision =
|
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));
|
2013-02-04 09:09:19 +08:00
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
lwsl_parser("v%02d hdrs completed\n", wsi->ietf_spec_revision);
|
2013-02-06 15:15:25 +09:00
|
|
|
}
|
2013-02-04 09:09:19 +08:00
|
|
|
wsi->u.hdr.parser_state = WSI_PARSING_COMPLETE;
|
2013-02-11 21:43:41 +08:00
|
|
|
wsi->hdr_parsing_completed = 1;
|
2013-02-04 09:09:19 +08:00
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-09 08:49:14 +00:00
|
|
|
|
2013-01-18 09:49:20 +08:00
|
|
|
/**
|
|
|
|
|
* lws_frame_is_binary: true if the current frame was sent in binary mode
|
|
|
|
|
*
|
|
|
|
|
* @wsi: the connection we are inquiring about
|
|
|
|
|
*
|
|
|
|
|
* This is intended to be called from the LWS_CALLBACK_RECEIVE callback if
|
|
|
|
|
* it's interested to see if the frame it's dealing with was sent in binary
|
|
|
|
|
* mode.
|
|
|
|
|
*/
|
|
|
|
|
|
2013-03-30 09:52:21 +08:00
|
|
|
LWS_VISIBLE int lws_frame_is_binary(struct libwebsocket *wsi)
|
2013-01-18 09:49:20 +08:00
|
|
|
{
|
2013-01-21 11:04:23 +08:00
|
|
|
return wsi->u.ws.frame_is_binary;
|
2013-01-18 09:49:20 +08:00
|
|
|
}
|
2011-02-09 08:49:14 +00:00
|
|
|
|
2011-05-23 10:00:03 +01:00
|
|
|
int
|
|
|
|
|
libwebsocket_rx_sm(struct libwebsocket *wsi, unsigned char c)
|
2010-11-08 20:20:42 +00:00
|
|
|
{
|
2011-05-23 10:00:03 +01:00
|
|
|
struct lws_tokens eff_buf;
|
2013-02-10 21:21:24 +08:00
|
|
|
int ret = 0;
|
2015-10-05 11:35:52 +01:00
|
|
|
int callback_action = LWS_CALLBACK_RECEIVE;
|
2010-11-08 20:20:42 +00:00
|
|
|
|
|
|
|
|
switch (wsi->lws_rx_parse_state) {
|
|
|
|
|
case LWS_RXPS_NEW:
|
2010-11-13 10:03:47 +00:00
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
switch (wsi->ietf_spec_revision) {
|
2011-09-25 09:32:54 +01:00
|
|
|
case 13:
|
2011-04-24 05:46:23 +01:00
|
|
|
/*
|
|
|
|
|
* no prepended frame key any more
|
|
|
|
|
*/
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.all_zero_nonce = 1;
|
2011-04-24 05:46:23 +01:00
|
|
|
goto handle_first;
|
|
|
|
|
|
2011-02-09 08:49:14 +00:00
|
|
|
default:
|
2013-02-11 17:13:32 +08:00
|
|
|
lwsl_warn("lws_rx_sm: unknown spec version %d\n",
|
|
|
|
|
wsi->ietf_spec_revision);
|
2011-02-09 08:49:14 +00:00
|
|
|
break;
|
2010-11-08 20:20:42 +00:00
|
|
|
}
|
2010-11-11 09:22:22 +00:00
|
|
|
break;
|
2011-01-18 18:14:26 +00:00
|
|
|
case LWS_RXPS_04_MASK_NONCE_1:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_masking_nonce_04[1] = c;
|
2011-02-10 09:22:35 +00:00
|
|
|
if (c)
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.all_zero_nonce = 0;
|
2011-01-18 18:14:26 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_MASK_NONCE_2;
|
|
|
|
|
break;
|
|
|
|
|
case LWS_RXPS_04_MASK_NONCE_2:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_masking_nonce_04[2] = c;
|
2011-02-10 09:22:35 +00:00
|
|
|
if (c)
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.all_zero_nonce = 0;
|
2011-01-18 18:14:26 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_MASK_NONCE_3;
|
|
|
|
|
break;
|
|
|
|
|
case LWS_RXPS_04_MASK_NONCE_3:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_masking_nonce_04[3] = c;
|
2011-02-10 09:22:35 +00:00
|
|
|
if (c)
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.all_zero_nonce = 0;
|
2011-01-18 18:14:26 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* start from the zero'th byte in the XOR key buffer since
|
|
|
|
|
* this is the start of a frame with a new key
|
|
|
|
|
*/
|
|
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_mask_index = 0;
|
2011-01-23 16:50:33 +00:00
|
|
|
|
2011-01-18 18:14:26 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_1;
|
|
|
|
|
break;
|
2011-01-19 12:20:27 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 04 logical framing from the spec (all this is masked when incoming
|
|
|
|
|
* and has to be unmasked)
|
|
|
|
|
*
|
|
|
|
|
* We ignore the possibility of extension data because we don't
|
|
|
|
|
* negotiate any extensions at the moment.
|
2011-01-23 16:50:33 +00:00
|
|
|
*
|
2011-01-19 12:20:27 +00:00
|
|
|
* 0 1 2 3
|
|
|
|
|
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
|
|
|
|
* +-+-+-+-+-------+-+-------------+-------------------------------+
|
|
|
|
|
* |F|R|R|R| opcode|R| Payload len | Extended payload length |
|
|
|
|
|
* |I|S|S|S| (4) |S| (7) | (16/63) |
|
|
|
|
|
* |N|V|V|V| |V| | (if payload len==126/127) |
|
|
|
|
|
* | |1|2|3| |4| | |
|
|
|
|
|
* +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
|
|
|
|
|
* | Extended payload length continued, if payload len == 127 |
|
|
|
|
|
* + - - - - - - - - - - - - - - - +-------------------------------+
|
|
|
|
|
* | | Extension data |
|
|
|
|
|
* +-------------------------------+ - - - - - - - - - - - - - - - +
|
|
|
|
|
* : :
|
|
|
|
|
* +---------------------------------------------------------------+
|
|
|
|
|
* : Application data :
|
|
|
|
|
* +---------------------------------------------------------------+
|
|
|
|
|
*
|
|
|
|
|
* We pass payload through to userland as soon as we get it, ignoring
|
|
|
|
|
* FIN. It's up to userland to buffer it up if it wants to see a
|
|
|
|
|
* whole unfragmented block of the original size (which may be up to
|
|
|
|
|
* 2^63 long!)
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_1:
|
2011-04-24 05:46:23 +01:00
|
|
|
handle_first:
|
|
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.opcode = c & 0xf;
|
|
|
|
|
wsi->u.ws.rsv = c & 0x70;
|
|
|
|
|
wsi->u.ws.final = !!((c >> 7) & 1);
|
2013-02-28 17:11:29 +08:00
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
switch (wsi->u.ws.opcode) {
|
2013-01-19 10:39:35 +08:00
|
|
|
case LWS_WS_OPCODE_07__TEXT_FRAME:
|
|
|
|
|
case LWS_WS_OPCODE_07__BINARY_FRAME:
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->u.ws.frame_is_binary =
|
|
|
|
|
wsi->u.ws.opcode == LWS_WS_OPCODE_07__BINARY_FRAME;
|
2013-01-19 10:39:35 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN:
|
|
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.this_frame_masked = !!(c & 0x80);
|
2011-04-24 05:46:23 +01:00
|
|
|
|
2011-09-25 10:46:31 +01:00
|
|
|
switch (c & 0x7f) {
|
2011-01-19 12:20:27 +00:00
|
|
|
case 126:
|
|
|
|
|
/* control frames are not allowed to have big lengths */
|
2013-01-21 11:04:23 +08:00
|
|
|
if (wsi->u.ws.opcode & 8)
|
2011-04-24 06:19:22 +01:00
|
|
|
goto illegal_ctl_length;
|
|
|
|
|
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN16_2;
|
|
|
|
|
break;
|
|
|
|
|
case 127:
|
|
|
|
|
/* control frames are not allowed to have big lengths */
|
2013-01-21 11:04:23 +08:00
|
|
|
if (wsi->u.ws.opcode & 8)
|
2011-04-24 06:19:22 +01:00
|
|
|
goto illegal_ctl_length;
|
|
|
|
|
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_8;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length = c & 0x7f;
|
|
|
|
|
if (wsi->u.ws.this_frame_masked)
|
2011-04-24 05:46:23 +01:00
|
|
|
wsi->lws_rx_parse_state =
|
|
|
|
|
LWS_RXPS_07_COLLECT_FRAME_KEY_1;
|
|
|
|
|
else
|
2014-02-15 16:00:37 +08:00
|
|
|
if (wsi->u.ws.rx_packet_length)
|
|
|
|
|
wsi->lws_rx_parse_state =
|
2011-01-19 12:20:27 +00:00
|
|
|
LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED;
|
2014-02-15 16:00:37 +08:00
|
|
|
else {
|
|
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_NEW;
|
|
|
|
|
goto spill;
|
|
|
|
|
}
|
2011-01-19 12:20:27 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN16_2:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length = c << 8;
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN16_1;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN16_1:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length |= c;
|
|
|
|
|
if (wsi->u.ws.this_frame_masked)
|
2011-04-24 05:46:23 +01:00
|
|
|
wsi->lws_rx_parse_state =
|
|
|
|
|
LWS_RXPS_07_COLLECT_FRAME_KEY_1;
|
|
|
|
|
else
|
|
|
|
|
wsi->lws_rx_parse_state =
|
|
|
|
|
LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED;
|
2011-01-19 12:20:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN64_8:
|
|
|
|
|
if (c & 0x80) {
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_warn("b63 of length must be zero\n");
|
2011-01-19 12:20:27 +00:00
|
|
|
/* kill the connection */
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2011-01-27 06:45:53 +00:00
|
|
|
#if defined __LP64__
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length = ((size_t)c) << 56;
|
2011-01-27 06:45:53 +00:00
|
|
|
#else
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length = 0;
|
2011-01-27 06:45:53 +00:00
|
|
|
#endif
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_7;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN64_7:
|
2011-01-27 06:45:53 +00:00
|
|
|
#if defined __LP64__
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length |= ((size_t)c) << 48;
|
2011-01-27 06:45:53 +00:00
|
|
|
#endif
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_6;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN64_6:
|
2011-01-27 06:45:53 +00:00
|
|
|
#if defined __LP64__
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length |= ((size_t)c) << 40;
|
2011-01-27 06:45:53 +00:00
|
|
|
#endif
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_5;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN64_5:
|
2011-01-27 06:45:53 +00:00
|
|
|
#if defined __LP64__
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length |= ((size_t)c) << 32;
|
2011-01-27 06:45:53 +00:00
|
|
|
#endif
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_4;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN64_4:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length |= ((size_t)c) << 24;
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_3;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN64_3:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length |= ((size_t)c) << 16;
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN64_2:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length |= ((size_t)c) << 8;
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_1;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_04_FRAME_HDR_LEN64_1:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_packet_length |= ((size_t)c);
|
|
|
|
|
if (wsi->u.ws.this_frame_masked)
|
2011-04-24 05:46:23 +01:00
|
|
|
wsi->lws_rx_parse_state =
|
|
|
|
|
LWS_RXPS_07_COLLECT_FRAME_KEY_1;
|
|
|
|
|
else
|
|
|
|
|
wsi->lws_rx_parse_state =
|
|
|
|
|
LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED;
|
2011-01-19 12:20:27 +00:00
|
|
|
break;
|
|
|
|
|
|
2011-04-24 05:46:23 +01:00
|
|
|
case LWS_RXPS_07_COLLECT_FRAME_KEY_1:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_masking_nonce_04[0] = c;
|
2011-04-24 05:46:23 +01:00
|
|
|
if (c)
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.all_zero_nonce = 0;
|
2011-04-24 05:46:23 +01:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_07_COLLECT_FRAME_KEY_2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_07_COLLECT_FRAME_KEY_2:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_masking_nonce_04[1] = c;
|
2011-04-24 05:46:23 +01:00
|
|
|
if (c)
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.all_zero_nonce = 0;
|
2011-04-24 05:46:23 +01:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_07_COLLECT_FRAME_KEY_3;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_07_COLLECT_FRAME_KEY_3:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_masking_nonce_04[2] = c;
|
2011-04-24 05:46:23 +01:00
|
|
|
if (c)
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.all_zero_nonce = 0;
|
2011-04-24 05:46:23 +01:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_07_COLLECT_FRAME_KEY_4;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LWS_RXPS_07_COLLECT_FRAME_KEY_4:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_masking_nonce_04[3] = c;
|
2011-04-24 05:46:23 +01:00
|
|
|
if (c)
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.all_zero_nonce = 0;
|
2011-04-24 05:46:23 +01:00
|
|
|
wsi->lws_rx_parse_state =
|
|
|
|
|
LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED;
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.frame_mask_index = 0;
|
2014-02-15 16:00:37 +08:00
|
|
|
if (wsi->u.ws.rx_packet_length == 0) {
|
|
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_NEW;
|
2013-02-28 17:11:29 +08:00
|
|
|
goto spill;
|
2014-02-15 16:00:37 +08:00
|
|
|
}
|
2011-04-24 05:46:23 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
case LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED:
|
2013-01-20 17:08:31 +08:00
|
|
|
|
2014-11-30 12:53:27 +08:00
|
|
|
if (!wsi->u.ws.rx_user_buffer) {
|
2013-02-06 21:10:16 +09:00
|
|
|
lwsl_err("NULL user buffer...\n");
|
2014-11-30 12:53:27 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
2013-02-06 21:10:16 +09:00
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
if (wsi->u.ws.all_zero_nonce)
|
|
|
|
|
wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING +
|
|
|
|
|
(wsi->u.ws.rx_user_buffer_head++)] = c;
|
2011-02-10 09:22:35 +00:00
|
|
|
else
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING +
|
|
|
|
|
(wsi->u.ws.rx_user_buffer_head++)] =
|
2013-02-11 17:13:32 +08:00
|
|
|
c ^ wsi->u.ws.frame_masking_nonce_04[
|
|
|
|
|
(wsi->u.ws.frame_mask_index++) & 3];
|
2011-01-22 12:51:57 +00:00
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
if (--wsi->u.ws.rx_packet_length == 0) {
|
2013-02-14 11:25:44 +08:00
|
|
|
/* spill because we have the whole frame */
|
2011-01-19 12:20:27 +00:00
|
|
|
wsi->lws_rx_parse_state = LWS_RXPS_NEW;
|
|
|
|
|
goto spill;
|
|
|
|
|
}
|
2013-02-14 11:25:44 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* if there's no protocol max frame size given, we are
|
|
|
|
|
* supposed to default to LWS_MAX_SOCKET_IO_BUF
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (!wsi->protocol->rx_buffer_size &&
|
|
|
|
|
wsi->u.ws.rx_user_buffer_head !=
|
|
|
|
|
LWS_MAX_SOCKET_IO_BUF)
|
2011-01-19 12:20:27 +00:00
|
|
|
break;
|
2013-02-14 11:25:44 +08:00
|
|
|
else
|
|
|
|
|
if (wsi->protocol->rx_buffer_size &&
|
|
|
|
|
wsi->u.ws.rx_user_buffer_head !=
|
|
|
|
|
wsi->protocol->rx_buffer_size)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* spill because we filled our rx buffer */
|
2011-01-19 12:20:27 +00:00
|
|
|
spill:
|
|
|
|
|
/*
|
|
|
|
|
* is this frame a control packet we should take care of at this
|
|
|
|
|
* layer? If so service it and hide it from the user callback
|
|
|
|
|
*/
|
|
|
|
|
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("spill on %s\n", wsi->protocol->name);
|
2011-05-23 10:00:03 +01:00
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
switch (wsi->u.ws.opcode) {
|
2011-04-24 06:19:22 +01:00
|
|
|
case LWS_WS_OPCODE_07__CLOSE:
|
2011-03-07 07:08:12 +00:00
|
|
|
/* is this an acknowledgement of our close? */
|
|
|
|
|
if (wsi->state == WSI_STATE_AWAITING_CLOSE_ACK) {
|
|
|
|
|
/*
|
|
|
|
|
* fine he has told us he is closing too, let's
|
|
|
|
|
* finish our close
|
|
|
|
|
*/
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("seen client close ack\n");
|
2011-03-07 07:08:12 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
2015-04-17 20:29:58 +08:00
|
|
|
if (wsi->state == WSI_STATE_RETURNED_CLOSE_ALREADY)
|
|
|
|
|
/* if he sends us 2 CLOSE, kill him */
|
|
|
|
|
return -1;
|
|
|
|
|
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("server sees client close packet\n");
|
2011-02-10 09:07:05 +00:00
|
|
|
wsi->state = WSI_STATE_RETURNED_CLOSE_ALREADY;
|
2015-04-17 20:29:58 +08:00
|
|
|
/* deal with the close packet contents as a PONG */
|
|
|
|
|
wsi->u.ws.payload_is_close = 1;
|
|
|
|
|
goto process_as_ping;
|
2011-01-19 12:20:27 +00:00
|
|
|
|
2011-04-24 06:19:22 +01:00
|
|
|
case LWS_WS_OPCODE_07__PING:
|
2013-02-11 17:13:32 +08:00
|
|
|
lwsl_info("received %d byte ping, sending pong\n",
|
|
|
|
|
wsi->u.ws.rx_user_buffer_head);
|
2014-08-24 14:39:19 +08:00
|
|
|
|
2015-03-24 21:07:01 +08:00
|
|
|
if (wsi->u.ws.ping_pending_flag) {
|
2014-08-24 14:39:19 +08:00
|
|
|
/*
|
|
|
|
|
* there is already a pending ping payload
|
|
|
|
|
* we should just log and drop
|
|
|
|
|
*/
|
|
|
|
|
lwsl_parser("DROP PING since one pending\n");
|
|
|
|
|
goto ping_drop;
|
|
|
|
|
}
|
2015-04-17 20:29:58 +08:00
|
|
|
process_as_ping:
|
2014-08-24 14:39:19 +08:00
|
|
|
/* control packets can only be < 128 bytes long */
|
2015-03-24 21:22:52 +08:00
|
|
|
if (wsi->u.ws.rx_user_buffer_head > 128 - 4) {
|
2014-08-24 14:39:19 +08:00
|
|
|
lwsl_parser("DROP PING payload too large\n");
|
|
|
|
|
goto ping_drop;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* if existing buffer is too small, drop it */
|
|
|
|
|
if (wsi->u.ws.ping_payload_buf &&
|
|
|
|
|
wsi->u.ws.ping_payload_alloc < wsi->u.ws.rx_user_buffer_head) {
|
2014-12-05 00:09:20 +01:00
|
|
|
lws_free2(wsi->u.ws.ping_payload_buf);
|
2014-08-24 14:39:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* if no buffer, allocate it */
|
|
|
|
|
if (!wsi->u.ws.ping_payload_buf) {
|
2014-12-04 23:59:35 +01:00
|
|
|
wsi->u.ws.ping_payload_buf = lws_malloc(wsi->u.ws.rx_user_buffer_head
|
|
|
|
|
+ LWS_SEND_BUFFER_PRE_PADDING);
|
2014-08-24 14:39:19 +08:00
|
|
|
wsi->u.ws.ping_payload_alloc = wsi->u.ws.rx_user_buffer_head;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* stash the pong payload */
|
|
|
|
|
memcpy(wsi->u.ws.ping_payload_buf + LWS_SEND_BUFFER_PRE_PADDING,
|
|
|
|
|
&wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING],
|
|
|
|
|
wsi->u.ws.rx_user_buffer_head);
|
|
|
|
|
|
|
|
|
|
wsi->u.ws.ping_payload_len = wsi->u.ws.rx_user_buffer_head;
|
2015-03-24 21:07:01 +08:00
|
|
|
wsi->u.ws.ping_pending_flag = 1;
|
2014-08-24 14:39:19 +08:00
|
|
|
|
|
|
|
|
/* get it sent as soon as possible */
|
|
|
|
|
libwebsocket_callback_on_writable(wsi->protocol->owning_server, wsi);
|
|
|
|
|
ping_drop:
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_user_buffer_head = 0;
|
2011-01-27 20:06:03 +00:00
|
|
|
return 0;
|
2011-01-19 12:20:27 +00:00
|
|
|
|
2011-04-24 06:19:22 +01:00
|
|
|
case LWS_WS_OPCODE_07__PONG:
|
2015-10-05 11:35:52 +01:00
|
|
|
lwsl_info("received pong\n");
|
|
|
|
|
lwsl_hexdump(&wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING],
|
|
|
|
|
wsi->u.ws.rx_user_buffer_head);
|
|
|
|
|
|
|
|
|
|
/* issue it */
|
|
|
|
|
callback_action = LWS_CALLBACK_RECEIVE_PONG;
|
|
|
|
|
break;
|
2011-01-19 12:20:27 +00:00
|
|
|
|
2011-05-23 10:00:03 +01:00
|
|
|
case LWS_WS_OPCODE_07__TEXT_FRAME:
|
|
|
|
|
case LWS_WS_OPCODE_07__BINARY_FRAME:
|
2013-01-18 09:49:20 +08:00
|
|
|
case LWS_WS_OPCODE_07__CONTINUATION:
|
2011-01-19 12:20:27 +00:00
|
|
|
break;
|
2011-05-23 10:00:03 +01:00
|
|
|
|
|
|
|
|
default:
|
2013-02-11 17:13:32 +08:00
|
|
|
lwsl_parser("passing opc %x up to exts\n",
|
|
|
|
|
wsi->u.ws.opcode);
|
2011-05-23 10:00:03 +01:00
|
|
|
/*
|
|
|
|
|
* It's something special we can't understand here.
|
|
|
|
|
* Pass the payload up to the extension's parsing
|
|
|
|
|
* state machine.
|
|
|
|
|
*/
|
|
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
eff_buf.token = &wsi->u.ws.rx_user_buffer[
|
2011-05-23 10:00:03 +01:00
|
|
|
LWS_SEND_BUFFER_PRE_PADDING];
|
2013-01-21 11:04:23 +08:00
|
|
|
eff_buf.token_len = wsi->u.ws.rx_user_buffer_head;
|
2011-05-23 10:00:03 +01:00
|
|
|
|
2014-04-02 19:45:42 +08:00
|
|
|
if (lws_ext_callback_for_each_active(wsi,
|
|
|
|
|
LWS_EXT_CALLBACK_EXTENDED_PAYLOAD_RX,
|
|
|
|
|
&eff_buf, 0) <= 0) /* not handle or fail */
|
2013-02-11 17:13:32 +08:00
|
|
|
lwsl_ext("ext opc opcode 0x%x unknown\n",
|
|
|
|
|
wsi->u.ws.opcode);
|
2011-05-23 10:00:03 +01:00
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_user_buffer_head = 0;
|
2011-05-23 10:00:03 +01:00
|
|
|
return 0;
|
2011-01-19 12:20:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* No it's real payload, pass it up to the user callback.
|
|
|
|
|
* It's nicely buffered with the pre-padding taken care of
|
|
|
|
|
* so it can be sent straight out again using libwebsocket_write
|
|
|
|
|
*/
|
|
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
eff_buf.token = &wsi->u.ws.rx_user_buffer[
|
2013-01-09 18:06:55 +08:00
|
|
|
LWS_SEND_BUFFER_PRE_PADDING];
|
2013-01-21 11:04:23 +08:00
|
|
|
eff_buf.token_len = wsi->u.ws.rx_user_buffer_head;
|
2014-04-02 19:45:42 +08:00
|
|
|
|
|
|
|
|
if (lws_ext_callback_for_each_active(wsi,
|
|
|
|
|
LWS_EXT_CALLBACK_PAYLOAD_RX, &eff_buf, 0) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2013-01-09 18:06:55 +08:00
|
|
|
if (eff_buf.token_len > 0) {
|
2013-02-10 21:21:24 +08:00
|
|
|
eff_buf.token[eff_buf.token_len] = '\0';
|
2013-01-09 18:06:55 +08:00
|
|
|
|
2015-10-05 11:35:52 +01:00
|
|
|
if (wsi->protocol->callback) {
|
|
|
|
|
|
|
|
|
|
if (callback_action == LWS_CALLBACK_RECEIVE_PONG)
|
|
|
|
|
lwsl_info("Doing pong callback\n");
|
|
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
ret = user_callback_handle_rxflow(
|
|
|
|
|
wsi->protocol->callback,
|
|
|
|
|
wsi->protocol->owning_server,
|
2015-10-05 11:35:52 +01:00
|
|
|
wsi,
|
|
|
|
|
(enum libwebsocket_callback_reasons)callback_action,
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->user_space,
|
|
|
|
|
eff_buf.token,
|
|
|
|
|
eff_buf.token_len);
|
2015-10-05 11:35:52 +01:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
lwsl_err("No callback on payload spill!\n");
|
2013-01-09 18:06:55 +08:00
|
|
|
}
|
2011-05-23 10:00:03 +01:00
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_user_buffer_head = 0;
|
2011-01-22 12:51:57 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-10 21:21:24 +08:00
|
|
|
return ret;
|
2011-04-24 06:19:22 +01:00
|
|
|
|
|
|
|
|
illegal_ctl_length:
|
|
|
|
|
|
2013-02-11 17:13:32 +08:00
|
|
|
lwsl_warn("Control frame with xtended length is illegal\n");
|
2011-04-24 06:19:22 +01:00
|
|
|
/* kill the connection */
|
|
|
|
|
return -1;
|
2011-01-22 12:51:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-01-19 12:20:27 +00:00
|
|
|
/**
|
|
|
|
|
* libwebsockets_remaining_packet_payload() - Bytes to come before "overall"
|
2011-01-23 16:50:33 +00:00
|
|
|
* rx packet is complete
|
2011-01-19 12:20:27 +00:00
|
|
|
* @wsi: Websocket instance (available from user callback)
|
|
|
|
|
*
|
|
|
|
|
* This function is intended to be called from the callback if the
|
|
|
|
|
* user code is interested in "complete packets" from the client.
|
|
|
|
|
* libwebsockets just passes through payload as it comes and issues a buffer
|
|
|
|
|
* additionally when it hits a built-in limit. The LWS_CALLBACK_RECEIVE
|
|
|
|
|
* callback handler can use this API to find out if the buffer it has just
|
|
|
|
|
* been given is the last piece of a "complete packet" from the client --
|
|
|
|
|
* when that is the case libwebsockets_remaining_packet_payload() will return
|
|
|
|
|
* 0.
|
|
|
|
|
*
|
|
|
|
|
* Many protocols won't care becuse their packets are always small.
|
|
|
|
|
*/
|
|
|
|
|
|
2013-03-30 09:52:21 +08:00
|
|
|
LWS_VISIBLE size_t
|
2011-01-19 12:20:27 +00:00
|
|
|
libwebsockets_remaining_packet_payload(struct libwebsocket *wsi)
|
|
|
|
|
{
|
2013-01-21 11:04:23 +08:00
|
|
|
return wsi->u.ws.rx_packet_length;
|
2011-01-19 12:20:27 +00:00
|
|
|
}
|