/*

     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 2, 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_quiesce_stream.c

 * @brief  Testcase for libmicrohttpd quiescing

 * @author Markus Doppelbauer

 * @author Christian Grothoff

 * @author Karlson2k (Evgeny Grin)

 */

#include "mhd_options.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <pthread.h>

#include <microhttpd.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#elif defined(_WIN32)

#include <windows.h>

#define sleep(s) (Sleep((s)*1000), 0)

#endif /* _WIN32 */

static volatile unsigned int request_counter;

static void

http_PanicCallback (void *cls,

                    const char *file,

                    unsigned int line,

                    const char *reason)

{

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

  fprintf( stderr,

           "PANIC: exit process: %s at %s:%u\n",

           reason,

           file,

           line);

  exit (EXIT_FAILURE);

}

static void *

resume_connection (void *arg)

{

  struct MHD_Connection *connection = arg;

  /* fprintf (stderr, "Calling resume\n"); */

  MHD_resume_connection (connection);

  return NULL;

}

static void

suspend_connection (struct MHD_Connection *connection)

{

  pthread_t thread_id;

  /* fprintf (stderr, "Calling suspend\n"); */

  MHD_suspend_connection (connection);

  int status = pthread_create (&thread_id,

                               NULL,

                               &resume_connection,

                               connection);

  if (0 != status)

    {

      fprintf (stderr,

               "Could not create thead\n");

      exit( EXIT_FAILURE );

    }

  pthread_detach (thread_id);

}

struct ContentReaderUserdata

{

  int bytes_written;

  struct MHD_Connection *connection;

};

static ssize_t

http_ContentReaderCallback (void *cls,

                            uint64_t pos,

                            char *buf,

                            size_t max)

{

  static const char alphabet[] = "\nABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

  struct ContentReaderUserdata *userdata = cls;

  (void)pos;(void)max;  /* Unused. Silent compiler warning. */

  if( userdata->bytes_written >= 1024)

    {

      fprintf( stderr,

               "finish: %d\n",

               request_counter);

      return MHD_CONTENT_READER_END_OF_STREAM;

    }

  userdata->bytes_written++;

  buf[0] = alphabet[userdata->bytes_written % (sizeof(alphabet) - 1)];

  suspend_connection (userdata->connection);

  return 1;

}

static int

http_AccessHandlerCallback (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 )

{

  int ret;

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

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

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

  /* Never respond on first call */

  if (NULL == *con_cls)

  {

    fprintf (stderr,

             "start: %d\n",

              ++request_counter);

    struct ContentReaderUserdata *userdata = malloc (sizeof(struct ContentReaderUserdata));

    if (NULL == userdata)

      return MHD_NO;

    userdata->bytes_written = 0;

    userdata->connection = connection;

    *con_cls = userdata;

    return MHD_YES;

  }

  /* Second call: create response */

  struct MHD_Response *response

    = MHD_create_response_from_callback (-1,

                                         32 * 1024,

                                         &http_ContentReaderCallback,

                                         *con_cls,

                                         NULL);

  ret = MHD_queue_response (connection,

                            MHD_HTTP_OK,

                            response);

  MHD_destroy_response (response);

  suspend_connection (connection);

  return ret;

}

int

main(void)

{

  int port;

  char command_line[1024];

  if (MHD_NO != MHD_is_feature_supported (MHD_FEATURE_AUTODETECT_BIND_PORT))

    port = 0;

  else

    port = 1470;

  /* Panic callback */

  MHD_set_panic_func (&http_PanicCallback,

                      NULL);

  /* Flags */

  unsigned int daemon_flags

    = MHD_USE_INTERNAL_POLLING_THREAD

    | MHD_USE_AUTO

    | MHD_ALLOW_SUSPEND_RESUME

    | MHD_USE_ITC;

  /* Create daemon */

  struct MHD_Daemon *daemon = MHD_start_daemon (daemon_flags,

                                                port,

                                                NULL,

                                                NULL,

                                                &http_AccessHandlerCallback,

                                                NULL,

                                                MHD_OPTION_END);

  if (NULL == daemon)

    return 1;

  if (0 == port)

    {

      const union MHD_DaemonInfo *dinfo;

      dinfo = MHD_get_daemon_info (daemon, MHD_DAEMON_INFO_BIND_PORT);

      if (NULL == dinfo || 0 == dinfo->port)

        { MHD_stop_daemon (daemon); return 32; }

      port = (int)dinfo->port;

    }

  sprintf(command_line, "curl -s http://127.0.0.1:%d", port);

  if (0 != system (command_line))

    {

      MHD_stop_daemon (daemon);

      return 1;

    }

  /* wait for a request */

  while (0 == request_counter)

    (void)sleep (1);

  fprintf (stderr,

           "quiesce\n");

  MHD_quiesce_daemon (daemon);

  /* wait a second */

  (void)sleep (1);

  fprintf (stderr,

           "stopping daemon\n");

  MHD_stop_daemon (daemon);

  return 0;

}