/*

     This file is part of libmicrohttpd

     Copyright (C) 2016 Christian Grothoff

     libmicrohttpd is free software; you can redistribute it and/or modify

     it under the terms of the GNU General Public License as published

     by the Free Software Foundation; either version 3, or (at your

     option) any later version.

     libmicrohttpd is distributed in the hope that it will be useful, but

     WITHOUT ANY WARRANTY; without even the implied warranty of

     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

     General Public License for more details.

     You should have received a copy of the GNU General Public License

     along with libmicrohttpd; see the file COPYING.  If not, write to the

     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

     Boston, MA 02110-1301, USA.

*/

/**

 * @file test_upgrade.c

 * @brief  Testcase for libmicrohttpd upgrading a connection

 * @author Christian Grothoff

 * @author Karlson2k (Evgeny Grin)

 */

#include "mhd_options.h"

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <pthread.h>

#include <stdlib.h>

#include <stddef.h>

#ifndef WINDOWS

#include <unistd.h>

#endif

#ifdef HAVE_STDBOOL_H

#include <stdbool.h>

#endif /* HAVE_STDBOOL_H */

#include "mhd_sockets.h"

#ifdef HAVE_NETINET_IP_H

#include <netinet/ip.h>

#endif /* HAVE_NETINET_IP_H */

#include "platform.h"

#include "microhttpd.h"

#include "test_helpers.h"

#ifdef HTTPS_SUPPORT

#include <gnutls/gnutls.h>

#include "../testcurl/https/tls_test_keys.h"

#if defined(HAVE_FORK) && defined(HAVE_WAITPID)

#include <sys/types.h>

#include <sys/wait.h>

#endif /* HAVE_FORK && HAVE_WAITPID */

#endif /* HTTPS_SUPPORT */

static int verbose = 0;

enum tls_tool

{

  TLS_CLI_NO_TOOL = 0,

  TLS_CLI_GNUTLS,

  TLS_CLI_OPENSSL,

  TLS_LIB_GNUTLS

};

enum tls_tool use_tls_tool;

#if defined(HTTPS_SUPPORT) && defined(HAVE_FORK) && defined(HAVE_WAITPID)

/**

 * Fork child that connects via GnuTLS-CLI to our @a port.  Allows us to

 * talk to our port over a socket in @a sp without having to worry

 * about TLS.

 *

 * @param location where the socket is returned

 * @return -1 on error, otherwise PID of TLS child process

 */

static pid_t

gnutlscli_connect (int *sock,

                 uint16_t port)

{

  pid_t chld;

  int sp[2];

  char destination[30];

  if (0 != socketpair (AF_UNIX,

                       SOCK_STREAM,

                       0,

                       sp))

    return -1;

  chld = fork ();

  if (0 != chld)

    {

      *sock = sp[1];

      MHD_socket_close_chk_ (sp[0]);

      return chld;

    }

  MHD_socket_close_chk_ (sp[1]);

  (void) close (0);

  (void) close (1);

  dup2 (sp[0], 0);

  dup2 (sp[0], 1);

  MHD_socket_close_chk_ (sp[0]);

  if (TLS_CLI_GNUTLS == use_tls_tool)

    {

      snprintf (destination,

                sizeof(destination),

                "%u",

                (unsigned int) port);

      execlp ("gnutls-cli",

              "gnutls-cli",

              "--insecure",

              "-p",

              destination,

              "127.0.0.1",

              (char *) NULL);

    }

  else if (TLS_CLI_OPENSSL == use_tls_tool)

    {

      snprintf (destination,

                sizeof(destination),

                "127.0.0.1:%u",

                (unsigned int) port);

      execlp ("openssl",

              "openssl",

              "s_client",

              "-connect",

              destination,

              "-verify",

              "1",

              (char *) NULL);

    }

  _exit (1);

}

#endif /* HTTPS_SUPPORT && HAVE_FORK && HAVE_WAITPID */

/**

 * Wrapper structure for plain&TLS sockets

 */

struct wr_socket_strc

{

  /**

   * Real network socket

   */

  MHD_socket fd;

  /**

   * Type of this socket

   */

  enum wr_type

  {

    wr_invalid = 0,

    wr_plain = 1,

    wr_tls = 2

  } t;

#ifdef HTTPS_SUPPORT

  /**

   * TLS credentials

   */

  gnutls_certificate_credentials_t tls_crd;

  /**

   * TLS session.

   */

  gnutls_session_t tls_s;

  /**

   * TLS handshake already succeed?

   */

  bool tls_connected;

#endif

};

/**

 * Pseudo type for plain&TLS sockets

 */

typedef struct wr_socket_strc* wr_socket;

/**

 * Invalid value of wr_socket

 */

#define WR_BAD (NULL)

/**

 * Get underlying real socket.

 * @return FD of real socket

 */

#define wr_fd(s) ((s)->fd)

/**

 * Create wr_socket with plain TCP underlying socket

 * @return created socket on success, WR_BAD otherwise

 */

static wr_socket

wr_create_plain_sckt(void)

{

  wr_socket s = (wr_socket)malloc(sizeof(struct wr_socket_strc));

  if (WR_BAD == s)

    return WR_BAD;

  s->t = wr_plain;

  s->fd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);

  if (MHD_INVALID_SOCKET != s->fd)

    return s;

  free(s);

  return WR_BAD;

}

/**

 * Create wr_socket with TLS TCP underlying socket

 * @return created socket on success, WR_BAD otherwise

 */

static wr_socket

wr_create_tls_sckt(void)

{

#ifdef HTTPS_SUPPORT

  wr_socket s = (wr_socket)malloc(sizeof(struct wr_socket_strc));

  if (WR_BAD == s)

    return WR_BAD;

  s->t = wr_tls;

  s->tls_connected = 0;

  s->fd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);

  if (MHD_INVALID_SOCKET != s->fd)

    {

      if (GNUTLS_E_SUCCESS == gnutls_init (&(s->tls_s), GNUTLS_CLIENT))

        {

          if (GNUTLS_E_SUCCESS == gnutls_set_default_priority (s->tls_s))

            {

              if (GNUTLS_E_SUCCESS == gnutls_certificate_allocate_credentials (&(s->tls_crd)))

                {

                  if (GNUTLS_E_SUCCESS == gnutls_credentials_set (s->tls_s, GNUTLS_CRD_CERTIFICATE, s->tls_crd))

                    {

#if GNUTLS_VERSION_NUMBER+0 >= 0x030109

                      gnutls_transport_set_int (s->tls_s, (int)(s->fd));

#else  /* GnuTLS before 3.1.9 */

                      gnutls_transport_set_ptr (s->tls_s, (gnutls_transport_ptr_t)(intptr_t)(s->fd));

#endif /* GnuTLS before 3.1.9 */

                      return s;

                    }

                  gnutls_certificate_free_credentials (s->tls_crd);

                }

            }

          gnutls_deinit (s->tls_s);

        }

      (void)MHD_socket_close_ (s->fd);

    }

  free(s);

#endif /* HTTPS_SUPPORT */

  return WR_BAD;

}

/**

 * Create wr_socket with plain TCP underlying socket

 * from already created TCP socket.

 * @param plain_sk real TCP socket

 * @return created socket on success, WR_BAD otherwise

 */

static wr_socket

wr_create_from_plain_sckt(MHD_socket plain_sk)

{

  wr_socket s = (wr_socket)malloc(sizeof(struct wr_socket_strc));

  if (WR_BAD == s)

    return WR_BAD;

  s->t = wr_plain;

  s->fd = plain_sk;

  return s;

}

/**

 * Connect socket to specified address.

 * @param s socket to use

 * @param addr address to connect

 * @param length of sturcture pointed by @a addr

 * @return zero on success, -1 otherwise.

 */

static int

wr_connect(wr_socket s,

           const struct sockaddr *addr,

           int length)

{

  if (0 != connect (s->fd, addr, length))

    return -1;

  if (wr_plain == s->t)

    return 0;

#ifdef HTTPS_SUPPORT

  if (wr_tls == s->t)

    {

      /* Do not try handshake here as

       * it require processing on MHD side and

       * when testing with "external" polling,

       * test will call MHD processing only

       * after return from wr_connect(). */

      s->tls_connected = 0;

      return 0;

    }

#endif /* HTTPS_SUPPORT */

  return -1;

}

#ifdef HTTPS_SUPPORT

/* Only to be called from wr_send() and wr_recv() ! */

static bool wr_handshake(wr_socket s)

{

  int res = gnutls_handshake (s->tls_s);

  if (GNUTLS_E_SUCCESS == res)

    s->tls_connected = true;

  else if (GNUTLS_E_AGAIN == res)

    MHD_socket_set_error_ (MHD_SCKT_EAGAIN_);

  else

    MHD_socket_set_error_ (MHD_SCKT_ECONNABORTED_); /* hard error */

  return s->tls_connected;

}

#endif /* HTTPS_SUPPORT */

/**

 * Send data to remote by socket.

 * @param s the socket to use

 * @param buf the buffer with data to send

 * @param len the length of data in @a buf

 * @return number of bytes were sent if succeed,

 *         -1 if failed. Use #MHD_socket_get_error_()

 *         to get socket error.

 */

static ssize_t

wr_send (wr_socket s,

         const void *buf,

         size_t len)

{

  if (wr_plain == s->t)

    return MHD_send_(s->fd, buf, len);

#ifdef HTTPS_SUPPORT

  if (wr_tls == s->t)

    {

      ssize_t ret;

      if (!s->tls_connected && !wr_handshake (s))

        return -1;

      ret = gnutls_record_send (s->tls_s, buf, len);

      if (ret > 0)

        return ret;

      if (GNUTLS_E_AGAIN == ret)

        MHD_socket_set_error_ (MHD_SCKT_EAGAIN_);

      else

        MHD_socket_set_error_ (MHD_SCKT_ECONNABORTED_); /* hard error */

    }

#endif /* HTTPS_SUPPORT */

  return -1;

}

/**

 * Receive data from remote by socket.

 * @param s the socket to use

 * @param buf the buffer to store received data

 * @param len the length of @a buf

 * @return number of bytes were received if succeed,

 *         -1 if failed. Use #MHD_socket_get_error_()

 *         to get socket error.

 */

static ssize_t

wr_recv (wr_socket s,

         void *buf,

         size_t len)

{

  if (wr_plain == s->t)

    return MHD_recv_ (s->fd, buf, len);

#ifdef HTTPS_SUPPORT

  if (wr_tls == s->t)

    {

      ssize_t ret;

      if (!s->tls_connected && !wr_handshake (s))

        return -1;

      ret = gnutls_record_recv (s->tls_s, buf, len);

      if (ret > 0)

        return ret;

      if (GNUTLS_E_AGAIN == ret)

        MHD_socket_set_error_ (MHD_SCKT_EAGAIN_);

      else

        MHD_socket_set_error_ (MHD_SCKT_ECONNABORTED_); /* hard error */

    }

#endif /* HTTPS_SUPPORT */

  return -1;

}

/**

 * Close socket and release allocated resourced

 * @param s the socket to close

 * @return zero on succeed, -1 otherwise

 */

static int

wr_close (wr_socket s)

{

  int ret = (MHD_socket_close_(s->fd)) ? 0 : -1;

#ifdef HTTPS_SUPPORT

  if (wr_tls == s->t)

    {

      gnutls_deinit (s->tls_s);

      gnutls_certificate_free_credentials (s->tls_crd);

    }

#endif /* HTTPS_SUPPORT */

  free(s);

  return ret;

}

/**

 * Thread we use to run the interaction with the upgraded socket.

 */

static pthread_t pt;

/**

 * Will be set to the upgraded socket.

 */

static wr_socket usock;

/**

 * Thread we use to run the interaction with the upgraded socket.

 */

static pthread_t pt_client;

/**

 * Flag set to 1 once the test is finished.

 */

static volatile bool done;

static void

notify_completed_cb (void *cls,

                     struct MHD_Connection *connection,

                     void **con_cls,

                     enum MHD_RequestTerminationCode toe)

{

  (void)cls; (void)connection;  /* Unused. Silent compiler warning. */

  if ( (toe != MHD_REQUEST_TERMINATED_COMPLETED_OK) &&

       (toe != MHD_REQUEST_TERMINATED_CLIENT_ABORT) &&

       (toe != MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN) )

    abort ();

  if (! pthread_equal (**((pthread_t**)con_cls), pthread_self ()))

    abort ();

  free (*con_cls);

  *con_cls = NULL;

}

/**

 * Logging callback.

 *

 * @param cls logging closure (NULL)

 * @param uri access URI

 * @param connection connection handle

 * @return #TEST_PTR

 */

static void *

log_cb (void *cls,

        const char *uri,

        struct MHD_Connection *connection)

{

  pthread_t* ppth;

  (void)cls; (void)connection;  /* Unused. Silent compiler warning. */

  if (0 != strcmp (uri,

                   "/"))

    abort ();

  ppth = (pthread_t*) malloc (sizeof(pthread_t));

  if (NULL == ppth)

    abort();

  *ppth = pthread_self ();

  return (void *) ppth;

}

/**

 * Function to check that MHD properly notifies about starting

 * and stopping.

 *

 * @param cls client-defined closure

 * @param connection connection handle

 * @param socket_context socket-specific pointer where the

 *                       client can associate some state specific

 *                       to the TCP connection; note that this is

 *                       different from the "con_cls" which is per

 *                       HTTP request.  The client can initialize

 *                       during #MHD_CONNECTION_NOTIFY_STARTED and

 *                       cleanup during #MHD_CONNECTION_NOTIFY_CLOSED

 *                       and access in the meantime using

 *                       #MHD_CONNECTION_INFO_SOCKET_CONTEXT.

 * @param toe reason for connection notification

 * @see #MHD_OPTION_NOTIFY_CONNECTION

 * @ingroup request

 */

static void

notify_connection_cb (void *cls,

                      struct MHD_Connection *connection,

                      void **socket_context,

                      enum MHD_ConnectionNotificationCode toe)

{

  static int started;

  (void)cls; (void)connection;  /* Unused. Silent compiler warning. */

  switch (toe)

  {

  case MHD_CONNECTION_NOTIFY_STARTED:

    if (MHD_NO != started)

      abort ();

    started = MHD_YES;

    *socket_context = &started;

    break;

  case MHD_CONNECTION_NOTIFY_CLOSED:

    if (MHD_YES != started)

      abort ();

    if (&started != *socket_context)

      abort ();

    *socket_context = NULL;

    started = MHD_NO;

    break;

  }

}

/**

 * Change socket to blocking.

 *

 * @param fd the socket to manipulate

 * @return non-zero if succeeded, zero otherwise

 */

static void

make_blocking (MHD_socket fd)

{

#if defined(MHD_POSIX_SOCKETS)

  int flags;

  flags = fcntl (fd, F_GETFL);

  if (-1 == flags)

    return;

  if ((flags & ~O_NONBLOCK) != flags)

    if (-1 == fcntl (fd, F_SETFL, flags & ~O_NONBLOCK))

      abort ();

#elif defined(MHD_WINSOCK_SOCKETS)

  unsigned long flags = 1;

  ioctlsocket (fd, FIONBIO, &flags);

#endif /* MHD_WINSOCK_SOCKETS */

}

static void

send_all (wr_socket sock,

          const char *text)

{

  size_t len = strlen (text);

  ssize_t ret;

  size_t off;

  make_blocking (wr_fd (sock));

  for (off = 0; off < len; off += ret)

    {

      ret = wr_send (sock,

                       &text[off],

                       len - off);

      if (0 > ret)

        {

          if (MHD_SCKT_ERR_IS_EAGAIN_ (MHD_socket_get_error_ ()))

            {

              ret = 0;

              continue;

            }

          abort ();

        }

    }

}

/**

 * Read character-by-character until we

 * get '\r\n\r\n'.

 */

static void

recv_hdr (wr_socket sock)

{

  unsigned int i;

  char next;

  char c;

  ssize_t ret;

  make_blocking (wr_fd (sock));

  next = '\r';

  i = 0;

  while (i < 4)

    {

      ret = wr_recv (sock,

                       &c,

                       1);

      if (0 > ret)

        {

          if (MHD_SCKT_ERR_IS_EAGAIN_ (MHD_socket_get_error_ ()))

            continue;

          abort ();

        }

      if (0 == ret)

        continue;

      if (c == next)

        {

          i++;

          if (next == '\r')

            next = '\n';

          else

            next = '\r';

          continue;

        }

      if (c == '\r')

        {

          i = 1;

          next = '\n';

          continue;

        }

      i = 0;

      next = '\r';

    }

}

static void

recv_all (wr_socket sock,

          const char *text)

{

  size_t len = strlen (text);

  char buf[len];

  ssize_t ret;

  size_t off;

  make_blocking (wr_fd (sock));

  for (off = 0; off < len; off += ret)

    {

      ret = wr_recv (sock,

                       &buf[off],

                       len - off);

      if (0 > ret)

        {

          if (MHD_SCKT_ERR_IS_EAGAIN_ (MHD_socket_get_error_ ()))

            {

              ret = 0;

              continue;

            }

          abort ();

        }

    }

  if (0 != strncmp (text, buf, len))

    abort();

}

/**

 * Main function for the thread that runs the interaction with

 * the upgraded socket.

 *

 * @param cls the handle for the upgrade

 */

static void *

run_usock (void *cls)

{

  struct MHD_UpgradeResponseHandle *urh = cls;

  send_all (usock,

            "Hello");

  recv_all (usock,

            "World");

  send_all (usock,

            "Finished");

  MHD_upgrade_action (urh,

                      MHD_UPGRADE_ACTION_CLOSE);

  return NULL;

}

/**

 * Main function for the thread that runs the client-side of the

 * interaction with the upgraded socket.

 *

 * @param cls the client socket

 */

static void *

run_usock_client (void *cls)

{

  wr_socket *sock = cls;

  send_all (*sock,

            "GET / HTTP/1.1\r\nConnection: Upgrade\r\n\r\n");

  recv_hdr (*sock);

  recv_all (*sock,

            "Hello");

  send_all (*sock,

            "World");

  recv_all (*sock,

            "Finished");

  wr_close (*sock);

  done = true;

  return NULL;

}

/**

 * Function called after a protocol "upgrade" response was sent

 * successfully and the socket should now be controlled by some

 * protocol other than HTTP.

 *

 * Any data already received on the socket will be made available in

 * @e extra_in.  This can happen if the application sent extra data

 * before MHD send the upgrade response.  The application should

 * treat data from @a extra_in as if it had read it from the socket.

 *

 * Note that the application must not close() @a sock directly,

 * but instead use #MHD_upgrade_action() for special operations

 * on @a sock.

 *

 * Except when in 'thread-per-connection' mode, implementations

 * of this function should never block (as it will still be called

 * from within the main event loop).

 *

 * @param cls closure, whatever was given to #MHD_create_response_for_upgrade().

 * @param connection original HTTP connection handle,

 *                   giving the function a last chance

 *                   to inspect the original HTTP request

 * @param con_cls last value left in `con_cls` of the `MHD_AccessHandlerCallback`

 * @param extra_in if we happened to have read bytes after the

 *                 HTTP header already (because the client sent

 *                 more than the HTTP header of the request before

 *                 we sent the upgrade response),

 *                 these are the extra bytes already read from @a sock

 *                 by MHD.  The application should treat these as if

 *                 it had read them from @a sock.

 * @param extra_in_size number of bytes in @a extra_in

 * @param sock socket to use for bi-directional communication

 *        with the client.  For HTTPS, this may not be a socket

 *        that is directly connected to the client and thus certain

 *        operations (TCP-specific setsockopt(), getsockopt(), etc.)

 *        may not work as expected (as the socket could be from a

 *        socketpair() or a TCP-loopback).  The application is expected

 *        to perform read()/recv() and write()/send() calls on the socket.

 *        The application may also call shutdown(), but must not call

 *        close() directly.

 * @param urh argument for #MHD_upgrade_action()s on this @a connection.

 *        Applications must eventually use this callback to (indirectly)

 *        perform the close() action on the @a sock.

 */

static void

upgrade_cb (void *cls,

            struct MHD_Connection *connection,

            void *con_cls,

            const char *extra_in,

            size_t extra_in_size,

            MHD_socket sock,

            struct MHD_UpgradeResponseHandle *urh)

{

  (void)cls; (void)connection; (void)con_cls; (void)extra_in; /* Unused. Silent compiler warning. */

  usock = wr_create_from_plain_sckt (sock);

  if (0 != extra_in_size)

    abort ();

  if (0 != pthread_create (&pt,

                           NULL,

                           &run_usock,

                           urh))

    abort ();

}

/**

 * A client has requested the given url using the given method

 * (#MHD_HTTP_METHOD_GET, #MHD_HTTP_METHOD_PUT,

 * #MHD_HTTP_METHOD_DELETE, #MHD_HTTP_METHOD_POST, etc).  The callback

 * must call MHD callbacks to provide content to give back to the

 * client and return an HTTP status code (i.e. #MHD_HTTP_OK,

 * #MHD_HTTP_NOT_FOUND, etc.).

 *

 * @param cls argument given together with the function

 *        pointer when the handler was registered with MHD

 * @param url the requested url

 * @param method the HTTP method used (#MHD_HTTP_METHOD_GET,

 *        #MHD_HTTP_METHOD_PUT, etc.)

 * @param version the HTTP version string (i.e.

 *        #MHD_HTTP_VERSION_1_1)

 * @param upload_data the data being uploaded (excluding HEADERS,

 *        for a POST that fits into memory and that is encoded

 *        with a supported encoding, the POST data will NOT be

 *        given in upload_data and is instead available as

 *        part of #MHD_get_connection_values; very large POST

 *        data *will* be made available incrementally in

 *        @a upload_data)

 * @param upload_data_size set initially to the size of the

 *        @a upload_data provided; the method must update this

 *        value to the number of bytes NOT processed;

 * @param con_cls pointer that the callback can set to some

 *        address and that will be preserved by MHD for future

 *        calls for this request; since the access handler may

 *        be called many times (i.e., for a PUT/POST operation

 *        with plenty of upload data) this allows the application

 *        to easily associate some request-specific state.

 *        If necessary, this state can be cleaned up in the

 *        global #MHD_RequestCompletedCallback (which

 *        can be set with the #MHD_OPTION_NOTIFY_COMPLETED).

 *        Initially, `*con_cls` will be NULL.

 * @return #MHD_YES if the connection was handled successfully,

 *         #MHD_NO if the socket must be closed due to a serios

 *         error while handling the request

 */

static int

ahc_upgrade (void *cls,

             struct MHD_Connection *connection,

             const char *url,

             const char *method,

             const char *version,

             const char *upload_data,

             size_t *upload_data_size,

             void **con_cls)

{

  struct MHD_Response *resp;

  int ret;

  (void)cls;(void)url;(void)method;                        /* Unused. Silent compiler warning. */

  (void)version;(void)upload_data;(void)upload_data_size;  /* Unused. Silent compiler warning. */

  if (NULL == *con_cls)

    abort ();

  if (! pthread_equal (**((pthread_t**)con_cls), pthread_self ()))

    abort ();

  resp = MHD_create_response_for_upgrade (&upgrade_cb,

                                          NULL);

  MHD_add_response_header (resp,

                           MHD_HTTP_HEADER_UPGRADE,

                           "Hello World Protocol");

  ret = MHD_queue_response (connection,

                            MHD_HTTP_SWITCHING_PROTOCOLS,

                            resp);

  MHD_destroy_response (resp);

  return ret;

}

/**

 * Run the MHD external event loop using select.

 *

 * @param daemon daemon to run it for

 */

static void

run_mhd_select_loop (struct MHD_Daemon *daemon)

{

  fd_set rs;

  fd_set ws;

  fd_set es;

  MHD_socket max_fd;

  MHD_UNSIGNED_LONG_LONG to;

  struct timeval tv;

  while (! done)

    {

      FD_ZERO (&rs);

      FD_ZERO (&ws);

      FD_ZERO (&es);

      max_fd = -1;

      to = 1000;

      if (MHD_YES !=

          MHD_get_fdset (daemon,

                         &rs,

                         &ws,