You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1189 lines
22 KiB
1189 lines
22 KiB
/*
|
|
* libwebsockets - small server side websockets and web server implementation
|
|
*
|
|
* Copyright (C) 2010 - 2020 Andy Green <andy@warmcat.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to
|
|
* deal in the Software without restriction, including without limitation the
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "private-lib-core.h"
|
|
|
|
#ifdef LWS_HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
void
|
|
lws_ser_wu16be(uint8_t *b, uint16_t u)
|
|
{
|
|
*b++ = (uint8_t)(u >> 8);
|
|
*b = (uint8_t)u;
|
|
}
|
|
|
|
void
|
|
lws_ser_wu32be(uint8_t *b, uint32_t u32)
|
|
{
|
|
*b++ = (uint8_t)(u32 >> 24);
|
|
*b++ = (uint8_t)(u32 >> 16);
|
|
*b++ = (uint8_t)(u32 >> 8);
|
|
*b = (uint8_t)u32;
|
|
}
|
|
|
|
void
|
|
lws_ser_wu64be(uint8_t *b, uint64_t u64)
|
|
{
|
|
lws_ser_wu32be(b, (uint32_t)(u64 >> 32));
|
|
lws_ser_wu32be(b + 4, (uint32_t)u64);
|
|
}
|
|
|
|
uint16_t
|
|
lws_ser_ru16be(const uint8_t *b)
|
|
{
|
|
return (b[0] << 8) | b[1];
|
|
}
|
|
|
|
uint32_t
|
|
lws_ser_ru32be(const uint8_t *b)
|
|
{
|
|
return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
|
|
}
|
|
|
|
uint64_t
|
|
lws_ser_ru64be(const uint8_t *b)
|
|
{
|
|
return (((uint64_t)lws_ser_ru32be(b)) << 32) | lws_ser_ru32be(b + 4);
|
|
}
|
|
|
|
int
|
|
lws_vbi_encode(uint64_t value, void *buf)
|
|
{
|
|
uint8_t *p = (uint8_t *)buf, b;
|
|
|
|
if (value > 0xfffffff) {
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
do {
|
|
b = value & 0x7f;
|
|
value >>= 7;
|
|
if (value)
|
|
*p++ = (0x80 | b);
|
|
else
|
|
*p++ = b;
|
|
} while (value);
|
|
|
|
return lws_ptr_diff(p, buf);
|
|
}
|
|
|
|
int
|
|
lws_vbi_decode(const void *buf, uint64_t *value, size_t len)
|
|
{
|
|
const uint8_t *p = (const uint8_t *)buf, *end = p + len;
|
|
uint64_t v = 0;
|
|
int s = 0;
|
|
|
|
while (p < end) {
|
|
v |= (((uint64_t)(*p)) & 0x7f) << s;
|
|
if (*p & 0x80) {
|
|
*value = v;
|
|
|
|
return lws_ptr_diff(p, buf);
|
|
}
|
|
s += 7;
|
|
if (s >= 64)
|
|
return 0;
|
|
p++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
signed 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;
|
|
}
|
|
|
|
int
|
|
lws_hex_to_byte_array(const char *h, uint8_t *dest, int max)
|
|
{
|
|
uint8_t *odest = dest;
|
|
|
|
while (max-- && *h) {
|
|
int t = char_to_hex(*h++), t1;
|
|
|
|
if (!*h || t < 0)
|
|
return -1;
|
|
|
|
t1 = char_to_hex(*h++);
|
|
if (t1 < 0)
|
|
return -1;
|
|
|
|
*dest++ = (t << 4) | t1;
|
|
}
|
|
|
|
if (max < 0)
|
|
return -1;
|
|
|
|
return lws_ptr_diff(dest, odest);
|
|
}
|
|
|
|
|
|
#if !defined(LWS_PLAT_OPTEE)
|
|
|
|
#if defined(LWS_WITH_FILE_OPS)
|
|
int lws_open(const char *__file, int __oflag, ...)
|
|
{
|
|
va_list ap;
|
|
int n;
|
|
|
|
va_start(ap, __oflag);
|
|
if (((__oflag & O_CREAT) == O_CREAT)
|
|
#if defined(O_TMPFILE)
|
|
|| ((__oflag & O_TMPFILE) == O_TMPFILE)
|
|
#endif
|
|
)
|
|
/* last arg is really a mode_t. But windows... */
|
|
n = open(__file, __oflag, va_arg(ap, uint32_t));
|
|
else
|
|
n = open(__file, __oflag);
|
|
va_end(ap);
|
|
|
|
if (n != -1 && lws_plat_apply_FD_CLOEXEC(n)) {
|
|
close(n);
|
|
|
|
return -1;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
int
|
|
lws_pthread_self_to_tsi(struct lws_context *context)
|
|
{
|
|
#if LWS_MAX_SMP > 1
|
|
pthread_t ps = pthread_self();
|
|
struct lws_context_per_thread *pt = &context->pt[0];
|
|
int n;
|
|
|
|
for (n = 0; n < context->count_threads; n++) {
|
|
if (pthread_equal(ps, pt->self))
|
|
return n;
|
|
pt++;
|
|
}
|
|
|
|
return -1;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
void *
|
|
lws_context_user(struct lws_context *context)
|
|
{
|
|
return context->user_space;
|
|
}
|
|
|
|
void
|
|
lws_explicit_bzero(void *p, size_t len)
|
|
{
|
|
volatile uint8_t *vp = p;
|
|
|
|
while (len--)
|
|
*vp++ = 0;
|
|
}
|
|
|
|
#if !(defined(LWS_PLAT_OPTEE) && !defined(LWS_WITH_NETWORK))
|
|
|
|
/**
|
|
* lws_now_secs() - seconds since 1970-1-1
|
|
*
|
|
*/
|
|
unsigned long
|
|
lws_now_secs(void)
|
|
{
|
|
struct timeval tv;
|
|
|
|
gettimeofday(&tv, NULL);
|
|
|
|
return tv.tv_sec;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(LWS_WITH_SERVER)
|
|
const char *
|
|
lws_canonical_hostname(struct lws_context *context)
|
|
{
|
|
return (const char *)context->canonical_hostname;
|
|
}
|
|
#endif
|
|
|
|
int
|
|
lws_get_count_threads(struct lws_context *context)
|
|
{
|
|
return context->count_threads;
|
|
}
|
|
|
|
static const unsigned char e0f4[] = {
|
|
0xa0 | ((2 - 1) << 2) | 1, /* e0 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e1 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e2 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e3 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e4 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e5 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e6 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e7 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e8 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* e9 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* ea */
|
|
0x80 | ((4 - 1) << 2) | 1, /* eb */
|
|
0x80 | ((4 - 1) << 2) | 1, /* ec */
|
|
0x80 | ((2 - 1) << 2) | 1, /* ed */
|
|
0x80 | ((4 - 1) << 2) | 1, /* ee */
|
|
0x80 | ((4 - 1) << 2) | 1, /* ef */
|
|
0x90 | ((3 - 1) << 2) | 2, /* f0 */
|
|
0x80 | ((4 - 1) << 2) | 2, /* f1 */
|
|
0x80 | ((4 - 1) << 2) | 2, /* f2 */
|
|
0x80 | ((4 - 1) << 2) | 2, /* f3 */
|
|
0x80 | ((1 - 1) << 2) | 2, /* f4 */
|
|
|
|
0, /* s0 */
|
|
0x80 | ((4 - 1) << 2) | 0, /* s2 */
|
|
0x80 | ((4 - 1) << 2) | 1, /* s3 */
|
|
};
|
|
|
|
int
|
|
lws_check_byte_utf8(unsigned char state, unsigned char c)
|
|
{
|
|
unsigned char s = state;
|
|
|
|
if (!s) {
|
|
if (c >= 0x80) {
|
|
if (c < 0xc2 || c > 0xf4)
|
|
return -1;
|
|
if (c < 0xe0)
|
|
return 0x80 | ((4 - 1) << 2);
|
|
else
|
|
return e0f4[c - 0xe0];
|
|
}
|
|
|
|
return s;
|
|
}
|
|
if (c < (s & 0xf0) || c >= (s & 0xf0) + 0x10 + ((s << 2) & 0x30))
|
|
return -1;
|
|
|
|
return e0f4[21 + (s & 3)];
|
|
}
|
|
|
|
int
|
|
lws_check_utf8(unsigned char *state, unsigned char *buf, size_t len)
|
|
{
|
|
unsigned char s = *state;
|
|
|
|
while (len--) {
|
|
unsigned char c = *buf++;
|
|
|
|
if (!s) {
|
|
if (c >= 0x80) {
|
|
if (c < 0xc2 || c > 0xf4)
|
|
return 1;
|
|
if (c < 0xe0)
|
|
s = 0x80 | ((4 - 1) << 2);
|
|
else
|
|
s = e0f4[c - 0xe0];
|
|
}
|
|
} else {
|
|
if (c < (s & 0xf0) ||
|
|
c >= (s & 0xf0) + 0x10 + ((s << 2) & 0x30))
|
|
return 1;
|
|
s = e0f4[21 + (s & 3)];
|
|
}
|
|
}
|
|
|
|
*state = s;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
char *
|
|
lws_strdup(const char *s)
|
|
{
|
|
char *d = lws_malloc(strlen(s) + 1, "strdup");
|
|
|
|
if (d)
|
|
strcpy(d, s);
|
|
|
|
return d;
|
|
}
|
|
|
|
static const char *hex = "0123456789ABCDEF";
|
|
|
|
const char *
|
|
lws_sql_purify(char *escaped, const char *string, int len)
|
|
{
|
|
const char *p = string;
|
|
char *q = escaped;
|
|
|
|
while (*p && len-- > 2) {
|
|
if (*p == '\'') {
|
|
*q++ = '\'';
|
|
*q++ = '\'';
|
|
len --;
|
|
p++;
|
|
} else
|
|
*q++ = *p++;
|
|
}
|
|
*q = '\0';
|
|
|
|
return escaped;
|
|
}
|
|
|
|
int
|
|
lws_sql_purify_len(const char *p)
|
|
{
|
|
int olen = 0;
|
|
|
|
while (*p) {
|
|
if (*p++ == '\'')
|
|
olen++;
|
|
olen++;
|
|
}
|
|
|
|
return olen;
|
|
}
|
|
|
|
const char *
|
|
lws_json_purify(char *escaped, const char *string, int len, int *in_used)
|
|
{
|
|
const char *p = string;
|
|
char *q = escaped;
|
|
|
|
if (!p) {
|
|
escaped[0] = '\0';
|
|
return escaped;
|
|
}
|
|
|
|
while (*p && len-- > 6) {
|
|
if (*p == '\t') {
|
|
p++;
|
|
*q++ = '\\';
|
|
*q++ = 't';
|
|
continue;
|
|
}
|
|
|
|
if (*p == '\n') {
|
|
p++;
|
|
*q++ = '\\';
|
|
*q++ = 'n';
|
|
continue;
|
|
}
|
|
|
|
if (*p == '\r') {
|
|
p++;
|
|
*q++ = '\\';
|
|
*q++ = 'r';
|
|
continue;
|
|
}
|
|
|
|
if (*p == '\"' || *p == '\\' || *p < 0x20) {
|
|
*q++ = '\\';
|
|
*q++ = 'u';
|
|
*q++ = '0';
|
|
*q++ = '0';
|
|
*q++ = hex[((*p) >> 4) & 15];
|
|
*q++ = hex[(*p) & 15];
|
|
len -= 5;
|
|
p++;
|
|
} else
|
|
*q++ = *p++;
|
|
}
|
|
*q = '\0';
|
|
|
|
if (in_used)
|
|
*in_used = lws_ptr_diff(p, string);
|
|
|
|
return escaped;
|
|
}
|
|
|
|
int
|
|
lws_json_purify_len(const char *string)
|
|
{
|
|
int len = 0;
|
|
const char *p = string;
|
|
|
|
while (*p) {
|
|
if (*p == '\t' || *p == '\n' || *p == '\r') {
|
|
p++;
|
|
len += 2;
|
|
continue;
|
|
}
|
|
|
|
if (*p == '\"' || *p == '\\' || *p < 0x20) {
|
|
len += 6;
|
|
p++;
|
|
continue;
|
|
}
|
|
p++;
|
|
len++;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
void
|
|
lws_filename_purify_inplace(char *filename)
|
|
{
|
|
while (*filename) {
|
|
|
|
if (*filename == '.' && filename[1] == '.') {
|
|
*filename = '_';
|
|
filename[1] = '_';
|
|
}
|
|
|
|
if (*filename == ':' ||
|
|
*filename == '\\' ||
|
|
*filename == '$' ||
|
|
*filename == '%')
|
|
*filename = '_';
|
|
|
|
filename++;
|
|
}
|
|
}
|
|
|
|
const char *
|
|
lws_urlencode(char *escaped, const char *string, int len)
|
|
{
|
|
const char *p = string;
|
|
char *q = escaped;
|
|
|
|
while (*p && len-- > 3) {
|
|
if (*p == ' ') {
|
|
*q++ = '+';
|
|
p++;
|
|
continue;
|
|
}
|
|
if ((*p >= '0' && *p <= '9') ||
|
|
(*p >= 'A' && *p <= 'Z') ||
|
|
(*p >= 'a' && *p <= 'z')) {
|
|
*q++ = *p++;
|
|
continue;
|
|
}
|
|
*q++ = '%';
|
|
*q++ = hex[(*p >> 4) & 0xf];
|
|
*q++ = hex[*p & 0xf];
|
|
|
|
len -= 2;
|
|
p++;
|
|
}
|
|
*q = '\0';
|
|
|
|
return escaped;
|
|
}
|
|
|
|
int
|
|
lws_urldecode(char *string, const char *escaped, int len)
|
|
{
|
|
int state = 0, n;
|
|
char sum = 0;
|
|
|
|
while (*escaped && len) {
|
|
switch (state) {
|
|
case 0:
|
|
if (*escaped == '%') {
|
|
state++;
|
|
escaped++;
|
|
continue;
|
|
}
|
|
if (*escaped == '+') {
|
|
escaped++;
|
|
*string++ = ' ';
|
|
len--;
|
|
continue;
|
|
}
|
|
*string++ = *escaped++;
|
|
len--;
|
|
break;
|
|
case 1:
|
|
n = char_to_hex(*escaped);
|
|
if (n < 0)
|
|
return -1;
|
|
escaped++;
|
|
sum = n << 4;
|
|
state++;
|
|
break;
|
|
|
|
case 2:
|
|
n = char_to_hex(*escaped);
|
|
if (n < 0)
|
|
return -1;
|
|
escaped++;
|
|
*string++ = sum | n;
|
|
len--;
|
|
state = 0;
|
|
break;
|
|
}
|
|
|
|
}
|
|
*string = '\0';
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lws_finalize_startup(struct lws_context *context)
|
|
{
|
|
if (lws_check_opt(context->options, LWS_SERVER_OPTION_EXPLICIT_VHOSTS))
|
|
if (lws_plat_drop_app_privileges(context, 1))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
lws_get_effective_uid_gid(struct lws_context *context, int *uid, int *gid)
|
|
{
|
|
*uid = context->uid;
|
|
*gid = context->gid;
|
|
}
|
|
|
|
int
|
|
lws_snprintf(char *str, size_t size, const char *format, ...)
|
|
{
|
|
va_list ap;
|
|
int n;
|
|
|
|
if (!size)
|
|
return 0;
|
|
|
|
va_start(ap, format);
|
|
n = vsnprintf(str, size, format, ap);
|
|
va_end(ap);
|
|
|
|
if (n >= (int)size)
|
|
return (int)size;
|
|
|
|
return n;
|
|
}
|
|
|
|
char *
|
|
lws_strncpy(char *dest, const char *src, size_t size)
|
|
{
|
|
strncpy(dest, src, size - 1);
|
|
dest[size - 1] = '\0';
|
|
|
|
return dest;
|
|
}
|
|
|
|
int
|
|
lws_timingsafe_bcmp(const void *a, const void *b, uint32_t len)
|
|
{
|
|
const uint8_t *pa = a, *pb = b;
|
|
uint8_t sum = 0;
|
|
|
|
while (len--)
|
|
sum |= (*pa++ ^ *pb++);
|
|
|
|
return sum;
|
|
}
|
|
|
|
|
|
typedef enum {
|
|
LWS_TOKZS_LEADING_WHITESPACE,
|
|
LWS_TOKZS_QUOTED_STRING,
|
|
LWS_TOKZS_TOKEN,
|
|
LWS_TOKZS_TOKEN_POST_TERMINAL
|
|
} lws_tokenize_state;
|
|
|
|
lws_tokenize_elem
|
|
lws_tokenize(struct lws_tokenize *ts)
|
|
{
|
|
const char *rfc7230_delims = "(),/:;<=>?@[\\]{}";
|
|
lws_tokenize_state state = LWS_TOKZS_LEADING_WHITESPACE;
|
|
char c, flo = 0, d_minus = '-', d_dot = '.', s_minus = '\0',
|
|
s_dot = '\0', skipping = 0;
|
|
signed char num = (ts->flags & LWS_TOKENIZE_F_NO_INTEGERS) ? 0 : -1;
|
|
int utf8 = 0;
|
|
|
|
/* for speed, compute the effect of the flags outside the loop */
|
|
|
|
if (ts->flags & LWS_TOKENIZE_F_MINUS_NONTERM) {
|
|
d_minus = '\0';
|
|
s_minus = '-';
|
|
}
|
|
if (ts->flags & LWS_TOKENIZE_F_DOT_NONTERM) {
|
|
d_dot = '\0';
|
|
s_dot = '.';
|
|
}
|
|
|
|
ts->token = NULL;
|
|
ts->token_len = 0;
|
|
|
|
while (ts->len) {
|
|
c = *ts->start++;
|
|
ts->len--;
|
|
|
|
utf8 = lws_check_byte_utf8((unsigned char)utf8, c);
|
|
if (utf8 < 0)
|
|
return LWS_TOKZE_ERR_BROKEN_UTF8;
|
|
|
|
if (!c)
|
|
break;
|
|
|
|
if (skipping) {
|
|
if (c != '\r' && c != '\n')
|
|
continue;
|
|
else
|
|
skipping = 0;
|
|
}
|
|
|
|
/* comment */
|
|
|
|
if (ts->flags & LWS_TOKENIZE_F_HASH_COMMENT &&
|
|
state != LWS_TOKZS_QUOTED_STRING &&
|
|
c == '#') {
|
|
skipping = 1;
|
|
continue;
|
|
}
|
|
|
|
/* whitespace */
|
|
|
|
if (c == ' ' || c == '\t' || c == '\n' || c == '\r' ||
|
|
c == '\f') {
|
|
switch (state) {
|
|
case LWS_TOKZS_LEADING_WHITESPACE:
|
|
case LWS_TOKZS_TOKEN_POST_TERMINAL:
|
|
continue;
|
|
case LWS_TOKZS_QUOTED_STRING:
|
|
ts->token_len++;
|
|
continue;
|
|
case LWS_TOKZS_TOKEN:
|
|
/* we want to scan forward to look for = */
|
|
|
|
state = LWS_TOKZS_TOKEN_POST_TERMINAL;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* quoted string */
|
|
|
|
if (c == '\"') {
|
|
if (state == LWS_TOKZS_QUOTED_STRING)
|
|
return LWS_TOKZE_QUOTED_STRING;
|
|
|
|
/* starting a quoted string */
|
|
|
|
if (ts->flags & LWS_TOKENIZE_F_COMMA_SEP_LIST) {
|
|
if (ts->delim == LWSTZ_DT_NEED_DELIM)
|
|
return LWS_TOKZE_ERR_COMMA_LIST;
|
|
ts->delim = LWSTZ_DT_NEED_DELIM;
|
|
}
|
|
|
|
state = LWS_TOKZS_QUOTED_STRING;
|
|
ts->token = ts->start;
|
|
ts->token_len = 0;
|
|
|
|
continue;
|
|
}
|
|
|
|
/* token= aggregation */
|
|
|
|
if (c == '=' && (state == LWS_TOKZS_TOKEN_POST_TERMINAL ||
|
|
state == LWS_TOKZS_TOKEN)) {
|
|
if (num == 1)
|
|
return LWS_TOKZE_ERR_NUM_ON_LHS;
|
|
/* swallow the = */
|
|
return LWS_TOKZE_TOKEN_NAME_EQUALS;
|
|
}
|
|
|
|
/* optional token: aggregation */
|
|
|
|
if ((ts->flags & LWS_TOKENIZE_F_AGG_COLON) && c == ':' &&
|
|
(state == LWS_TOKZS_TOKEN_POST_TERMINAL ||
|
|
state == LWS_TOKZS_TOKEN))
|
|
/* swallow the : */
|
|
return LWS_TOKZE_TOKEN_NAME_COLON;
|
|
|
|
/* aggregate . in a number as a float */
|
|
|
|
if (c == '.' && !(ts->flags & LWS_TOKENIZE_F_NO_FLOATS) &&
|
|
state == LWS_TOKZS_TOKEN && num == 1) {
|
|
if (flo)
|
|
return LWS_TOKZE_ERR_MALFORMED_FLOAT;
|
|
flo = 1;
|
|
ts->token_len++;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Delimiter... by default anything that:
|
|
*
|
|
* - isn't matched earlier, or
|
|
* - is [A-Z, a-z, 0-9, _], and
|
|
* - is not a partial utf8 char
|
|
*
|
|
* is a "delimiter", it marks the end of a token and is itself
|
|
* reported as a single LWS_TOKZE_DELIMITER each time.
|
|
*
|
|
* However with LWS_TOKENIZE_F_RFC7230_DELIMS flag, tokens may
|
|
* contain any noncontrol character that isn't defined in
|
|
* rfc7230_delims, and only characters listed there are treated
|
|
* as delimiters.
|
|
*/
|
|
|
|
if (!utf8 &&
|
|
((ts->flags & LWS_TOKENIZE_F_RFC7230_DELIMS &&
|
|
strchr(rfc7230_delims, c) && c > 32) ||
|
|
((!(ts->flags & LWS_TOKENIZE_F_RFC7230_DELIMS) &&
|
|
(c < '0' || c > '9') && (c < 'A' || c > 'Z') &&
|
|
(c < 'a' || c > 'z') && c != '_') &&
|
|
c != s_minus && c != s_dot) ||
|
|
c == d_minus || c == d_dot
|
|
) &&
|
|
!((ts->flags & LWS_TOKENIZE_F_SLASH_NONTERM) && c == '/')) {
|
|
switch (state) {
|
|
case LWS_TOKZS_LEADING_WHITESPACE:
|
|
if (ts->flags & LWS_TOKENIZE_F_COMMA_SEP_LIST) {
|
|
if (c != ',' ||
|
|
ts->delim != LWSTZ_DT_NEED_DELIM)
|
|
return LWS_TOKZE_ERR_COMMA_LIST;
|
|
ts->delim = LWSTZ_DT_NEED_NEXT_CONTENT;
|
|
}
|
|
|
|
ts->token = ts->start - 1;
|
|
ts->token_len = 1;
|
|
return LWS_TOKZE_DELIMITER;
|
|
|
|
case LWS_TOKZS_QUOTED_STRING:
|
|
ts->token_len++;
|
|
continue;
|
|
|
|
case LWS_TOKZS_TOKEN_POST_TERMINAL:
|
|
case LWS_TOKZS_TOKEN:
|
|
/* report the delimiter next time */
|
|
ts->start--;
|
|
ts->len++;
|
|
goto token_or_numeric;
|
|
}
|
|
}
|
|
|
|
/* anything that's not whitespace or delimiter is payload */
|
|
|
|
switch (state) {
|
|
case LWS_TOKZS_LEADING_WHITESPACE:
|
|
|
|
if (ts->flags & LWS_TOKENIZE_F_COMMA_SEP_LIST) {
|
|
if (ts->delim == LWSTZ_DT_NEED_DELIM)
|
|
return LWS_TOKZE_ERR_COMMA_LIST;
|
|
ts->delim = LWSTZ_DT_NEED_DELIM;
|
|
}
|
|
|
|
state = LWS_TOKZS_TOKEN;
|
|
ts->token = ts->start - 1;
|
|
ts->token_len = 1;
|
|
goto checknum;
|
|
|
|
case LWS_TOKZS_QUOTED_STRING:
|
|
case LWS_TOKZS_TOKEN:
|
|
ts->token_len++;
|
|
checknum:
|
|
if (!(ts->flags & LWS_TOKENIZE_F_NO_INTEGERS)) {
|
|
if (c < '0' || c > '9')
|
|
num = 0;
|
|
else
|
|
if (num < 0)
|
|
num = 1;
|
|
}
|
|
continue;
|
|
|
|
case LWS_TOKZS_TOKEN_POST_TERMINAL:
|
|
/* report the new token next time */
|
|
ts->start--;
|
|
ts->len++;
|
|
goto token_or_numeric;
|
|
}
|
|
}
|
|
|
|
/* we ran out of content */
|
|
|
|
if (utf8) /* ended partway through a multibyte char */
|
|
return LWS_TOKZE_ERR_BROKEN_UTF8;
|
|
|
|
if (state == LWS_TOKZS_QUOTED_STRING)
|
|
return LWS_TOKZE_ERR_UNTERM_STRING;
|
|
|
|
if (state != LWS_TOKZS_TOKEN_POST_TERMINAL &&
|
|
state != LWS_TOKZS_TOKEN) {
|
|
if ((ts->flags & LWS_TOKENIZE_F_COMMA_SEP_LIST) &&
|
|
ts->delim == LWSTZ_DT_NEED_NEXT_CONTENT)
|
|
return LWS_TOKZE_ERR_COMMA_LIST;
|
|
|
|
return LWS_TOKZE_ENDED;
|
|
}
|
|
|
|
/* report the pending token */
|
|
|
|
token_or_numeric:
|
|
|
|
if (num != 1)
|
|
return LWS_TOKZE_TOKEN;
|
|
if (flo)
|
|
return LWS_TOKZE_FLOAT;
|
|
|
|
return LWS_TOKZE_INTEGER;
|
|
}
|
|
|
|
|
|
int
|
|
lws_tokenize_cstr(struct lws_tokenize *ts, char *str, size_t max)
|
|
{
|
|
if (ts->token_len + 1 >= max)
|
|
return 1;
|
|
|
|
memcpy(str, ts->token, ts->token_len);
|
|
str[ts->token_len] = '\0';
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
lws_tokenize_init(struct lws_tokenize *ts, const char *start, int flags)
|
|
{
|
|
ts->start = start;
|
|
ts->len = 0x7fffffff;
|
|
ts->flags = flags;
|
|
ts->delim = LWSTZ_DT_NEED_FIRST_CONTENT;
|
|
}
|
|
|
|
|
|
typedef enum {
|
|
LWS_EXPS_LITERAL,
|
|
LWS_EXPS_OPEN_OR_LIT,
|
|
LWS_EXPS_NAME_OR_CLOSE,
|
|
LWS_EXPS_DRAIN,
|
|
} lws_strexp_state;
|
|
|
|
void
|
|
lws_strexp_init(lws_strexp_t *exp, void *priv, lws_strexp_expand_cb cb,
|
|
char *out, size_t olen)
|
|
{
|
|
memset(exp, 0, sizeof(*exp));
|
|
exp->cb = cb;
|
|
exp->out = out;
|
|
exp->olen = olen;
|
|
exp->state = LWS_EXPS_LITERAL;
|
|
exp->priv = priv;
|
|
}
|
|
|
|
void
|
|
lws_strexp_reset_out(lws_strexp_t *exp, char *out, size_t olen)
|
|
{
|
|
exp->out = out;
|
|
exp->olen = olen;
|
|
exp->pos = 0;
|
|
}
|
|
|
|
int
|
|
lws_strexp_expand(lws_strexp_t *exp, const char *in, size_t len,
|
|
size_t *pused_in, size_t *pused_out)
|
|
{
|
|
size_t used = 0;
|
|
int n;
|
|
|
|
while (used < len) {
|
|
|
|
switch (exp->state) {
|
|
case LWS_EXPS_LITERAL:
|
|
if (*in == '$') {
|
|
exp->state = LWS_EXPS_OPEN_OR_LIT;
|
|
break;
|
|
}
|
|
|
|
exp->out[exp->pos++] = *in;
|
|
if (exp->olen - exp->pos < 1) {
|
|
*pused_in = used + 1;
|
|
*pused_out = exp->pos;
|
|
return LSTRX_FILLED_OUT;
|
|
}
|
|
break;
|
|
|
|
case LWS_EXPS_OPEN_OR_LIT:
|
|
if (*in == '{') {
|
|
exp->state = LWS_EXPS_NAME_OR_CLOSE;
|
|
exp->name_pos = 0;
|
|
break;
|
|
}
|
|
/* treat as a literal */
|
|
if (exp->olen - exp->pos < 3)
|
|
return -1;
|
|
|
|
exp->out[exp->pos++] = '$';
|
|
exp->out[exp->pos++] = *in;
|
|
if (*in != '$')
|
|
exp->state = LWS_EXPS_LITERAL;
|
|
break;
|
|
|
|
case LWS_EXPS_NAME_OR_CLOSE:
|
|
if (*in == '}') {
|
|
exp->name[exp->name_pos] = '\0';
|
|
exp->state = LWS_EXPS_DRAIN;
|
|
goto drain;
|
|
}
|
|
if (exp->name_pos >= sizeof(exp->name) - 1)
|
|
return LSTRX_FATAL_NAME_TOO_LONG;
|
|
|
|
exp->name[exp->name_pos++] = *in;
|
|
break;
|
|
|
|
case LWS_EXPS_DRAIN:
|
|
drain:
|
|
*pused_in = used;
|
|
n = exp->cb(exp->priv, exp->name, exp->out, &exp->pos,
|
|
exp->olen, &exp->exp_ofs);
|
|
*pused_out = exp->pos;
|
|
if (n == LSTRX_FILLED_OUT ||
|
|
n == LSTRX_FATAL_NAME_UNKNOWN)
|
|
return n;
|
|
|
|
exp->state = LWS_EXPS_LITERAL;
|
|
break;
|
|
}
|
|
|
|
used++;
|
|
in++;
|
|
}
|
|
|
|
exp->out[exp->pos] = '\0';
|
|
*pused_in = used;
|
|
*pused_out = exp->pos;
|
|
|
|
return LSTRX_DONE;
|
|
}
|
|
|
|
|
|
#if LWS_MAX_SMP > 1
|
|
|
|
void
|
|
lws_mutex_refcount_init(struct lws_mutex_refcount *mr)
|
|
{
|
|
pthread_mutex_init(&mr->lock, NULL);
|
|
mr->last_lock_reason = NULL;
|
|
mr->lock_depth = 0;
|
|
mr->metadata = 0;
|
|
mr->lock_owner = 0;
|
|
}
|
|
|
|
void
|
|
lws_mutex_refcount_destroy(struct lws_mutex_refcount *mr)
|
|
{
|
|
pthread_mutex_destroy(&mr->lock);
|
|
}
|
|
|
|
void
|
|
lws_mutex_refcount_lock(struct lws_mutex_refcount *mr, const char *reason)
|
|
{
|
|
/* if true, this sequence is atomic because our thread has the lock
|
|
*
|
|
* - if true, only guy who can race to make it untrue is our thread,
|
|
* and we are here.
|
|
*
|
|
* - if false, only guy who could race to make it true is our thread,
|
|
* and we are here
|
|
*
|
|
* - it can be false and change to a different tid that is also false
|
|
*/
|
|
if (mr->lock_owner == pthread_self()) {
|
|
/* atomic because we only change it if we own the lock */
|
|
mr->lock_depth++;
|
|
return;
|
|
}
|
|
|
|
pthread_mutex_lock(&mr->lock);
|
|
/* atomic because only we can have the lock */
|
|
mr->last_lock_reason = reason;
|
|
mr->lock_owner = pthread_self();
|
|
mr->lock_depth = 1;
|
|
//lwsl_notice("tid %d: lock %s\n", mr->tid, reason);
|
|
}
|
|
|
|
void
|
|
lws_mutex_refcount_unlock(struct lws_mutex_refcount *mr)
|
|
{
|
|
if (--mr->lock_depth)
|
|
/* atomic because only thread that has the lock can unlock */
|
|
return;
|
|
|
|
mr->last_lock_reason = "free";
|
|
mr->lock_owner = 0;
|
|
//lwsl_notice("tid %d: unlock %s\n", mr->tid, mr->last_lock_reason);
|
|
pthread_mutex_unlock(&mr->lock);
|
|
}
|
|
|
|
#endif /* SMP */
|
|
|
|
|
|
const char *
|
|
lws_cmdline_option(int argc, const char **argv, const char *val)
|
|
{
|
|
int n = (int)strlen(val), c = argc;
|
|
|
|
while (--c > 0) {
|
|
|
|
if (!strncmp(argv[c], val, n)) {
|
|
if (!*(argv[c] + n) && c < argc - 1) {
|
|
/* coverity treats unchecked argv as "tainted" */
|
|
if (!argv[c + 1] || strlen(argv[c + 1]) > 1024)
|
|
return NULL;
|
|
return argv[c + 1];
|
|
}
|
|
|
|
if (argv[c][n] == '=')
|
|
return &argv[c][n + 1];
|
|
return argv[c] + n;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static const char * const builtins[] = {
|
|
"-d",
|
|
"--udp-tx-loss",
|
|
"--udp-rx-loss"
|
|
};
|
|
|
|
void
|
|
lws_cmdline_option_handle_builtin(int argc, const char **argv,
|
|
struct lws_context_creation_info *info)
|
|
{
|
|
const char *p;
|
|
int n, m, logs = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE;
|
|
|
|
for (n = 0; n < (int)LWS_ARRAY_SIZE(builtins); n++) {
|
|
p = lws_cmdline_option(argc, argv, builtins[n]);
|
|
if (!p)
|
|
continue;
|
|
|
|
m = atoi(p);
|
|
|
|
switch (n) {
|
|
case 0:
|
|
logs = m;
|
|
break;
|
|
case 1:
|
|
info->udp_loss_sim_tx_pc = m;
|
|
break;
|
|
case 2:
|
|
info->udp_loss_sim_rx_pc = m;
|
|
break;
|
|
}
|
|
}
|
|
|
|
lws_set_log_level(logs, NULL);
|
|
}
|
|
|
|
|
|
const lws_humanize_unit_t humanize_schema_si[] = {
|
|
{ "Pi ", LWS_PI }, { "Ti ", LWS_TI }, { "Gi ", LWS_GI },
|
|
{ "Mi ", LWS_MI }, { "Ki ", LWS_KI }, { " ", 1 },
|
|
{ NULL, 0 }
|
|
};
|
|
const lws_humanize_unit_t humanize_schema_si_bytes[] = {
|
|
{ "PiB", LWS_PI }, { "TiB", LWS_TI }, { "GiB", LWS_GI },
|
|
{ "MiB", LWS_MI }, { "KiB", LWS_KI }, { "B ", 1 },
|
|
{ NULL, 0 }
|
|
};
|
|
const lws_humanize_unit_t humanize_schema_us[] = {
|
|
{ "y ", (uint64_t)365 * 24 * 3600 * LWS_US_PER_SEC },
|
|
{ "d ", (uint64_t)24 * 3600 * LWS_US_PER_SEC },
|
|
{ "hr ", (uint64_t)3600 * LWS_US_PER_SEC },
|
|
{ "min", 60 * LWS_US_PER_SEC },
|
|
{ "s ", LWS_US_PER_SEC },
|
|
{ "ms ", LWS_US_PER_MS },
|
|
{ "us ", 1 },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
static int
|
|
decim(char *r, uint64_t v, char chars, char leading)
|
|
{
|
|
int n = chars - 1;
|
|
uint64_t q = 1;
|
|
|
|
r += n;
|
|
|
|
while (n >= 0) {
|
|
if (v / q)
|
|
*r-- = '0' + ((v / q) % 10);
|
|
else
|
|
*r-- = leading ? '0' : ' ';
|
|
q = q * 10;
|
|
n--;
|
|
}
|
|
|
|
if (v / q)
|
|
/* the number is bigger than the allowed chars! */
|
|
r[1] = '!';
|
|
|
|
return chars;
|
|
}
|
|
|
|
int
|
|
lws_humanize(char *p, int len, uint64_t v, const lws_humanize_unit_t *schema)
|
|
{
|
|
char *end = p + len;
|
|
|
|
do {
|
|
if (v >= schema->factor || schema->factor == 1) {
|
|
if (schema->factor == 1) {
|
|
*p++ = ' ';
|
|
p += decim(p, v, 4, 0);
|
|
return lws_snprintf(p, lws_ptr_diff(end, p),
|
|
"%s ", schema->name);
|
|
}
|
|
|
|
*p++ = ' ';
|
|
p += decim(p, v / schema->factor, 4, 0);
|
|
*p++ = '.';
|
|
p += decim(p, (v % schema->factor) /
|
|
(schema->factor / 1000), 3, 1);
|
|
|
|
return lws_snprintf(p, lws_ptr_diff(end, p),
|
|
"%s", schema->name);
|
|
}
|
|
schema++;
|
|
} while (schema->name);
|
|
|
|
assert(0);
|
|
strncpy(p, "unknown value", len);
|
|
|
|
return 0;
|
|
}
|