/*

 * libwebsockets - small server side websockets and web server implementation

 *

 * Copyright (C) 2019 - 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.

 *

 * This is the glue that wires up raw-socket to Secure Streams.

 */

#include <private-lib-core.h>

int

secstream_raw(struct lws *wsi, enum lws_callback_reasons reason, void *user,

        void *in, size_t len)

{

#if defined(LWS_WITH_SERVER)

  struct lws_context_per_thread *pt = &wsi->a.context->pt[(int)wsi->tsi];

#endif

  lws_ss_handle_t *h = (lws_ss_handle_t *)lws_get_opaque_user_data(wsi);

  uint8_t buf[LWS_PRE + 1520], *p = &buf[LWS_PRE],

    *end = &buf[sizeof(buf) - 1];

  lws_ss_state_return_t r;

  size_t buflen;

  int f = 0;

  switch (reason) {

  case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:

    assert(h);

    assert(h->policy);

    lwsl_info("%s: %s, %s CLIENT_CONNECTION_ERROR: %s\n", __func__,

        lws_ss_tag(h), h->policy->streamtype, in ? (char *)in : "(null)");

#if defined(LWS_WITH_CONMON)

    lws_conmon_ss_json(h);

#endif

    r = lws_ss_event_helper(h, LWSSSCS_UNREACHABLE);

    if (r == LWSSSSRET_DESTROY_ME)

      return _lws_ss_handle_state_ret_CAN_DESTROY_HANDLE(r, wsi, &h);

    h->wsi = NULL;

    r = lws_ss_backoff(h);

    if (r != LWSSSSRET_OK)

      return _lws_ss_handle_state_ret_CAN_DESTROY_HANDLE(r, wsi, &h);

    break;

  case LWS_CALLBACK_RAW_CLOSE:

    if (!h)

      break;

    lws_sul_cancel(&h->sul_timeout);

#if defined(LWS_WITH_CONMON)

    lws_conmon_ss_json(h);

#endif

    lwsl_info("%s: %s, %s RAW_CLOSE\n", __func__, lws_ss_tag(h),

        h->policy ? h->policy->streamtype : "no policy");

    h->wsi = NULL;

#if defined(LWS_WITH_SERVER)

    lws_pt_lock(pt, __func__);

    lws_dll2_remove(&h->cli_list);

    lws_pt_unlock(pt);

#endif

    /* wsi is going down anyway */

    r = lws_ss_event_helper(h, LWSSSCS_DISCONNECTED);

    if (r == LWSSSSRET_DESTROY_ME)

      return _lws_ss_handle_state_ret_CAN_DESTROY_HANDLE(r, wsi, &h);

    if (h->policy && !(h->policy->flags & LWSSSPOLF_OPPORTUNISTIC) &&

#if defined(LWS_WITH_SERVER)

          !(h->info.flags & LWSSSINFLAGS_ACCEPTED) && /* not server */

#endif

        !h->txn_ok && !wsi->a.context->being_destroyed) {

      r = lws_ss_backoff(h);

      if (r != LWSSSSRET_OK)

        return _lws_ss_handle_state_ret_CAN_DESTROY_HANDLE(r, wsi, &h);

      break;

    }

    break;

  case LWS_CALLBACK_RAW_CONNECTED:

    lwsl_info("%s: RAW_CONNECTED\n", __func__);

    h->retry = 0;

    h->seqstate = SSSEQ_CONNECTED;

    lws_sul_cancel(&h->sul);

#if defined(LWS_WITH_SYS_METRICS)

    /*

     * If any hanging caliper measurement, dump it, and free any tags

     */

    lws_metrics_caliper_report_hist(h->cal_txn, (struct lws *)NULL);

#endif

    r = lws_ss_event_helper(h, LWSSSCS_CONNECTED);

    if (r != LWSSSSRET_OK)

      return _lws_ss_handle_state_ret_CAN_DESTROY_HANDLE(r, wsi, &h);

    lws_validity_confirmed(wsi);

    break;

  case LWS_CALLBACK_RAW_ADOPT:

    lwsl_info("%s: RAW_ADOPT\n", __func__);

    break;

       /* chunks of chunked content, with header removed */

       case LWS_CALLBACK_RAW_RX_FILE:

               in = p;

               f = (int)read((int)(intptr_t)wsi->desc.filefd, p, sizeof(buf) - LWS_PRE);

               if (f < 0)

                       return 0;

               len = (unsigned int)f;

               /* fallthru */

  case LWS_CALLBACK_RAW_RX:

    if (!h || !h->info.rx)

      return 0;

    r = h->info.rx(ss_to_userobj(h), (const uint8_t *)in, len, 0);

    if (r != LWSSSSRET_OK)

      return _lws_ss_handle_state_ret_CAN_DESTROY_HANDLE(r, wsi, &h);

    return 0; /* don't passthru */

  case LWS_CALLBACK_RAW_WRITEABLE:

    lwsl_info("%s: RAW_WRITEABLE\n", __func__);

    if (!h || !h->info.tx)

      return 0;

    buflen = lws_ptr_diff_size_t(end, p);

    r = h->info.tx(ss_to_userobj(h),  h->txord++, p, &buflen, &f);

    if (r == LWSSSSRET_TX_DONT_SEND)

      return 0;

    if (r < 0)

      return _lws_ss_handle_state_ret_CAN_DESTROY_HANDLE(r, wsi, &h);

    /*

     * flags are ignored with raw, there are no protocol payload

     * boundaries, just an arbitrarily-fragmented bytestream

     */

    p += buflen;

    if (lws_write(wsi, buf + LWS_PRE, lws_ptr_diff_size_t(p, buf + LWS_PRE),

       LWS_WRITE_HTTP) != lws_ptr_diff(p, buf + LWS_PRE)) {

      lwsl_err("%s: write failed\n", __func__);

      return -1;

    }

    lws_set_timeout(wsi, 0, 0);

    break;

  default:

    break;

  }

  return 0;

}

static int

secstream_connect_munge_raw(lws_ss_handle_t *h, char *buf, size_t len,

         struct lws_client_connect_info *i,

         union lws_ss_contemp *ct)

{

  i->method = "RAW";

  return 0;

}

const struct lws_protocols protocol_secstream_raw = {

  "lws-secstream-raw",

  secstream_raw,

  0,

  0,

  0, NULL, 0

};

const struct ss_pcols ss_pcol_raw = {

  "raw",

  "",

  &protocol_secstream_raw,

  secstream_connect_munge_raw,

  NULL, NULL

};