/*

 * 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, (int)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, lws_ptr_diff_size_t(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, lws_ptr_diff_size_t(end, *p))) {

            *p += lws_snprintf(*p,

                   lws_ptr_diff_size_t(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__);

  /*

   * Switch roles if we're upgrading away from http

   */

  if (!wsi->h2_stream_carries_ws) {

    lws_role_transition(wsi, LWSIFR_SERVER, LRS_ESTABLISHED,

            &role_ops_ws);

#if defined(LWS_WITH_SECURE_STREAMS) && defined(LWS_WITH_SERVER)

    /*

     * If we're a SS server object, we have to switch to ss-ws

     * protocol handler too

     */

    if (wsi->a.vhost->ss_handle) {

      lwsl_info("%s: %s switching to ws protocol\n",

          __func__, lws_ss_tag(wsi->a.vhost->ss_handle));

      wsi->a.protocol = &protocol_secstream_ws;

      /*

       * inform the SS user code that this has done a one-way

       * upgrade to some other protocol... it will likely

       * want to treat subsequent payloads differently

       */

      (void)lws_ss_event_helper(wsi->a.vhost->ss_handle,

            LWSSSCS_SERVER_UPGRADE);

    }

#endif

  }

  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 = (uint8_t)

             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: %s: dropping ah on ws upgrade\n", __func__, lws_wsi_tag(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 = (unsigned int)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 = (unsigned int)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;

  }

#if defined(LWS_WITH_SECURE_STREAMS) && defined(LWS_WITH_SERVER)

  if (wsi->a.vhost->ss_handle) {

    lws_ss_handle_t *sssh = wsi->a.vhost->ss_handle;

    /*

     * At the moment, once we see it's a ss ws server, whatever

     * he asked for we bind him to the ss-ws protocol handler.

     *

     * In the response subprotocol header, we need to name

     *

     * sssh->policy->u.http.u.ws.subprotocol

     *

     * though...

     */

    if (sssh->policy->u.http.u.ws.subprotocol) {

      pcol = lws_vhost_name_to_protocol(wsi->a.vhost,

                "lws-secstream-ws");

      if (pcol) {

        lws_bind_protocol(wsi, pcol, "ss ws upg pcol");

        goto alloc_ws;

      }

    }

  }

#endif

  /* 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, (unsigned int)n, hash);

  accept_len = lws_b64_encode_string((char *)hash, 20,

      (char *)pt->serv_buf, (int)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

#if defined(LWS_WITH_SECURE_STREAMS) && defined(LWS_WITH_SERVER)

    {

      lws_ss_handle_t *sssh = wsi->a.vhost->ss_handle;

      /*

       * At the moment, once we see it's a ss ws server, whatever

       * he asked for we bind him to the ss-ws protocol handler.

       *

       * In the response subprotocol header, we need to name

       *

       * sssh->policy->u.http.u.ws.subprotocol

       *

       * though...

       */

      if (sssh && sssh->policy &&

          sssh->policy->u.http.u.ws.subprotocol)

        prot = sssh->policy->u.http.u.ws.subprotocol;

    }

#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, lws_ptr_diff_size_t(p, response),

          LWS_WRITE_HTTP_HEADERS);

  if (n != lws_ptr_diff(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 = (unsigned 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 = (unsigned 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 = (int)avail;

  pmdrx.eb_out.token = buffer;

  pmdrx.eb_out.len = (int)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 = (int)(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 (int)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 (int)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,

           (unsigned int)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, (size_t)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,

            (unsigned int)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