src/lib/daemon_close_all_connections.c - manifest_repos/libmicrohttpd - Git at Google

 /*
   This file is part of libmicrohttpd
   Copyright (C) 2007-2018 Daniel Pittman and Christian Grothoff

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

 /**
  * @file lib/daemon_close_all_connections.c
  * @brief function to close all connections open at a daemon
  * @author Christian Grothoff
  */
 #include "internal.h"
 #include "connection_cleanup.h"
 #include "connection_close.h"
 #include "connection_finish_forward.h"
 #include "daemon_close_all_connections.h"
 #include "request_resume.h"
 #include "upgrade_process.h"


 /**
  * Close the given connection, remove it from all of its
  * DLLs and move it into the cleanup queue.
  * @remark To be called only from thread that
  * process daemon's select()/poll()/etc.
  *
  * @param pos connection to move to cleanup
  */
 static void
 close_connection (struct MHD_Connection *pos)
 {
   struct MHD_Daemon *daemon = pos->daemon;

   if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
   {
     MHD_connection_mark_closed_ (pos);
     return;   /* must let thread to do the rest */
   }
   MHD_connection_close_ (pos,
                          MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN);

   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);

   mhd_assert (! pos->suspended);
   mhd_assert (! pos->resuming);
   if (pos->connection_timeout ==
       pos->daemon->connection_default_timeout)
     XDLL_remove (daemon->normal_timeout_head,
                  daemon->normal_timeout_tail,
                  pos);
   else
     XDLL_remove (daemon->manual_timeout_head,
                  daemon->manual_timeout_tail,
                  pos);
   DLL_remove (daemon->connections_head,
               daemon->connections_tail,
               pos);
   DLL_insert (daemon->cleanup_head,
               daemon->cleanup_tail,
               pos);

   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 }


 /**
  * Close all connections for the daemon.  Must only be called when
  * MHD_Daemon::shutdown was set to true.
  *
  * @remark To be called only from thread that process daemon's
  * select()/poll()/etc.
  *
  * @param daemon daemon to close down
  */
 void
 MHD_daemon_close_all_connections_ (struct MHD_Daemon *daemon)
 {
   struct MHD_Connection *pos;
   const bool used_thr_p_c = (MHD_TM_THREAD_PER_CONNECTION ==
                              daemon->threading_mode);
 #ifdef UPGRADE_SUPPORT
   const bool upg_allowed = (! daemon->disallow_upgrade);
 #endif /* UPGRADE_SUPPORT */
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   struct MHD_UpgradeResponseHandle *urh;
   struct MHD_UpgradeResponseHandle *urhn;
   const bool used_tls = (NULL != daemon->tls_api);

   mhd_assert (NULL == daemon->worker_pool);
   mhd_assert (daemon->shutdown);
   /* give upgraded HTTPS connections a chance to finish */
   /* 'daemon->urh_head' is not used in thread-per-connection mode. */
   for (urh = daemon->urh_tail; NULL != urh; urh = urhn)
   {
     urhn = urh->prev;
     /* call generic forwarding function for passing data
        with chance to detect that application is done. */
     MHD_upgrade_response_handle_process_ (urh);
     MHD_connection_finish_forward_ (urh->connection);
     urh->clean_ready = true;
     /* Resuming will move connection to cleanup list. */
     MHD_request_resume (&urh->connection->request);
   }
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */

   /* Give suspended connections a chance to resume to avoid
      running into the check for there not being any suspended
      connections left in case of a tight race with a recently
      resumed connection. */
   if (! daemon->disallow_suspend_resume)
   {
     daemon->resuming = true;   /* Force check for pending resume. */
     MHD_resume_suspended_connections_ (daemon);
   }
   /* first, make sure all threads are aware of shutdown; need to
      traverse DLLs in peace... */
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
 #ifdef UPGRADE_SUPPORT
   if (upg_allowed)
   {
     struct MHD_Connection *susp;

     susp = daemon->suspended_connections_tail;
     while (NULL != susp)
     {
       if (NULL == susp->request.urh)     /* "Upgraded" connection? */
         MHD_PANIC (_ (
                      "MHD_stop_daemon() called while we have suspended connections.\n"));
 #ifdef HTTPS_SUPPORT
       else if (used_tls &&
                used_thr_p_c &&
                (! susp->request.urh->clean_ready) )
         shutdown (susp->request.urh->app.socket,
                   SHUT_RDWR);     /* Wake thread by shutdown of app socket. */
 #endif /* HTTPS_SUPPORT */
       else
       {
 #ifdef HAVE_MESSAGES
         if (! susp->request.urh->was_closed)
           MHD_DLOG (daemon,
                     MHD_SC_SHUTDOWN_WITH_OPEN_UPGRADED_CONNECTION,
                     _ (
                       "Initiated daemon shutdown while \"upgraded\" connection was not closed.\n"));
 #endif
         susp->request.urh->was_closed = true;
         /* If thread-per-connection is used, connection's thread
          * may still processing "upgrade" (exiting). */
         if (! used_thr_p_c)
           MHD_connection_finish_forward_ (susp);
         /* Do not use MHD_resume_connection() as mutex is
          * already locked. */
         susp->resuming = true;
         daemon->resuming = true;
       }
       susp = susp->prev;
     }
   }
   else /* This 'else' is combined with next 'if' */
 #endif /* UPGRADE_SUPPORT */
   if (NULL != daemon->suspended_connections_head)
     MHD_PANIC (_ (
                  "MHD_stop_daemon() called while we have suspended connections.\n"));
   for (pos = daemon->connections_tail; NULL != pos; pos = pos->prev)
   {
     shutdown (pos->socket_fd,
               SHUT_RDWR);
 #if MHD_WINSOCK_SOCKETS
     if ( (used_thr_p_c) &&
          (MHD_ITC_IS_VALID_ (daemon->itc)) &&
          (! MHD_itc_activate_ (daemon->itc,
                                "e")) )
       MHD_PANIC (_ (
                    "Failed to signal shutdown via inter-thread communication channel.\n"));
 #endif
   }

   /* now, collect per-connection threads */
   if (used_thr_p_c)
   {
     pos = daemon->connections_tail;
     while (NULL != pos)
     {
       if (! pos->thread_joined)
       {
         MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
         if (! MHD_join_thread_ (pos->pid.handle))
           MHD_PANIC (_ ("Failed to join a thread.\n"));
         MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
         pos->thread_joined = true;
         /* The thread may have concurrently modified the DLL,
            need to restart from the beginning */
         pos = daemon->connections_tail;
         continue;
       }
       pos = pos->prev;
     }
   }
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);

 #ifdef UPGRADE_SUPPORT
   /* Finished threads with "upgraded" connections need to be moved
    * to cleanup list by resume_suspended_connections(). */
   /* "Upgraded" connections that were not closed explicitly by
    * application should be moved to cleanup list too. */
   if (upg_allowed)
   {
     daemon->resuming = true;   /* Force check for pending resume. */
     MHD_resume_suspended_connections_ (daemon);
   }
 #endif /* UPGRADE_SUPPORT */

   /* now that we're alone, move everyone to cleanup */
   while (NULL != (pos = daemon->connections_tail))
   {
     if ( (used_thr_p_c) &&
          (! pos->thread_joined) )
       MHD_PANIC (_ ("Failed to join a thread.\n"));
     close_connection (pos);
   }
   MHD_connection_cleanup_ (daemon);
 }


 /* end of daemon_close_all_connections.c */
	/*
	This file is part of libmicrohttpd
	Copyright (C) 2007-2018 Daniel Pittman and Christian Grothoff

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library 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
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	/**
	* @file lib/daemon_close_all_connections.c
	* @brief function to close all connections open at a daemon
	* @author Christian Grothoff
	*/
	#include "internal.h"
	#include "connection_cleanup.h"
	#include "connection_close.h"
	#include "connection_finish_forward.h"
	#include "daemon_close_all_connections.h"
	#include "request_resume.h"
	#include "upgrade_process.h"


	/**
	* Close the given connection, remove it from all of its
	* DLLs and move it into the cleanup queue.
	* @remark To be called only from thread that
	* process daemon's select()/poll()/etc.
	*
	* @param pos connection to move to cleanup
	*/
	static void
	close_connection (struct MHD_Connection *pos)
	{
	struct MHD_Daemon *daemon = pos->daemon;

	if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
	{
	MHD_connection_mark_closed_ (pos);
	return; /* must let thread to do the rest */
	}
	MHD_connection_close_ (pos,
	MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN);

	MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);

	mhd_assert (! pos->suspended);
	mhd_assert (! pos->resuming);
	if (pos->connection_timeout ==
	pos->daemon->connection_default_timeout)
	XDLL_remove (daemon->normal_timeout_head,
	daemon->normal_timeout_tail,
	pos);
	else
	XDLL_remove (daemon->manual_timeout_head,
	daemon->manual_timeout_tail,
	pos);
	DLL_remove (daemon->connections_head,
	daemon->connections_tail,
	pos);
	DLL_insert (daemon->cleanup_head,
	daemon->cleanup_tail,
	pos);

	MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
	}


	/**
	* Close all connections for the daemon. Must only be called when
	* MHD_Daemon::shutdown was set to true.
	*
	* @remark To be called only from thread that process daemon's
	* select()/poll()/etc.
	*
	* @param daemon daemon to close down
	*/
	void
	MHD_daemon_close_all_connections_ (struct MHD_Daemon *daemon)
	{
	struct MHD_Connection *pos;
	const bool used_thr_p_c = (MHD_TM_THREAD_PER_CONNECTION ==
	daemon->threading_mode);
	#ifdef UPGRADE_SUPPORT
	const bool upg_allowed = (! daemon->disallow_upgrade);
	#endif /* UPGRADE_SUPPORT */
	#if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
	struct MHD_UpgradeResponseHandle *urh;
	struct MHD_UpgradeResponseHandle *urhn;
	const bool used_tls = (NULL != daemon->tls_api);

	mhd_assert (NULL == daemon->worker_pool);
	mhd_assert (daemon->shutdown);
	/* give upgraded HTTPS connections a chance to finish */
	/* 'daemon->urh_head' is not used in thread-per-connection mode. */
	for (urh = daemon->urh_tail; NULL != urh; urh = urhn)
	{
	urhn = urh->prev;
	/* call generic forwarding function for passing data
	with chance to detect that application is done. */
	MHD_upgrade_response_handle_process_ (urh);
	MHD_connection_finish_forward_ (urh->connection);
	urh->clean_ready = true;
	/* Resuming will move connection to cleanup list. */
	MHD_request_resume (&urh->connection->request);
	}
	#endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */

	/* Give suspended connections a chance to resume to avoid
	running into the check for there not being any suspended
	connections left in case of a tight race with a recently
	resumed connection. */
	if (! daemon->disallow_suspend_resume)
	{
	daemon->resuming = true; /* Force check for pending resume. */
	MHD_resume_suspended_connections_ (daemon);
	}
	/* first, make sure all threads are aware of shutdown; need to
	traverse DLLs in peace... */
	MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
	#ifdef UPGRADE_SUPPORT
	if (upg_allowed)
	{
	struct MHD_Connection *susp;

	susp = daemon->suspended_connections_tail;
	while (NULL != susp)
	{
	if (NULL == susp->request.urh) /* "Upgraded" connection? */
	MHD_PANIC (_ (
	"MHD_stop_daemon() called while we have suspended connections.\n"));
	#ifdef HTTPS_SUPPORT
	else if (used_tls &&
	used_thr_p_c &&
	(! susp->request.urh->clean_ready) )
	shutdown (susp->request.urh->app.socket,
	SHUT_RDWR); /* Wake thread by shutdown of app socket. */
	#endif /* HTTPS_SUPPORT */
	else
	{
	#ifdef HAVE_MESSAGES
	if (! susp->request.urh->was_closed)
	MHD_DLOG (daemon,
	MHD_SC_SHUTDOWN_WITH_OPEN_UPGRADED_CONNECTION,
	_ (
	"Initiated daemon shutdown while \"upgraded\" connection was not closed.\n"));
	#endif
	susp->request.urh->was_closed = true;
	/* If thread-per-connection is used, connection's thread
	* may still processing "upgrade" (exiting). */
	if (! used_thr_p_c)
	MHD_connection_finish_forward_ (susp);
	/* Do not use MHD_resume_connection() as mutex is
	* already locked. */
	susp->resuming = true;
	daemon->resuming = true;
	}
	susp = susp->prev;
	}
	}
	else /* This 'else' is combined with next 'if' */
	#endif /* UPGRADE_SUPPORT */
	if (NULL != daemon->suspended_connections_head)
	MHD_PANIC (_ (
	"MHD_stop_daemon() called while we have suspended connections.\n"));
	for (pos = daemon->connections_tail; NULL != pos; pos = pos->prev)
	{
	shutdown (pos->socket_fd,
	SHUT_RDWR);
	#if MHD_WINSOCK_SOCKETS
	if ( (used_thr_p_c) &&
	(MHD_ITC_IS_VALID_ (daemon->itc)) &&
	(! MHD_itc_activate_ (daemon->itc,
	"e")) )
	MHD_PANIC (_ (
	"Failed to signal shutdown via inter-thread communication channel.\n"));
	#endif
	}

	/* now, collect per-connection threads */
	if (used_thr_p_c)
	{
	pos = daemon->connections_tail;
	while (NULL != pos)
	{
	if (! pos->thread_joined)
	{
	MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
	if (! MHD_join_thread_ (pos->pid.handle))
	MHD_PANIC (_ ("Failed to join a thread.\n"));
	MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
	pos->thread_joined = true;
	/* The thread may have concurrently modified the DLL,
	need to restart from the beginning */
	pos = daemon->connections_tail;
	continue;
	}
	pos = pos->prev;
	}
	}
	MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);

	#ifdef UPGRADE_SUPPORT
	/* Finished threads with "upgraded" connections need to be moved
	* to cleanup list by resume_suspended_connections(). */
	/* "Upgraded" connections that were not closed explicitly by
	* application should be moved to cleanup list too. */
	if (upg_allowed)
	{
	daemon->resuming = true; /* Force check for pending resume. */
	MHD_resume_suspended_connections_ (daemon);
	}
	#endif /* UPGRADE_SUPPORT */

	/* now that we're alone, move everyone to cleanup */
	while (NULL != (pos = daemon->connections_tail))
	{
	if ( (used_thr_p_c) &&
	(! pos->thread_joined) )
	MHD_PANIC (_ ("Failed to join a thread.\n"));
	close_connection (pos);
	}
	MHD_connection_cleanup_ (daemon);
	}


	/* end of daemon_close_all_connections.c */