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
|
|
|
}
|
|
|
|
|
/* 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)
|
|
|
|
|
{
|
2013-02-11 17:13:32 +08:00
|
|
|
wsi->u.hdr.ah = 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;
|
|
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-10 15:15:21 +08:00
|
|
|
static char char_to_hex(const char c)
|
|
|
|
|
{
|
|
|
|
|
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
|
|
|
{
|
|
|
|
|
int n;
|
|
|
|
|
|
2013-01-21 11:04:23 +08:00
|
|
|
switch (wsi->u.hdr.parser_state) {
|
2010-11-08 20:20:42 +00:00
|
|
|
case WSI_TOKEN_GET_URI:
|
2013-11-19 13:38:16 +01:00
|
|
|
case WSI_TOKEN_POST_URI:
|
2014-07-05 10:04:19 +08:00
|
|
|
case WSI_TOKEN_OPTIONS_URI:
|
2010-11-08 20:20:42 +00:00
|
|
|
case WSI_TOKEN_HOST:
|
|
|
|
|
case WSI_TOKEN_CONNECTION:
|
|
|
|
|
case WSI_TOKEN_KEY1:
|
|
|
|
|
case WSI_TOKEN_KEY2:
|
|
|
|
|
case WSI_TOKEN_PROTOCOL:
|
|
|
|
|
case WSI_TOKEN_UPGRADE:
|
|
|
|
|
case WSI_TOKEN_ORIGIN:
|
2011-01-22 12:51:57 +00:00
|
|
|
case WSI_TOKEN_SWORIGIN:
|
2010-11-11 12:48:13 +00:00
|
|
|
case WSI_TOKEN_DRAFT:
|
2010-11-08 20:20:42 +00:00
|
|
|
case WSI_TOKEN_CHALLENGE:
|
2011-01-18 15:39:02 +00:00
|
|
|
case WSI_TOKEN_KEY:
|
|
|
|
|
case WSI_TOKEN_VERSION:
|
2011-01-22 12:51:57 +00:00
|
|
|
case WSI_TOKEN_ACCEPT:
|
|
|
|
|
case WSI_TOKEN_NONCE:
|
2011-02-09 08:58:42 +00:00
|
|
|
case WSI_TOKEN_EXTENSIONS:
|
2011-01-22 12:51:57 +00:00
|
|
|
case WSI_TOKEN_HTTP:
|
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
|
|
|
case WSI_TOKEN_HTTP_ACCEPT:
|
2014-06-28 20:19:57 -04:00
|
|
|
case WSI_TOKEN_HTTP_AC_REQUEST_HEADERS:
|
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
|
|
|
case WSI_TOKEN_HTTP_IF_MODIFIED_SINCE:
|
2014-06-28 20:19:57 -04:00
|
|
|
case WSI_TOKEN_HTTP_IF_NONE_MATCH:
|
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
|
|
|
case WSI_TOKEN_HTTP_ACCEPT_ENCODING:
|
|
|
|
|
case WSI_TOKEN_HTTP_ACCEPT_LANGUAGE:
|
|
|
|
|
case WSI_TOKEN_HTTP_PRAGMA:
|
|
|
|
|
case WSI_TOKEN_HTTP_CACHE_CONTROL:
|
|
|
|
|
case WSI_TOKEN_HTTP_AUTHORIZATION:
|
|
|
|
|
case WSI_TOKEN_HTTP_COOKIE:
|
2013-11-19 13:38:16 +01:00
|
|
|
case WSI_TOKEN_HTTP_CONTENT_LENGTH:
|
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
|
|
|
case WSI_TOKEN_HTTP_CONTENT_TYPE:
|
|
|
|
|
case WSI_TOKEN_HTTP_DATE:
|
|
|
|
|
case WSI_TOKEN_HTTP_RANGE:
|
|
|
|
|
case WSI_TOKEN_HTTP_REFERER:
|
|
|
|
|
|
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
|
|
|
|
2014-07-05 10:04:19 +08:00
|
|
|
if ((wsi->u.hdr.parser_state != WSI_TOKEN_GET_URI) &&
|
|
|
|
|
(wsi->u.hdr.parser_state != WSI_TOKEN_POST_URI) &&
|
|
|
|
|
(wsi->u.hdr.parser_state != WSI_TOKEN_OPTIONS_URI))
|
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;
|
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
|
|
|
c = '\0';
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
|
2013-11-10 15:15:21 +08:00
|
|
|
goto spill;
|
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;
|
|
|
|
|
} else
|
|
|
|
|
wsi->u.hdr.ups = URIPS_IDLE;
|
|
|
|
|
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;
|
2013-11-10 15:15:21 +08:00
|
|
|
else /* last we issued was / so SEEN_SLASH */
|
|
|
|
|
wsi->u.hdr.ups = URIPS_SEEN_SLASH;
|
|
|
|
|
break;
|
2013-11-13 07:45:17 +08:00
|
|
|
case URIPS_ARGUMENTS:
|
|
|
|
|
/* leave them alone */
|
|
|
|
|
break;
|
2013-11-10 15:15:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
check_eol:
|
|
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
/* bail at EOL */
|
2013-02-11 17:13:32 +08:00
|
|
|
if (wsi->u.hdr.parser_state != WSI_TOKEN_CHALLENGE &&
|
|
|
|
|
c == '\x0d') {
|
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
|
|
|
c = '\0';
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("*\n");
|
2010-11-08 20:20:42 +00: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;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-10 15:15:21 +08:00
|
|
|
spill:
|
2014-06-29 00:25:19 -04:00
|
|
|
{
|
2014-06-29 01:34:24 -04:00
|
|
|
int issue_result = issue_char(wsi, c);
|
2014-06-29 00:25:19 -04:00
|
|
|
if (issue_result < 0) {
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
else if(issue_result > 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:
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("WSI_TOKEN_NAME_PART '%c'\n", c);
|
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);
|
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
|
|
|
|
2013-02-04 09:24:18 +08:00
|
|
|
if (wsi->u.hdr.lextable_pos < 0) {
|
|
|
|
|
/* this is not a header we know about */
|
2014-07-05 10:04:19 +08:00
|
|
|
if (wsi->u.hdr.ah->frag_index[WSI_TOKEN_GET_URI] ||
|
|
|
|
|
wsi->u.hdr.ah->frag_index[WSI_TOKEN_POST_URI] ||
|
|
|
|
|
wsi->u.hdr.ah->frag_index[WSI_TOKEN_OPTIONS_URI] ||
|
|
|
|
|
wsi->u.hdr.ah->frag_index[WSI_TOKEN_HTTP]) {
|
2013-02-11 17:13:32 +08:00
|
|
|
/*
|
|
|
|
|
* altready had the method, no idea what
|
|
|
|
|
* this crap is, ignore
|
|
|
|
|
*/
|
2013-02-04 09:24:18 +08:00
|
|
|
wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2013-02-12 12:52:39 +08:00
|
|
|
/*
|
|
|
|
|
* hm it's an unknown http method in fact,
|
|
|
|
|
* treat as dangerous
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
lwsl_info("Unknown method - dropping\n");
|
|
|
|
|
return -1;
|
2013-02-04 09:24:18 +08:00
|
|
|
}
|
2014-03-09 11:49:21 +08:00
|
|
|
if (lextable[wsi->u.hdr.lextable_pos] < FAIL_CHAR) {
|
2013-01-18 01:55:48 +08:00
|
|
|
|
2013-02-04 09:24:18 +08:00
|
|
|
/* terminal state */
|
|
|
|
|
|
2014-03-09 11:49:21 +08:00
|
|
|
n = (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);
|
2013-02-12 13:10:19 +08:00
|
|
|
if (n == WSI_TOKEN_GET_URI &&
|
|
|
|
|
wsi->u.hdr.ah->frag_index[WSI_TOKEN_GET_URI]) {
|
|
|
|
|
lwsl_warn("Duplicated GET\n");
|
|
|
|
|
return -1;
|
2013-11-19 13:38:16 +01:00
|
|
|
} else if (n == WSI_TOKEN_POST_URI &&
|
|
|
|
|
wsi->u.hdr.ah->frag_index[WSI_TOKEN_POST_URI]) {
|
|
|
|
|
lwsl_warn("Duplicated POST\n");
|
|
|
|
|
return -1;
|
2014-07-05 10:04:19 +08:00
|
|
|
} else if (n == WSI_TOKEN_OPTIONS_URI &&
|
|
|
|
|
wsi->u.hdr.ah->frag_index[WSI_TOKEN_OPTIONS_URI]) {
|
|
|
|
|
lwsl_warn("Duplicated OPTIONS\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
|
|
|
|
|
|
|
|
if( context->token_limits ) {
|
|
|
|
|
wsi->u.hdr.current_token_limit = \
|
|
|
|
|
context->token_limits->token_limit[wsi->u.hdr.parser_state];
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
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
|
|
|
|
2010-11-08 20:20:42 +00:00
|
|
|
default: /* keep gcc happy */
|
|
|
|
|
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
|
|
|
{
|
|
|
|
|
int n;
|
2011-05-23 10:00:03 +01:00
|
|
|
struct lws_tokens eff_buf;
|
2013-02-10 21:21:24 +08:00
|
|
|
int ret = 0;
|
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
|
|
|
|
2013-02-06 21:10:16 +09:00
|
|
|
if (!wsi->u.ws.rx_user_buffer)
|
|
|
|
|
lwsl_err("NULL user buffer...\n");
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
2013-01-10 19:50:35 +08:00
|
|
|
lwsl_parser("server sees client close packet\n");
|
2011-01-19 12:20:27 +00:00
|
|
|
/* parrot the close packet payload back */
|
|
|
|
|
n = libwebsocket_write(wsi, (unsigned char *)
|
2013-02-11 17:13:32 +08:00
|
|
|
&wsi->u.ws.rx_user_buffer[
|
|
|
|
|
LWS_SEND_BUFFER_PRE_PADDING],
|
|
|
|
|
wsi->u.ws.rx_user_buffer_head,
|
|
|
|
|
LWS_WRITE_CLOSE);
|
2013-02-23 10:50:10 +08:00
|
|
|
if (n < 0)
|
2013-01-17 14:46:43 +08:00
|
|
|
lwsl_info("write of close ack failed %d\n", n);
|
2011-02-10 09:07:05 +00:00
|
|
|
wsi->state = WSI_STATE_RETURNED_CLOSE_ALREADY;
|
2011-01-19 12:20:27 +00:00
|
|
|
/* close the connection */
|
|
|
|
|
return -1;
|
|
|
|
|
|
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);
|
|
|
|
|
lwsl_hexdump(&wsi->u.ws.rx_user_buffer[
|
|
|
|
|
LWS_SEND_BUFFER_PRE_PADDING],
|
|
|
|
|
wsi->u.ws.rx_user_buffer_head);
|
2011-02-10 09:07:05 +00:00
|
|
|
/* parrot the ping packet payload back as a pong */
|
2011-01-19 12:20:27 +00:00
|
|
|
n = libwebsocket_write(wsi, (unsigned char *)
|
2013-02-11 17:13:32 +08:00
|
|
|
&wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING],
|
|
|
|
|
wsi->u.ws.rx_user_buffer_head, LWS_WRITE_PONG);
|
2013-02-23 10:50:10 +08:00
|
|
|
if (n < 0)
|
|
|
|
|
return -1;
|
2011-01-27 20:06:03 +00:00
|
|
|
/* ... then just drop it */
|
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:
|
2011-01-19 12:20:27 +00:00
|
|
|
/* ... then just drop it */
|
2013-01-21 11:04:23 +08:00
|
|
|
wsi->u.ws.rx_user_buffer_head = 0;
|
2011-01-19 12:20:27 +00:00
|
|
|
return 0;
|
|
|
|
|
|
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
|
|
|
|
2013-02-10 21:21:24 +08:00
|
|
|
if (wsi->protocol->callback)
|
2013-02-11 17:13:32 +08:00
|
|
|
ret = user_callback_handle_rxflow(
|
|
|
|
|
wsi->protocol->callback,
|
|
|
|
|
wsi->protocol->owning_server,
|
|
|
|
|
wsi, LWS_CALLBACK_RECEIVE,
|
|
|
|
|
wsi->user_space,
|
|
|
|
|
eff_buf.token,
|
|
|
|
|
eff_buf.token_len);
|
2013-01-09 18:06:55 +08:00
|
|
|
else
|
2013-01-14 13:10:55 +08:00
|
|
|
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
|
|
|
}
|