src/testspdy/test_session_timeout.c - manifest_repos/libmicrohttpd - Git at Google

 /*
     This file is part of libmicrospdy
     Copyright Copyright (C) 2013 Andrey Uzunov

     This program 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 of the License, or
     (at your option) any later version.

     This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

 /**
  * @file session_timeout.c
  * @brief  tests closing sessions after set timeout. Openssl is used for
  * 			client
  * @author Andrey Uzunov
  */

 #include "platform.h"
 #include "microspdy.h"
 #include "stdio.h"
 #include <sys/wait.h>
 #include <ctype.h>
 #include "common.h"
 #include <sys/time.h>
 #include <sys/stat.h>
 #include "../microspdy/internal.h"

 #define TIMEOUT 2
 #define SELECT_MS_TIMEOUT 20

 int port;

 pid_t parent;
 pid_t child;

 int run = 1;
 int chunk_size=1;
 int new_session;
 int closed_session;
 int do_sleep;


 static unsigned long long
 monotonic_time (void)
 {
 #ifdef HAVE_CLOCK_GETTIME
 #ifdef CLOCK_MONOTONIC
   struct timespec ts;
   if (0 == clock_gettime (CLOCK_MONOTONIC, &ts))
     return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
 #endif
 #endif
   return time (NULL) * 1000;
 }


 static void
 killchild(char *msg)
 {
 	printf("%s\n",msg);
 	kill(child, SIGKILL);
 	exit(1);
 }


 static void
 killparent(char *msg)
 {
 	printf("%s\n",msg);
 	kill(parent, SIGKILL);
 	_exit(1);
 }


 static void
 new_session_cb (void *cls,
                 struct SPDY_Session * session)
 {
   (void)cls;
   (void)session;

 	if(!new_session)do_sleep = 1;
 	new_session = 1;
 	printf("new session\n");
 }


 static void
 closed_session_cb (void *cls,
                    struct SPDY_Session * session,
                    int by_client)
 {
   (void)cls;
   (void)session;

 	printf("closed_session_cb called\n");

 	if(SPDY_YES == by_client)
 	{
 		killchild("closed by the client");
 	}
 	if(closed_session)
 	{
 		killchild("closed_session_cb called twice");
 	}

 	closed_session = 1;
 }


 static int
 parentproc()
 {
 	int childstatus;
 	unsigned long long timeoutlong=0;
 	struct timeval timeout;
 	int ret;
 	fd_set read_fd_set;
 	fd_set write_fd_set;
 	fd_set except_fd_set;
 	int maxfd = -1;
 	struct SPDY_Daemon *daemon;
   unsigned long long  beginning = 0;
 	unsigned long long now;

 	SPDY_init();

 	daemon = SPDY_start_daemon(port,
 								DATA_DIR "cert-and-key.pem",
 								DATA_DIR "cert-and-key.pem",
 								&new_session_cb,
 								&closed_session_cb,
 								NULL,
 								NULL,
 								NULL,
 								SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
 								TIMEOUT,
 								SPDY_DAEMON_OPTION_END);

 	if(NULL==daemon){
 		printf("no daemon\n");
 		return 1;
 	}

 	do
 	{
 		do_sleep=0;
 		FD_ZERO(&read_fd_set);
 		FD_ZERO(&write_fd_set);
 		FD_ZERO(&except_fd_set);

 		ret = SPDY_get_timeout(daemon, &timeoutlong);

 		if(new_session && !closed_session)
 		{
 			if(SPDY_NO == ret)
 			{
 				killchild("SPDY_get_timeout returned wrong SPDY_NO");
 			}
 			/*if(timeoutlong)
 			{
 				killchild("SPDY_get_timeout returned wrong timeout");
 			}*/
 			now = monotonic_time ();
       if(now - beginning > TIMEOUT*1000 + SELECT_MS_TIMEOUT)
       {
         printf("Started at: %llums\n",beginning);
         printf("Now is: %llums\n",now);
         printf("Timeout is: %i\n",TIMEOUT);
         printf("Select Timeout is: %ims\n",SELECT_MS_TIMEOUT);
         printf("SPDY_get_timeout gave: %llums\n",timeoutlong);
 				killchild("Timeout passed but session was not closed");
       }
       if(timeoutlong > beginning + TIMEOUT *1000)
       {
         printf("Started at: %llums\n",beginning);
         printf("Now is: %llums\n",now);
         printf("Timeout is: %i\n",TIMEOUT);
         printf("Select Timeout is: %ims\n",SELECT_MS_TIMEOUT);
         printf("SPDY_get_timeout gave: %llums\n",timeoutlong);
 				killchild("SPDY_get_timeout returned wrong timeout");
       }
 		}
 		else
 		{
 			if(SPDY_YES == ret)
 			{
 				killchild("SPDY_get_timeout returned wrong SPDY_YES");
 			}
 		}

 		if(SPDY_NO == ret || timeoutlong >= 1000)
 		{
 			timeout.tv_sec = 1;
       timeout.tv_usec = 0;
 		}
 		else
 		{
 			timeout.tv_sec = timeoutlong / 1000;
       timeout.tv_usec = (timeoutlong % 1000) * 1000;
 		}

     //ignore values
     timeout.tv_sec = 0;
     timeout.tv_usec = SELECT_MS_TIMEOUT * 1000;

 		maxfd = SPDY_get_fdset (daemon,
 								&read_fd_set,
 								&write_fd_set,
 								&except_fd_set);

 		ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);

 		switch(ret) {
 			case -1:
 				printf("select error: %i\n", errno);
 				break;
 			case 0:
 				/*if(new_session)
 				{
 					killchild("select returned wrong number");
 				}*/
 				break;
 			default:
 				SPDY_run(daemon);
         if(0 == beginning)
         {
 	  beginning = monotonic_time ();
         }
 				/*if(do_sleep)
 				{
 					sleep(TIMEOUT);
 					do_sleep = 0;
 				}*/
 			break;
 		}
 	}
 	while(waitpid(child,&childstatus,WNOHANG) != child);

 	if(!new_session || !closed_session)
 	{
 		killchild("child is dead, callback wasn't called");
 	}

 	ret = SPDY_get_timeout(daemon, &timeoutlong);

 	if(SPDY_YES == ret)
 	{
 		killchild("SPDY_get_timeout returned wrong SPDY_YES after child died");
 	}

 	SPDY_stop_daemon(daemon);

 	SPDY_deinit();

 	return 0;
 }


 static int
 childproc()
 {
 	pid_t devnull;
 	int out;

 	out=dup(1);
         if (-1 == out)
           abort();
 	//close(0);
 	close(1);
 	close(2);
 	/*devnull = open("/dev/null", O_RDONLY);
 	if (0 != devnull)
 	{
 		dup2(devnull, 0);
 		close(devnull);
 	}*/
 	devnull = open("/dev/null", O_WRONLY);
         if (-1 == devnull)
           abort ();
 	if (1 != devnull)
 	{
 		dup2(devnull, 1);
 		close(devnull);
 	}
 	devnull = open("/dev/null", O_WRONLY);
         if (-1 == devnull)
           abort ();
 	if (2 != devnull)
 	{
 		dup2(devnull, 2);
 		close(devnull);
 	}
 	char *uri;
 	asprintf (&uri, "127.0.0.1:%i", port);
 	execlp ("openssl", "openssl", "s_client", "-connect", uri, NULL);
 	close(1);
 	dup2(out,1);
 	close(out);
 	killparent ("executing openssl failed");
 	return 1;
 }


 int
 main()
 {
 	port = get_port(11123);
 	parent = getpid();

 	child = fork();
 	if (-1 == child)
 	{
 		fprintf(stderr, "can't fork, error %d\n", errno);
 		exit(EXIT_FAILURE);
 	}

 	if (child == 0)
 	{
 		int ret = childproc();
 		_exit(ret);
 	}
 	else
 	{
 		int ret = parentproc();
 		exit(ret);
 	}
 	return 1;
 }
	/*
	This file is part of libmicrospdy
	Copyright Copyright (C) 2013 Andrey Uzunov

	This program 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 of the License, or
	(at your option) any later version.

	This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	/**
	* @file session_timeout.c
	* @brief tests closing sessions after set timeout. Openssl is used for
	* client
	* @author Andrey Uzunov
	*/

	#include "platform.h"
	#include "microspdy.h"
	#include "stdio.h"
	#include <sys/wait.h>
	#include <ctype.h>
	#include "common.h"
	#include <sys/time.h>
	#include <sys/stat.h>
	#include "../microspdy/internal.h"

	#define TIMEOUT 2
	#define SELECT_MS_TIMEOUT 20

	int port;

	pid_t parent;
	pid_t child;

	int run = 1;
	int chunk_size=1;
	int new_session;
	int closed_session;
	int do_sleep;



	static unsigned long long
	monotonic_time (void)
	{
	#ifdef HAVE_CLOCK_GETTIME
	#ifdef CLOCK_MONOTONIC
	struct timespec ts;
	if (0 == clock_gettime (CLOCK_MONOTONIC, &ts))
	return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
	#endif
	#endif
	return time (NULL) * 1000;
	}


	static void
	killchild(char *msg)
	{
	printf("%s\n",msg);
	kill(child, SIGKILL);
	exit(1);
	}


	static void
	killparent(char *msg)
	{
	printf("%s\n",msg);
	kill(parent, SIGKILL);
	_exit(1);
	}


	static void
	new_session_cb (void *cls,
	struct SPDY_Session * session)
	{
	(void)cls;
	(void)session;

	if(!new_session)do_sleep = 1;
	new_session = 1;
	printf("new session\n");
	}


	static void
	closed_session_cb (void *cls,
	struct SPDY_Session * session,
	int by_client)
	{
	(void)cls;
	(void)session;

	printf("closed_session_cb called\n");

	if(SPDY_YES == by_client)
	{
	killchild("closed by the client");
	}
	if(closed_session)
	{
	killchild("closed_session_cb called twice");
	}

	closed_session = 1;
	}


	static int
	parentproc()
	{
	int childstatus;
	unsigned long long timeoutlong=0;
	struct timeval timeout;
	int ret;
	fd_set read_fd_set;
	fd_set write_fd_set;
	fd_set except_fd_set;
	int maxfd = -1;
	struct SPDY_Daemon *daemon;
	unsigned long long beginning = 0;
	unsigned long long now;

	SPDY_init();

	daemon = SPDY_start_daemon(port,
	DATA_DIR "cert-and-key.pem",
	DATA_DIR "cert-and-key.pem",
	&new_session_cb,
	&closed_session_cb,
	NULL,
	NULL,
	NULL,
	SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
	TIMEOUT,
	SPDY_DAEMON_OPTION_END);

	if(NULL==daemon){
	printf("no daemon\n");
	return 1;
	}

	do
	{
	do_sleep=0;
	FD_ZERO(&read_fd_set);
	FD_ZERO(&write_fd_set);
	FD_ZERO(&except_fd_set);

	ret = SPDY_get_timeout(daemon, &timeoutlong);

	if(new_session && !closed_session)
	{
	if(SPDY_NO == ret)
	{
	killchild("SPDY_get_timeout returned wrong SPDY_NO");
	}
	/*if(timeoutlong)
	{
	killchild("SPDY_get_timeout returned wrong timeout");
	}*/
	now = monotonic_time ();
	if(now - beginning > TIMEOUT*1000 + SELECT_MS_TIMEOUT)
	{
	printf("Started at: %llums\n",beginning);
	printf("Now is: %llums\n",now);
	printf("Timeout is: %i\n",TIMEOUT);
	printf("Select Timeout is: %ims\n",SELECT_MS_TIMEOUT);
	printf("SPDY_get_timeout gave: %llums\n",timeoutlong);
	killchild("Timeout passed but session was not closed");
	}
	if(timeoutlong > beginning + TIMEOUT *1000)
	{
	printf("Started at: %llums\n",beginning);
	printf("Now is: %llums\n",now);
	printf("Timeout is: %i\n",TIMEOUT);
	printf("Select Timeout is: %ims\n",SELECT_MS_TIMEOUT);
	printf("SPDY_get_timeout gave: %llums\n",timeoutlong);
	killchild("SPDY_get_timeout returned wrong timeout");
	}
	}
	else
	{
	if(SPDY_YES == ret)
	{
	killchild("SPDY_get_timeout returned wrong SPDY_YES");
	}
	}

	if(SPDY_NO == ret \|\| timeoutlong >= 1000)
	{
	timeout.tv_sec = 1;
	timeout.tv_usec = 0;
	}
	else
	{
	timeout.tv_sec = timeoutlong / 1000;
	timeout.tv_usec = (timeoutlong % 1000) * 1000;
	}

	//ignore values
	timeout.tv_sec = 0;
	timeout.tv_usec = SELECT_MS_TIMEOUT * 1000;

	maxfd = SPDY_get_fdset (daemon,
	&read_fd_set,
	&write_fd_set,
	&except_fd_set);

	ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);

	switch(ret) {
	case -1:
	printf("select error: %i\n", errno);
	break;
	case 0:
	/*if(new_session)
	{
	killchild("select returned wrong number");
	}*/
	break;
	default:
	SPDY_run(daemon);
	if(0 == beginning)
	{
	beginning = monotonic_time ();
	}
	/*if(do_sleep)
	{
	sleep(TIMEOUT);
	do_sleep = 0;
	}*/
	break;
	}
	}
	while(waitpid(child,&childstatus,WNOHANG) != child);

	if(!new_session \|\| !closed_session)
	{
	killchild("child is dead, callback wasn't called");
	}

	ret = SPDY_get_timeout(daemon, &timeoutlong);

	if(SPDY_YES == ret)
	{
	killchild("SPDY_get_timeout returned wrong SPDY_YES after child died");
	}

	SPDY_stop_daemon(daemon);

	SPDY_deinit();

	return 0;
	}


	static int
	childproc()
	{
	pid_t devnull;
	int out;

	out=dup(1);
	if (-1 == out)
	abort();
	//close(0);
	close(1);
	close(2);
	/*devnull = open("/dev/null", O_RDONLY);
	if (0 != devnull)
	{
	dup2(devnull, 0);
	close(devnull);
	}*/
	devnull = open("/dev/null", O_WRONLY);
	if (-1 == devnull)
	abort ();
	if (1 != devnull)
	{
	dup2(devnull, 1);
	close(devnull);
	}
	devnull = open("/dev/null", O_WRONLY);
	if (-1 == devnull)
	abort ();
	if (2 != devnull)
	{
	dup2(devnull, 2);
	close(devnull);
	}
	char *uri;
	asprintf (&uri, "127.0.0.1:%i", port);
	execlp ("openssl", "openssl", "s_client", "-connect", uri, NULL);
	close(1);
	dup2(out,1);
	close(out);
	killparent ("executing openssl failed");
	return 1;
	}


	int
	main()
	{
	port = get_port(11123);
	parent = getpid();

	child = fork();
	if (-1 == child)
	{
	fprintf(stderr, "can't fork, error %d\n", errno);
	exit(EXIT_FAILURE);
	}

	if (child == 0)
	{
	int ret = childproc();
	_exit(ret);
	}
	else
	{
	int ret = parentproc();
	exit(ret);
	}
	return 1;
	}