"Proxy-authorization: basic %s\x0d\x0a",
context->proxy_basic_auth_token);
- plen += sprintf((char *)pt->serv_buf + plen,
- "\x0d\x0a");
-
+ plen += sprintf((char *)pt->serv_buf + plen, "\x0d\x0a");
ads = context->http_proxy_address;
#ifdef LWS_USE_IPV6
const char *host, const char *origin,
const char *protocol, int ietf_version_or_minus_one)
{
- return lws_client_connect_extended(context, address, port, ssl_connection, path,
- host, origin, protocol,
- ietf_version_or_minus_one, NULL);
+ return lws_client_connect_extended(context, address, port, ssl_connection,
+ path, host, origin, protocol,
+ ietf_version_or_minus_one, NULL);
}
{
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
int callback_action = LWS_CALLBACK_CLIENT_RECEIVE;
+ int handled, n, m, rx_draining_ext = 0;
unsigned short close_code;
- unsigned char *pp;
struct lws_tokens eff_buf;
- int handled, n, m, rx_draining_ext = 0;
-
+ unsigned char *pp;
if (wsi->u.ws.rx_draining_ext) {
struct lws **w = &pt->rx_draining_ext_list;
case LWS_RXPS_04_FRAME_HDR_LEN16_1:
wsi->u.ws.rx_packet_length |= c;
- //lwsl_err("&&&&& packet length %d\n", wsi->u.ws.rx_packet_length);
if (wsi->u.ws.this_frame_masked)
- wsi->lws_rx_parse_state =
- LWS_RXPS_07_COLLECT_FRAME_KEY_1;
+ wsi->lws_rx_parse_state = LWS_RXPS_07_COLLECT_FRAME_KEY_1;
else {
if (wsi->u.ws.rx_packet_length)
wsi->lws_rx_parse_state =
switch (wsi->u.ws.opcode) {
case LWSWSOPC_CLOSE:
- pp = (unsigned char *)&wsi->u.ws.rx_ubuf[
- LWS_PRE];
+ pp = (unsigned char *)&wsi->u.ws.rx_ubuf[LWS_PRE];
if (wsi->context->options & LWS_SERVER_OPTION_VALIDATE_UTF8 &&
wsi->u.ws.rx_ubuf_head > 2 &&
lws_check_utf8(&wsi->u.ws.utf8, pp + 2,
* we do not care about how it went, we are closing
* immediately afterwards
*/
- lws_write(wsi,
- (unsigned char *)&wsi->u.ws.rx_ubuf[LWS_PRE],
+ lws_write(wsi, (unsigned char *)&wsi->u.ws.rx_ubuf[LWS_PRE],
wsi->u.ws.rx_ubuf_head, LWS_WRITE_CLOSE);
wsi->state = LWSS_RETURNED_CLOSE_ALREADY;
/* close the connection */
* state machine.
*/
- eff_buf.token = &wsi->u.ws.rx_ubuf[
- LWS_PRE];
+ eff_buf.token = &wsi->u.ws.rx_ubuf[LWS_PRE];
eff_buf.token_len = wsi->u.ws.rx_ubuf_head;
if (lws_ext_cb_active(wsi,
LWS_EXT_CB_EXTENDED_PAYLOAD_RX,
&eff_buf, 0) <= 0) { /* not handle or fail */
- lwsl_ext("Unhandled ext opc 0x%x\n",
- wsi->u.ws.opcode);
+ lwsl_ext("Unhandled ext opc 0x%x\n", wsi->u.ws.opcode);
wsi->u.ws.rx_ubuf_head = 0;
return 0;
return 0;
illegal_ctl_length:
-
lwsl_warn("Control frame asking for extended length is illegal\n");
/* kill the connection */
return -1;
n = recv(wsi->sock, sb, LWS_MAX_SOCKET_IO_BUF, 0);
if (n < 0) {
-
if (LWS_ERRNO == LWS_EAGAIN) {
lwsl_debug("Proxy read returned EAGAIN... retrying\n");
return 0;
pt->serv_buf[13] = '\0';
if (strcmp(sb, "HTTP/1.0 200 ") &&
- strcmp(sb, "HTTP/1.1 200 ")
- ) {
+ strcmp(sb, "HTTP/1.1 200 ")) {
lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
lwsl_err("ERROR proxy: %s\n", sb);
return 0;
/*
* we are under PENDING_TIMEOUT_SENT_CLIENT_HANDSHAKE
* timeout protection set in client-handshake.c
- */
-
- /*
+ *
* take care of our lws_callback_on_writable
* happening at a time when there's no real connection yet
*/
lws_latency_pre(context, wsi);
n = SSL_connect(wsi->ssl);
lws_latency(context, wsi,
- "SSL_connect LWSCM_WSCL_ISSUE_HANDSHAKE",
- n, n > 0);
+ "SSL_connect LWSCM_WSCL_ISSUE_HANDSHAKE", n, n > 0);
if (n < 0) {
n = SSL_get_error(wsi->ssl, n);
* are getting serviced inbetweentimes)
* us to get called back when writable.
*/
-
- lwsl_info(
- "SSL_connect WANT_WRITE... retrying\n");
+ lwsl_info("%s: WANT_WRITE... retrying\n", __func__);
lws_callback_on_writable(wsi);
some_wait:
wsi->mode = LWSCM_WSCL_WAITING_SSL;
* retry if new data comes until we
* run into the connection timeout or win
*/
-
n = ERR_get_error();
if (n != SSL_ERROR_NONE) {
lwsl_err("SSL connect error %lu: %s\n",
case LWSCM_WSCL_WAITING_SSL:
if (wsi->use_ssl) {
-
if (wsi->mode == LWSCM_WSCL_WAITING_SSL) {
lws_latency_pre(context, wsi);
n = SSL_connect(wsi->ssl);
* are getting serviced inbetweentimes)
* us to get called back when writable.
*/
-
lwsl_info("SSL_connect WANT_WRITE... retrying\n");
lws_callback_on_writable(wsi);
return 0;
}
-
/*
* In-place str to lower case
*/
* well, what the server sent looked reasonable for syntax.
* Now let's confirm it sent all the necessary headers
*/
-
p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_HTTP);
if (!p) {
lwsl_info("no URI\n");
len = lws_hdr_total_length(wsi, WSI_TOKEN_PROTOCOL);
if (!len) {
-
lwsl_info("lws_client_int_s_hs: WSI_TOKEN_PROTOCOL is null\n");
/*
* no protocol name to work from,
* we seem to be good to go, give client last chance to check
* headers and OK it
*/
- if (wsi->protocol->callback(wsi,
- LWS_CALLBACK_CLIENT_FILTER_PRE_ESTABLISH,
+ if (wsi->protocol->callback(wsi, LWS_CALLBACK_CLIENT_FILTER_PRE_ESTABLISH,
wsi->user_space, NULL, 0))
goto bail2;
* size mentioned in the protocol definition. If 0 there, then
* use a big default for compatibility
*/
-
n = wsi->protocol->rx_buffer_size;
if (!n)
n = LWS_MAX_SOCKET_IO_BUF;
* inform all extensions, not just active ones since they
* already know
*/
-
ext = context->extensions;
while (ext && ext->callback) {
#ifndef LWS_NO_EXTENSIONS
ext = context->extensions;
while (ext && ext->callback) {
-
n = lws_ext_cb_all_exts(context, wsi,
LWS_EXT_CB_CHECK_OK_TO_PROPOSE_EXTENSION,
(char *)ext->name, 0);
ext++;
continue;
}
-
n = context->protocols[0].callback(wsi,
LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED,
wsi->user_space, (char *)ext->name, 0);
/* give userland a chance to append, eg, cookies */
- context->protocols[0].callback(wsi,
- LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER,
- NULL, &p,
- (pkt + LWS_MAX_SOCKET_IO_BUF) - p - 12);
+ context->protocols[0].callback(wsi, LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER,
+ NULL, &p, (pkt + LWS_MAX_SOCKET_IO_BUF) - p - 12);
p += sprintf(p, "\x0d\x0a");
* representing the library version followed by the git head hash it
* was built from
*/
-
LWS_VISIBLE const char *
lws_get_library_version(void)
{
* images or whatever over http and dynamic data over websockets all in
* one place; they're all handled in the user callback.
*/
-
LWS_VISIBLE struct lws_context *
lws_create_context(struct lws_context_creation_info *info)
{
int n, m;
lwsl_notice("Initial logging level %d\n", log_level);
-
lwsl_notice("Libwebsockets version: %s\n", library_version);
#if LWS_POSIX
#ifdef LWS_USE_IPV6
}
#ifdef LWS_USE_LIBEV
ev_io_stop(context->io_loop, &context->w_accept.watcher);
- if(context->use_ev_sigint)
+ if (context->use_ev_sigint)
ev_signal_stop(context->io_loop, &context->w_sigint.watcher);
#endif /* LWS_USE_LIBEV */
switch (reason) {
case LWS_EXT_CB_OPTION_SET:
oa = in;
- lwsl_info("%s: option set: idx %d, %s, len %d\n", __func__, oa->option_index, oa->start, oa->len);
+ lwsl_info("%s: option set: idx %d, %s, len %d\n", __func__,
+ oa->option_index, oa->start, oa->len);
if (oa->start)
priv->args[oa->option_index] = atoi(oa->start);
else
}
#if 0
- for (n = 0; n < eff_buf->token_len; n++) {
- printf("%02X ", (unsigned char)eff_buf->token[n]);
- if ((n & 15) == 15)
- printf("\n");
- }
- printf("\n");
+ for (n = 0; n < eff_buf->token_len; n++) {
+ printf("%02X ", (unsigned char)eff_buf->token[n]);
+ if ((n & 15) == 15)
+ printf("\n");
+ }
+ printf("\n");
#endif
priv->tx.next_out = priv->buf_tx_deflated + LWS_PRE + 5;
LWS_VISIBLE void
lws_context_init_extensions(struct lws_context_creation_info *info,
- struct lws_context *context)
+ struct lws_context *context)
{
context->extensions = info->extensions;
lwsl_info(" LWS_MAX_EXTENSIONS_ACTIVE: %u\n", LWS_MAX_EXTENSIONS_ACTIVE);
}
-
enum lws_ext_option_parser_states {
LEAPS_SEEK_NAME,
LEAPS_EAT_NAME,
}
return -1;
}
-
len--;
in++;
}
wsi->act_ext_user[n], arg, len);
if (m < 0) {
lwsl_ext("Ext '%s' failed to handle callback %d!\n",
- wsi->active_extensions[n]->name, reason);
+ wsi->active_extensions[n]->name, reason);
return -1;
}
if (m > handled)
int
lws_issue_raw_ext_access(struct lws *wsi, unsigned char *buf, size_t len)
{
- int ret;
struct lws_tokens eff_buf;
- int m;
- int n = 0;
+ int ret, m, n = 0;
eff_buf.token = (char *)buf;
eff_buf.token_len = len;
}
int
-lws_any_extension_handled(struct lws *wsi,
- enum lws_extension_callback_reasons r,
+lws_any_extension_handled(struct lws *wsi, enum lws_extension_callback_reasons r,
void *v, size_t len)
{
- int n;
- int handled = 0;
struct lws_context *context = wsi->context;
+ int n, handled = 0;
/* maybe an extension will take care of it for us */
const struct lws_protocols *protocol, int reason)
{
struct lws_context_per_thread *pt = &context->pt[0];
- struct lws *wsi;
unsigned int n, m = context->count_threads;
+ struct lws *wsi;
while (m--) {
for (n = 0; n < pt->fds_count; n++) {
if (!wsi)
continue;
if (wsi->protocol == protocol)
- protocol->callback(wsi, reason, wsi->user_space, NULL, 0);
+ protocol->callback(wsi, reason, wsi->user_space,
+ NULL, 0);
}
pt++;
}
lws_is_final_fragment(struct lws *wsi)
{
lwsl_info("%s: final %d, rx pk length %d, draining %d", __func__,
- wsi->u.ws.final, wsi->u.ws.rx_packet_length, wsi->u.ws.rx_draining_ext);
+ wsi->u.ws.final, wsi->u.ws.rx_packet_length,
+ wsi->u.ws.rx_draining_ext);
return wsi->u.ws.final && !wsi->u.ws.rx_packet_length && !wsi->u.ws.rx_draining_ext;
}
LWS_EXT_CB_CONSTRUCT = 4,
LWS_EXT_CB_CLIENT_CONSTRUCT = 5,
LWS_EXT_CB_CHECK_OK_TO_REALLY_CLOSE = 6,
- LWS_EXT_CB_CHECK_OK_TO_PROPOSE_EXTENSION = 7,
+ LWS_EXT_CB_CHECK_OK_TO_PROPOSE_EXTENSION = 7,
LWS_EXT_CB_DESTROY = 8,
LWS_EXT_CB_DESTROY_ANY_WSI_CLOSING = 9,
LWS_EXT_CB_ANY_WSI_ESTABLISHED = 10,
/* always last real token index*/
WSI_TOKEN_COUNT,
- /* parser state additions */
+ /* parser state additions, no storage associated */
WSI_TOKEN_NAME_PART,
WSI_TOKEN_SKIPPING,
WSI_TOKEN_SKIPPING_SAW_CR,
/*
* The internal exts are part of the public abi
- * If we add more extensions, publish the callback here
+ * If we add more extensions, publish the callback here ------v
*/
extern int lws_extension_callback_pm_deflate(
#define lws_get_internal_extensions() NULL
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_ext_parse_options(const struct lws_extension *ext, struct lws *wsi,
- void *ext_user, const struct lws_ext_options *opts, const char *o, int len);
+ void *ext_user, const struct lws_ext_options *opts,
+ const char *o, int len);
#endif
/*
* This is just used to interrupt poll waiting
* we don't have to do anything with it.
*/
-static void lws_sigusr2(int sig)
+static void
+lws_sigusr2(int sig)
{
}
}
-static void sigpipe_handler(int x)
+static void
+sigpipe_handler(int x)
{
}
switch (n) {
case LWS_SSL_CAPABLE_ERROR:
-// lwsl_err("%s: wsi %p: LWS_SSL_CAPABLE_ERROR\n", __func__,
-// (void *)wsi);
/* we're going to close, let close know sends aren't possible */
wsi->socket_is_permanently_unusable = 1;
return -1;
lws_rx_sm(struct lws *wsi, unsigned char c)
{
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
- struct lws_tokens eff_buf;
- int ret = 0, n, rx_draining_ext = 0;
int callback_action = LWS_CALLBACK_RECEIVE;
+ int ret = 0, n, rx_draining_ext = 0;
+ struct lws_tokens eff_buf;
+
if (wsi->socket_is_permanently_unusable)
return -1;
case LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED:
-
assert(wsi->u.ws.rx_ubuf);
if (wsi->u.ws.rx_ubuf_head + LWS_PRE >=
int
_lws_change_pollfd(struct lws *wsi, int _and, int _or, struct lws_pollargs *pa)
{
- struct lws_context *context;
struct lws_context_per_thread *pt;
+ struct lws_context *context;
int ret = 0, pa_events = 1;
struct lws_pollfd *pfd;
int sampled_tid, tid;
struct lws_pollargs pa1;
#endif
- lwsl_info("%s: %p: tsi=%d, sock=%d, pos-in-fds=%d\n",
+ lwsl_debug("%s: %p: tsi=%d, sock=%d, pos-in-fds=%d\n",
__func__, wsi, wsi->tsi, wsi->sock, pt->fds_count);
if ((unsigned int)pt->fds_count >= context->fd_limit_per_thread) {
wsi->position_in_fds_table = pt->fds_count;
pt->fds[pt->fds_count].fd = wsi->sock;
pt->fds[pt->fds_count].events = LWS_POLLIN;
-
- /* don't apply this logic to the listening socket... */
-// if (wsi->mode != LWSCM_SERVER_LISTENER && !wsi->u.hdr.ah)
-// pt->fds[pt->fds_count].events = 0;
-
pa.events = pt->fds[pt->fds_count].events;
lws_plat_insert_socket_into_fds(context, wsi);
int
remove_wsi_socket_from_fds(struct lws *wsi)
{
- int m, ret = 0;
- struct lws *end_wsi;
struct lws_pollargs pa = { wsi->sock, 0, 0 };
#ifndef LWS_NO_SERVER
struct lws_pollargs pa1;
#endif
struct lws_context *context = wsi->context;
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
+ struct lws *end_wsi;
+ int m, ret = 0;
#if !defined(_WIN32) && !defined(MBED_OPERATORS)
if (wsi->sock > context->max_fds) {
int
lws_change_pollfd(struct lws *wsi, int _and, int _or)
{
- struct lws_context *context;
struct lws_context_per_thread *pt;
- int ret = 0;
+ struct lws_context *context;
struct lws_pollargs pa;
+ int ret = 0;
if (!wsi || !wsi->protocol || wsi->position_in_fds_table < 0)
return 1;
const struct lws_protocols *protocol)
{
const struct lws_context_per_thread *pt = &context->pt[0];
- struct lws *wsi;
unsigned int n, m = context->count_threads;
+ struct lws *wsi;
while (m--) {
for (n = 0; n < pt->fds_count; n++) {
const struct lws_extension *ext;
char ext_name[128];
int ext_count = 0;
- char *c;//, *start;
int more = 1;
char ignore;
int n, m;
+ char *c;
/*
* Figure out which extensions the client has that we want to
wsi->count_act_ext = 0;
n = 0;
ignore = 0;
-// start = c;
while (more) {
if (*c && (*c != ',' && *c != '\t')) {
ext++;
}
- //start = c;
n = 0;
}
{
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
unsigned char hash[20];
- int n;
+ int n, accept_len;
char *response;
char *p;
- int accept_len;
if (!lws_hdr_total_length(wsi, WSI_TOKEN_HOST) ||
!lws_hdr_total_length(wsi, WSI_TOKEN_KEY)) {
lws_SHA1(pt->serv_buf, n, hash);
- accept_len = lws_b64_encode_string((char *)hash, 20,
- (char *)pt->serv_buf, LWS_MAX_SOCKET_IO_BUF);
+ accept_len = lws_b64_encode_string((char *)hash, 20, (char *)pt->serv_buf,
+ LWS_MAX_SOCKET_IO_BUF);
if (accept_len < 0) {
lwsl_warn("Base64 encoded hash too long\n");
goto bail;
#if LWS_POSIX
struct sockaddr_in serv_addr4;
socklen_t len = sizeof(struct sockaddr);
+ int n, opt = 1, limit = 1;
struct sockaddr_in sin;
struct sockaddr *v;
- int n, opt = 1, limit = 1;
#endif
- int m = 0;
lws_sockfd_type sockfd;
struct lws *wsi;
+ int m = 0;
/* set up our external listening socket we serve on */
lws_adopt_socket(struct lws_context *context, lws_sockfd_type accept_fd)
{
struct lws *new_wsi = lws_create_new_server_wsi(context);
+
if (!new_wsi) {
compatible_close(accept_fd);
return NULL;
lws_server_socket_service(struct lws_context *context, struct lws *wsi,
struct lws_pollfd *pollfd)
{
- lws_sockfd_type accept_fd = LWS_SOCK_INVALID;
struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
+ lws_sockfd_type accept_fd = LWS_SOCK_INVALID;
#if LWS_POSIX
struct sockaddr_in cli_addr;
socklen_t clilen;
lws_libev_io(wsi, LWS_EV_STOP | LWS_EV_WRITE);
if (wsi->state != LWSS_HTTP_ISSUING_FILE) {
- n = user_callback_handle_rxflow(
- wsi->protocol->callback,
+ n = user_callback_handle_rxflow(wsi->protocol->callback,
wsi, LWS_CALLBACK_HTTP_WRITEABLE,
wsi->user_space, NULL, 0);
if (n < 0) {
#if LWS_POSIX
/* find canonical hostname */
gethostname((char *)context->canonical_hostname,
- sizeof(context->canonical_hostname) - 1);
+ sizeof(context->canonical_hostname) - 1);
lwsl_notice(" canonical_hostname = %s\n", context->canonical_hostname);
#else
*/
eff_buf.token = (char *)pt->serv_buf;
-drain:
+drain:
do {
more = 0;
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
- lwsl_notice("%s\n(C) Copyright 2016 Andy Green <andy@warmcat.com> - "
- "licensed under LGPL2.1\n", argv[0]);
+ lwsl_notice("libwebsockets fuzzing proxy - license LGPL2.1+SLE\n");
+ lwsl_notice("(C) Copyright 2016 Andy Green <andy@warmcat.com>\n");
/* listen on local side */
lws_context_destroy(context);
pthread_mutex_destroy(&lock_established_conns);
-
lwsl_notice("libwebsockets-test-server exited cleanly\n");
#ifndef _WIN32
projects / platform / upstream / libwebsockets.git / commitdiff