src/testspdy/test_misc.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 misc.c
  * @brief  tests a lot of small calls and callbacks. TODO mention what
  * @author Andrey Uzunov
  */

 #include "platform.h"
 #include "microspdy.h"
 #include "stdio.h"
 #include <sys/wait.h>
 #include "common.h"

 int port;

 #define HTML "<html><head>\
 <link href=\"main.css\" rel=\"stylesheet\" type=\"text/css\" />\
 </head><body>This is libmicrospdy</body></html>"

 #define CSS "body{font-size:15px}"

 #define SESSION_CLS "1234567890"

 #define REQUEST_CLS "1234567890REQ"

 pid_t parent;
 pid_t child;

 struct SPDY_Session *session1;
 struct SPDY_Session *session2;

 void
 killchild()
 {
 	kill(child, SIGKILL);
 	exit(1);
 }

 void
 killparent()
 {
 	kill(parent, SIGKILL);
 	_exit(1);
 }


 void
 create_child()
 {
 	parent = getpid();

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

 	if (child == 0)
 	{
 		int devnull;
 		char *uri;
 		fflush(stdout);
 		devnull = open("/dev/null", O_WRONLY);
                 if (-1 == devnull)
                   abort ();
 		if (1 != devnull)
 		{
 			dup2(devnull, 1);
 			close(devnull);
 		}
 		asprintf(&uri,"https://127.0.0.1:%i/",port);
 		execlp("spdycat", "spdycat","-anv",uri,NULL );
 		printf("execlp failed\n");
 		killparent();
 	}
 }

 void
 response_done_callback(void *cls,
 								struct SPDY_Response * response,
 								struct SPDY_Request * request,
 								enum SPDY_RESPONSE_RESULT status,
 						bool streamopened)
 {
   (void)status;
   (void)streamopened;

 	if(strcmp(cls,"/main.css"))
 	{
 		session1 = SPDY_get_session_for_request(request);
 		if(NULL == session1)
 		{
 			printf("SPDY_get_session_for_request failed\n");
 			killchild();
 		}

 		char *session_cls = strdup(SESSION_CLS);
 		SPDY_set_cls_to_session(session1,session_cls);
 	}
 	else
 	{
 		session2 = SPDY_get_session_for_request(request);
 		if(session1 != session2)
 		{
 			printf("SPDY_get_session_for_request failed the second time\n");
 			killchild();
 		}
 		printf("SPDY_get_session_for_request tested...\n");

 		void *session_cls = SPDY_get_cls_from_session(session2);
 		if(NULL == session_cls || strcmp(session_cls, SESSION_CLS))
 		{
 			printf("SPDY_get_cls_from_session failed\n");
 			killchild();
 		}
 		printf("SPDY_set_cls_to_session tested...\n");
 		printf("SPDY_get_cls_from_session tested...\n");

 		void *request_cls = SPDY_get_cls_from_request(request);
 		if(NULL == request_cls || strcmp(request_cls, REQUEST_CLS))
 		{
 			printf("SPDY_get_cls_from_request failed\n");
 			killchild();
 		}
 		printf("SPDY_set_cls_to_request tested...\n");
 		printf("SPDY_get_cls_from_request tested...\n");
 	}

 	SPDY_destroy_request(request);
 	SPDY_destroy_response(response);
 	free(cls);
 }

 void
 standard_request_handler(void *cls,
 						struct SPDY_Request * request,
 						uint8_t priority,
                         const char *method,
                         const char *path,
                         const char *version,
                         const char *host,
                         const char *scheme,
 						struct SPDY_NameValue * headers,
             bool more)
 {
 	(void)cls;
 	(void)request;
 	(void)priority;
 	(void)host;
 	(void)scheme;
 	(void)headers;
 	(void)method;
 	(void)version;
 	(void)more;

 	struct SPDY_Response *response=NULL;
 	char *cls_path = strdup(path);

 	if(strcmp(path,"/main.css")==0)
 	{
 		char *request_cls = strdup(REQUEST_CLS);
 		SPDY_set_cls_to_request(request,request_cls);
 		response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,CSS,strlen(CSS));
 	}
 	else
 	{
 		response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,HTML,strlen(HTML));
 	}

 	if(NULL==response){
 		fprintf(stdout,"no response obj\n");
 		killchild();
 	}

 	if(SPDY_queue_response(request,response,true,false,&response_done_callback,cls_path)!=SPDY_YES)
 	{
 		fprintf(stdout,"queue\n");
 		killchild();
 	}
 }

 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;

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

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

 	create_child();

 	do
 	{
 		FD_ZERO(&read_fd_set);
 		FD_ZERO(&write_fd_set);
 		FD_ZERO(&except_fd_set);

 		ret = SPDY_get_timeout(daemon, &timeoutlong);
 		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;
 		}

 		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:

 				break;
 			default:
 				SPDY_run(daemon);

 			break;
 		}
 	}
 	while(waitpid(child,&childstatus,WNOHANG) != child);

 	SPDY_stop_daemon(daemon);

 	return WEXITSTATUS(childstatus);
 }


 int
 main()
 {
 	port = get_port(13123);
 	SPDY_init();

 	int ret = parentproc();

 	SPDY_deinit();

 	return ret;
 }
	/*
	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 misc.c
	* @brief tests a lot of small calls and callbacks. TODO mention what
	* @author Andrey Uzunov
	*/

	#include "platform.h"
	#include "microspdy.h"
	#include "stdio.h"
	#include <sys/wait.h>
	#include "common.h"

	int port;

	#define HTML "<html><head>\
	<link href=\"main.css\" rel=\"stylesheet\" type=\"text/css\" />\
	</head><body>This is libmicrospdy</body></html>"

	#define CSS "body{font-size:15px}"

	#define SESSION_CLS "1234567890"

	#define REQUEST_CLS "1234567890REQ"

	pid_t parent;
	pid_t child;

	struct SPDY_Session *session1;
	struct SPDY_Session *session2;

	void
	killchild()
	{
	kill(child, SIGKILL);
	exit(1);
	}

	void
	killparent()
	{
	kill(parent, SIGKILL);
	_exit(1);
	}


	void
	create_child()
	{
	parent = getpid();

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

	if (child == 0)
	{
	int devnull;
	char *uri;
	fflush(stdout);
	devnull = open("/dev/null", O_WRONLY);
	if (-1 == devnull)
	abort ();
	if (1 != devnull)
	{
	dup2(devnull, 1);
	close(devnull);
	}
	asprintf(&uri,"https://127.0.0.1:%i/",port);
	execlp("spdycat", "spdycat","-anv",uri,NULL );
	printf("execlp failed\n");
	killparent();
	}
	}

	void
	response_done_callback(void *cls,
	struct SPDY_Response * response,
	struct SPDY_Request * request,
	enum SPDY_RESPONSE_RESULT status,
	bool streamopened)
	{
	(void)status;
	(void)streamopened;

	if(strcmp(cls,"/main.css"))
	{
	session1 = SPDY_get_session_for_request(request);
	if(NULL == session1)
	{
	printf("SPDY_get_session_for_request failed\n");
	killchild();
	}

	char *session_cls = strdup(SESSION_CLS);
	SPDY_set_cls_to_session(session1,session_cls);
	}
	else
	{
	session2 = SPDY_get_session_for_request(request);
	if(session1 != session2)
	{
	printf("SPDY_get_session_for_request failed the second time\n");
	killchild();
	}
	printf("SPDY_get_session_for_request tested...\n");

	void *session_cls = SPDY_get_cls_from_session(session2);
	if(NULL == session_cls \|\| strcmp(session_cls, SESSION_CLS))
	{
	printf("SPDY_get_cls_from_session failed\n");
	killchild();
	}
	printf("SPDY_set_cls_to_session tested...\n");
	printf("SPDY_get_cls_from_session tested...\n");

	void *request_cls = SPDY_get_cls_from_request(request);
	if(NULL == request_cls \|\| strcmp(request_cls, REQUEST_CLS))
	{
	printf("SPDY_get_cls_from_request failed\n");
	killchild();
	}
	printf("SPDY_set_cls_to_request tested...\n");
	printf("SPDY_get_cls_from_request tested...\n");
	}

	SPDY_destroy_request(request);
	SPDY_destroy_response(response);
	free(cls);
	}

	void
	standard_request_handler(void *cls,
	struct SPDY_Request * request,
	uint8_t priority,
	const char *method,
	const char *path,
	const char *version,
	const char *host,
	const char *scheme,
	struct SPDY_NameValue * headers,
	bool more)
	{
	(void)cls;
	(void)request;
	(void)priority;
	(void)host;
	(void)scheme;
	(void)headers;
	(void)method;
	(void)version;
	(void)more;

	struct SPDY_Response *response=NULL;
	char *cls_path = strdup(path);

	if(strcmp(path,"/main.css")==0)
	{
	char *request_cls = strdup(REQUEST_CLS);
	SPDY_set_cls_to_request(request,request_cls);
	response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,CSS,strlen(CSS));
	}
	else
	{
	response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,HTML,strlen(HTML));
	}

	if(NULL==response){
	fprintf(stdout,"no response obj\n");
	killchild();
	}

	if(SPDY_queue_response(request,response,true,false,&response_done_callback,cls_path)!=SPDY_YES)
	{
	fprintf(stdout,"queue\n");
	killchild();
	}
	}

	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;

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

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

	create_child();

	do
	{
	FD_ZERO(&read_fd_set);
	FD_ZERO(&write_fd_set);
	FD_ZERO(&except_fd_set);

	ret = SPDY_get_timeout(daemon, &timeoutlong);
	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;
	}

	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:

	break;
	default:
	SPDY_run(daemon);

	break;
	}
	}
	while(waitpid(child,&childstatus,WNOHANG) != child);

	SPDY_stop_daemon(daemon);

	return WEXITSTATUS(childstatus);
	}


	int
	main()
	{
	port = get_port(13123);
	SPDY_init();

	int ret = parentproc();

	SPDY_deinit();

	return ret;
	}