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