/*

 * 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"

#if defined(LWS_WITH_SERVER)

static void

lws_sul_tls_cb(lws_sorted_usec_list_t *sul)

{

  struct lws_context_per_thread *pt = lws_container_of(sul,

      struct lws_context_per_thread, sul_tls);

  lws_tls_check_all_cert_lifetimes(pt->context);

  __lws_sul_insert_us(&pt->pt_sul_owner[LWSSULLI_MISS_IF_SUSPENDED],

          &pt->sul_tls,

          (lws_usec_t)24 * 3600 * LWS_US_PER_SEC);

}

int

lws_context_init_server_ssl(const struct lws_context_creation_info *info,

          struct lws_vhost *vhost)

{

  struct lws_context *context = vhost->context;

  lws_fakewsi_def_plwsa(&vhost->context->pt[0]);

  lws_fakewsi_prep_plwsa_ctx(vhost->context);

  if (!lws_check_opt(info->options,

         LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT)) {

    vhost->tls.use_ssl = 0;

    return 0;

  }

  /*

   * If he is giving a server cert, take it as a sign he wants to use

   * it on this vhost.  User code can leave the cert filepath NULL and

   * set the LWS_SERVER_OPTION_CREATE_VHOST_SSL_CTX option itself, in

   * which case he's expected to set up the cert himself at

   * LWS_CALLBACK_OPENSSL_LOAD_EXTRA_SERVER_VERIFY_CERTS, which

   * provides the vhost SSL_CTX * in the user parameter.

   */

  if (info->ssl_cert_filepath || info->server_ssl_cert_mem)

    vhost->options |= LWS_SERVER_OPTION_CREATE_VHOST_SSL_CTX;

  if (info->port != CONTEXT_PORT_NO_LISTEN) {

    vhost->tls.use_ssl = lws_check_opt(vhost->options,

          LWS_SERVER_OPTION_CREATE_VHOST_SSL_CTX);

    if (vhost->tls.use_ssl && info->ssl_cipher_list)

      lwsl_notice(" SSL ciphers: '%s'\n",

            info->ssl_cipher_list);

    lwsl_info(" Vhost '%s' using %sTLS mode\n",

          vhost->name, vhost->tls.use_ssl ? "" : "non-");

  }

  /*

   * give him a fake wsi with context + vhost set, so he can use

   * lws_get_context() in the callback

   */

  plwsa->vhost = vhost; /* not a real bound wsi */

  /*

   * as a server, if we are requiring clients to identify themselves

   * then set the backend up for it

   */

  if (lws_check_opt(info->options,

        LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT))

    /* Normally SSL listener rejects non-ssl, optionally allow */

    vhost->tls.allow_non_ssl_on_ssl_port = 1;

  /*

   * give user code a chance to load certs into the server

   * allowing it to verify incoming client certs

   */

  if (vhost->tls.use_ssl) {

    if (lws_tls_server_vhost_backend_init(info, vhost, (struct lws *)plwsa))

      return -1;

    if (vhost->tls.ssl_ctx && !vhost->tls.active_ctx_ref)

      vhost->tls.active_ctx_ref = lws_tls_ctx_ref_create(vhost, vhost->tls.ssl_ctx);

    lws_tls_server_client_cert_verify_config(vhost);

    if (vhost->protocols[0].callback((struct lws *)plwsa,

          LWS_CALLBACK_OPENSSL_LOAD_EXTRA_SERVER_VERIFY_CERTS,

          vhost->tls.ssl_ctx, vhost, 0))

      return -1;

  }

  if (vhost->tls.use_ssl)

    lws_context_init_alpn(vhost);

  /* check certs in a few seconds (after protocol init) and then once a day */

  context->pt[0].sul_tls.cb = lws_sul_tls_cb;

  __lws_sul_insert_us(&context->pt[0].pt_sul_owner[LWSSULLI_MISS_IF_SUSPENDED],

          &context->pt[0].sul_tls,

          (lws_usec_t)5 * LWS_US_PER_SEC);

  return 0;

}

#endif

#if defined(LWS_WITH_TCP_TLS)

int

lws_tls_server_accept_completed(struct lws *wsi, int n)

{

  struct lws_context *context = wsi->a.context;

  struct lws_vhost *vh;

  lwsl_info("SSL_accept says %d\n", n);

  switch (n) {

  case LWS_SSL_CAPABLE_DONE:

    lws_tls_restrict_return_handshake(wsi);

    break;

  case LWS_SSL_CAPABLE_ERROR:

    lws_tls_restrict_return_handshake(wsi);

    lwsl_info("%s: SSL_accept failed socket %u: %d\n",

        __func__, wsi->desc.sockfd, n);

    wsi->socket_is_permanently_unusable = 1;

    return 1;

  default: /* MORE_SERVICE */

    // lwsl_notice("%s: %s: MORE_SERVICE (%d), setting LRS_SSL_ACK_PENDING\n", __func__, lws_wsi_tag(wsi), n);

    if (n == LWS_SSL_CAPABLE_MORE_SERVICE_READ) {

      if (lws_change_pollfd(wsi, 0, LWS_POLLIN))

        return 1;

    } else if (n == LWS_SSL_CAPABLE_MORE_SERVICE_WRITE) {

      if (lws_change_pollfd(wsi, 0, LWS_POLLOUT))

        return 1;

    }

    lwsi_set_state(wsi, LRS_SSL_ACK_PENDING);

    return 0;

  }

  /* adapt our vhost to match the SNI SSL_CTX that was chosen */

  vh = lws_vhost_first(context);

  while (vh) {

    if (!vh->being_destroyed && wsi->tls.ssl &&

        vh->tls.ssl_ctx == lws_tls_ctx_from_wsi(wsi)) {

      lwsl_info("setting wsi to vh %s\n", vh->name);

      lws_vhost_bind_wsi(vh, wsi);

      break;

    }

    vh = lws_vhost_next(vh);

  }

  /* OK, we are accepted... give him some time to negotiate */

  lws_set_timeout(wsi, PENDING_TIMEOUT_ESTABLISH_WITH_SERVER,

      (int)context->timeout_secs);

  lwsi_set_state(wsi, LRS_ESTABLISHED);

  if (lws_tls_server_conn_alpn(wsi)) {

    lwsl_warn("%s: fail on alpn\n", __func__);

    return 1; /* fail */

  }

  lwsl_debug("accepted new SSL conn\n");

  /* continue establishment */

  wsi->rxflow_change_to = LWS_RXFLOW_ALLOW;

  return 0;

}

int

lws_server_socket_service_ssl(struct lws *wsi, lws_sockfd_type accept_fd, char from_pollin)

{

  struct lws_context *context = wsi->a.context;

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

  ssize_t s;

  int n;

  if (!LWS_SSL_ENABLED(wsi->a.vhost))

    return 0;

  switch (lwsi_state(wsi)) {

  case LRS_SSL_INIT:

    if (wsi->tls.ssl)

      lwsl_err("%s: leaking ssl\n", __func__);

    if (accept_fd == LWS_SOCK_INVALID)

      assert(0);

    if (lws_tls_restrict_borrow(wsi)) {

      lwsl_err("%s: failed on ssl restriction\n", __func__);

      return 1;

    }

#if defined(LWS_WITH_LATENCY)

    lws_usec_t _ssl_new_start = lws_now_usecs();

#endif

    if (lws_tls_server_new_nonblocking(wsi, accept_fd)) {

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

      if (accept_fd != LWS_SOCK_INVALID)

        compatible_close(accept_fd);

      lws_tls_restrict_return(wsi);

      goto fail;

    }

#if defined(LWS_WITH_LATENCY)

    {

      unsigned int ms = (unsigned int)((lws_now_usecs() - _ssl_new_start) / 1000);

      if (ms > 2)

        lws_latency_note(pt, _ssl_new_start, 2000, "sslnew:%dms", ms);

    }

#endif

    /*

     * we are not accepted yet, but we need to enter ourselves

     * as a live connection.  That way we can retry when more

     * pieces come if we're not sorted yet

     */

    lwsi_set_state(wsi, LRS_SSL_ACK_PENDING);

    lws_pt_lock(pt, __func__);

    if (__insert_wsi_socket_into_fds(context, wsi)) {

      lwsl_err("%s: failed to insert into fds\n", __func__);

      goto fail;

    }

    lws_pt_unlock(pt);

    lws_set_timeout(wsi, PENDING_TIMEOUT_SSL_ACCEPT,

        (int)context->timeout_secs);

    lwsl_debug("inserted SSL accept into fds, trying SSL_accept\n");

    /* fallthru */

  case LRS_SSL_ACK_PENDING:

    // lwsl_notice("%s: %s: entering LRS_SSL_ACK_PENDING, from_pollin=%d\n", __func__, lws_wsi_tag(wsi), from_pollin);

    if (lws_change_pollfd(wsi, LWS_POLLOUT, 0)) {

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

      goto fail;

    }

    if (wsi->a.vhost->tls.allow_non_ssl_on_ssl_port && !wsi->skip_fallback) {

      /*

       * We came here by POLLIN, so there is supposed to be

       * something to read...

       */

      s = recv(wsi->desc.sockfd, (char *)pt->serv_buf,

         context->pt_serv_buf_size, MSG_PEEK);

      /*

       * We have LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT..

       * this just means don't hang up on him because of no

       * tls hello... what happens next is driven by

       * additional option flags:

       *

       * none: fail the connection

       *

       * LWS_SERVER_OPTION_REDIRECT_HTTP_TO_HTTPS:

       *     Destroy the TLS, issue a redirect using plaintext

       *     http (this may not be accepted by a client that

       *     has visited the site before and received an STS

       *     header).

       *

       * LWS_SERVER_OPTION_ALLOW_HTTP_ON_HTTPS_LISTENER:

       *     Destroy the TLS, continue and serve normally

       *     using http

       *

       * LWS_SERVER_OPTION_FALLBACK_TO_APPLY_LISTEN_ACCEPT_CONFIG:

       *     Destroy the TLS, apply whatever role and protocol

       *     were told in the vhost info struct

       *     .listen_accept_role / .listen_accept_protocol and

       *     continue with that

       */

      if (s >= 1 && pt->serv_buf[0] >= ' ') {

        /*

        * TLS content-type for Handshake is 0x16, and

        * for ChangeCipherSpec Record, it's 0x14

        *

        * A non-ssl session will start with the HTTP

        * method in ASCII.  If we see it's not a legit

        * SSL handshake kill the SSL for this

        * connection and try to handle as a HTTP

        * connection upgrade directly.

        */

        wsi->tls.use_ssl = 0;

        lws_tls_server_abort_connection(wsi);

        /*

         * care... this creates wsi with no ssl when ssl

         * is enabled and normally mandatory

         */

        wsi->tls.ssl = NULL;

        if (lws_check_opt(wsi->a.vhost->options,

            LWS_SERVER_OPTION_REDIRECT_HTTP_TO_HTTPS)) {

          lwsl_info("%s: redirecting from http "

              "to https\n", __func__);

          wsi->tls.redirect_to_https = 1;

          goto notls_accepted;

        }

        if (lws_check_opt(wsi->a.vhost->options,

        LWS_SERVER_OPTION_ALLOW_HTTP_ON_HTTPS_LISTENER)) {

          lwsl_info("%s: allowing unencrypted "

              "http service on tls port\n",

              __func__);

          goto notls_accepted;

        }

        if (lws_check_opt(wsi->a.vhost->options,

        LWS_SERVER_OPTION_FALLBACK_TO_APPLY_LISTEN_ACCEPT_CONFIG)) {

          if (lws_http_to_fallback(wsi, NULL, 0))

            goto fail;

          lwsl_info("%s: allowing non-tls "

              "fallback\n", __func__);

          goto notls_accepted;

        }

        char ipbuf[64];

        lws_get_peer_simple(wsi, ipbuf, sizeof(ipbuf));

        lwsl_notice("%s: client did not send a valid "

              "tls hello (default vhost %s) from %s\n",

              __func__, wsi->a.vhost->name, ipbuf);

        lwsl_hexdump_notice(pt->serv_buf, s > 256 ? 256 : (size_t)s);

        goto fail;

      }

      if (!s) {

        /*

         * POLLIN but nothing to read is supposed to

         * mean the connection is gone, we should

         * fail out...

         *

         */

        lwsl_debug("%s: PEEKed 0 (from_pollin %d)\n",

            __func__, from_pollin);

        if (!from_pollin) {

          /*

           * If this wasn't actually info from a

           * pollin let it go around again until

           * either data came or we still get told

           * zero length peek AND POLLIN

           */

          if (lws_change_pollfd(wsi, 0, LWS_POLLIN)) {

            lwsl_err("%s: change_pollfd failed\n",

                __func__);

            return -1;

          }

          lwsl_info("SSL_ERROR_WANT_READ\n");

          return 0;

        }

        /*

         * treat as remote closed

         */

        goto fail;

      }

      if (s < 0 && (LWS_ERRNO == LWS_EAGAIN ||

              LWS_ERRNO == LWS_EWOULDBLOCK)) {

        /*

         * well, we get no way to know ssl or not

         * so go around again waiting for something

         * to come and give us a hint, or timeout the

         * connection.

         */

        // lwsl_notice("%s: %s: punting (no data peeked)\n", __func__, lws_wsi_tag(wsi));

        if (lws_change_pollfd(wsi, 0, LWS_POLLIN)) {

          lwsl_err("%s: change_pollfd failed\n",

              __func__);

          return -1;

        }

        lwsl_info("SSL_ERROR_WANT_READ\n");

        return 0;

      }

    }

    /* normal SSL connection processing path */

#if defined(LWS_WITH_ASYNC_QUEUE)

    if (lwsi_state(wsi) != LRS_AWAITING_SSL_ACCEPT && context->count_async_threads) {

      struct lws_async_job *job;

      if (lws_change_pollfd(wsi, LWS_POLLIN | LWS_POLLOUT, 0)) {

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

        goto fail;

      }

      job = lws_zalloc(sizeof(*job), "async ssl job");

      if (!job)

        goto fail;

      job->wsi = wsi;

      wsi->async_worker_job = job;

      job->type = LWS_AQ_SSL_ACCEPT;

      //lwsl_notice("%s: %s: QUEUING LWS_AQ_SSL_ACCEPT\n", __func__, lws_wsi_tag(wsi));

      pthread_mutex_lock(&context->async_worker_mutex);

      if (lws_dll2_count(&context->async_worker_waiting) >=

          (uint32_t)(context->count_async_threads * 10)) {

        pthread_mutex_unlock(&context->async_worker_mutex);

        lws_free(job);

        wsi->async_worker_job = NULL;

        goto fail;

      }

      lws_dll2_add_tail(&job->list, &context->async_worker_waiting);

      if (context->async_worker_threads_idle == 0 &&

          context->async_worker_threads_active < context->count_async_threads) {

        pthread_t pt_th;

        context->async_worker_threads_active++;

        if (pthread_create(&pt_th, NULL, lws_async_worker_worker, context) == 0)

          pthread_detach(pt_th);

        else

          context->async_worker_threads_active--;

      }

      /* wake up any idle worker threads */

      pthread_cond_signal(&context->async_worker_cond);

      pthread_mutex_unlock(&context->async_worker_mutex);

      lwsi_set_state(wsi, LRS_AWAITING_SSL_ACCEPT);

      return 0;

    }

#endif

    errno = 0;

#if defined(LWS_WITH_LATENCY)

    lws_usec_t _ssl_acc_start = lws_now_usecs();

#endif

    n = lws_tls_server_accept(wsi);

#if defined(LWS_WITH_LATENCY)

    {

      unsigned int ms = (unsigned int)((lws_now_usecs() - _ssl_acc_start) / 1000);

      if (ms > 2)

        lws_latency_note(pt, _ssl_acc_start, 2000, "sslacc:%dms", ms);

    }

#endif

    if (lws_tls_server_accept_completed(wsi, n))

      goto fail;

    if (lwsi_state(wsi) != LRS_ESTABLISHED)

      return 0;

    break;

  default:

    break;

  }

  return 0;

notls_accepted:

  lwsi_set_state(wsi, LRS_ESTABLISHED);

  return 0;

fail:

  return 1;

}

#endif