Project: DBSlayer

Revision: 64

Author: dgottfrid

Date: 19 Mar 2008 19:52:11

• /trunk/common/slayer_http_server.c

  ......	@@ -0,0 +1,537 @@
  	1	#include <stdlib.h>
  	2	#include <unistd.h>
  	3	#include <libgen.h>
  	4	#include "slayer_http_server.h"
  	5	#include "slayer_http_fileserver.h"
  	6
  	7
  	8
  	9
  	10	static apr_status_t slayer_http_request_dispatch(slayer_http_server_t *server, slayer_http_connection_t *connection, void **tl_config);
  	11
  	12	static char * slayer_http_response_code_lookup(int code) {
  	13	char *description = "500 Internal Server Error";
  	14	switch(code) {
  	15	case 200: description = "200 OK"; break;
  	16	case 403: description = "403 Forbidden"; break;
  	17	case 404: description = "404 Not Found"; break;
  	18	default:
  	19	description = "500 Internal Server Error";
  	20	}
  	21	return description;
  	22	}
  	23
  	24	int slayer_http_handle_response(slayer_http_server_t *server, slayer_http_connection_t *client, const char *mime_type, const char *message, int message_size){
  	25	apr_status_t status;
  	26	char dstring[APR_RFC822_DATE_LEN];
  	27	apr_rfc822_date(dstring,apr_time_now());
  	28	if(message_size == -1) message_size = strlen(message);
  	29	char *header_response = slayer_http_response_code_lookup(client->request->response_code);
  	30	char *header = apr_pstrcat(client->request->mpool, "HTTP/1.0 ",header_response, "\r\n",
  	31	"Date: ",dstring,"\r\n",
  	32	"Server: ",server->server_name,"\r\n",
  	33	"Content-type: ", mime_type, "\r\n",
  	34	"Content-Length: ",apr_itoa(client->request->mpool,client->request->payload_size = message_size),"\r\n",
  	35	"Connection: close\r\n",
  	36	"\r\n",NULL);
  	37
  	38	int size;
  	39	int header_size = strlen(header);
  	40	client->request->message_marker = client->request->message = apr_palloc(client->request->mpool, (size = header_size + message_size));
  	41	client->request->message_end = client->request->message_marker + size;
  	42	memcpy(client->request->message,header,header_size);
  	43	memcpy(client->request->message + header_size, message, message_size);
  	44	while ((status = apr_queue_push(server->out_queue,client)) == APR_EINTR);
  	45	return status;
  	46	}
  	47
  	48	static int request_parse(apr_socket_t *conn, slayer_http_request_parse_t *http_request) {
  	49	apr_status_t conn_status;
  	50	int parse_status;
  	51
  	52	if (http_request->buffer_marker == NULL || http_request->buffer_marker >= http_request->buffer+http_request->buffer_size) {
  	53	conn_status = apr_socket_recv(conn,http_request->buffer,&(http_request->buffer_size));
  	54	if (conn_status !=APR_SUCCESS || http_request->buffer_size == 0) return -1;
  	55	http_request->buffer_marker = http_request->buffer;
  	56	}
  	57	if (http_request->request_state != PARSE_REQUEST_DONE) {
  	58	parse_status = slayer_http_request_line_parse(http_request);
  	59	}
  	60	if (http_request->request_state == PARSE_REQUEST_DONE) {
  	61	do {
  	62	parse_status = slayer_http_request_header_parse(http_request);
  	63	} while ( (http_request->buffer_marker < http_request->buffer + http_request->buffer_size) && http_request->header_state != PARSE_HEADER_DONE);
  	64	}
  	65	return parse_status;
  	66	}
  	67
  	68
  	69	int handle_incoming_connections(slayer_http_server_t *server) {
  	70
  	71	apr_socket_t *conn;
  	72	apr_sockaddr_t *addr;
  	73	apr_pollset_t *pollset;
  	74	apr_pollfd_t pfd_listen;
  	75	apr_status_t status;
  	76
  	77	const apr_pollfd_t *ret_pfd;
  	78	int events;
  	79	int connections_count = 0;
  	80	slayer_http_connection_t *connections[500];
  	81
  	82	//sigset(SIGPIPE,SIG_IGN);
  	83	status = apr_socket_create(&conn,APR_INET,SOCK_STREAM,APR_PROTO_TCP,server->mpool);
  	84	status = apr_socket_opt_set(conn,APR_SO_REUSEADDR,1);
  	85	status = apr_socket_opt_set(conn,APR_SO_NONBLOCK,1);
  	86	status = apr_sockaddr_info_get(&addr,server->hostname ? server->hostname : APR_ANYADDR,APR_UNSPEC,server->port,APR_IPV4_ADDR_OK,server->mpool);
  	87	status = apr_socket_bind(conn,addr);
  	88	if (status != APR_SUCCESS) {
  	89	fprintf(stderr,"couldn't bind to %s:%d\n",server->hostname ? server->hostname: "*", server->port);
  	90	exit(-1);
  	91	}
  	92	status = apr_socket_listen(conn,3);
  	93	status = apr_pollset_create(&pollset,sizeof(connections)/sizeof(slayer_http_connection_t*) +1 /* +1 for listenting socket */,server->mpool,0);
  	94	memset(connections,0,sizeof(connections) );
  	95	pfd_listen.p = server->mpool;
  	96	pfd_listen.desc_type = APR_POLL_SOCKET;
  	97	pfd_listen.reqevents = APR_POLLIN;
  	98	pfd_listen.rtnevents = 0;
  	99	pfd_listen.desc.s = conn;
  	100	pfd_listen.client_data = NULL;
  	101	status = apr_pollset_add(pollset,&pfd_listen);
  	102	while (1) {
  	103	do {
  	104	status = apr_pollset_poll(pollset, server->socket_timeout , &events, &ret_pfd);
  	105	if (apr_atomic_read32(&(server->shutdown))) return 0;
  	106	//update_alsotry(td_shared->alsotry,td_shared->config); -- NOT SURE WHAT TO ABOUT THIS ONE - TODO: add additional function
  	107	} while (status == APR_TIMEUP);
  	108	if (status == APR_SUCCESS) {
  	109	int i;
  	110	for ( i = 0; i < events; i++) {
  	111	if (ret_pfd[i].client_data == NULL) {
  	112	if (connections_count < (sizeof(connections) / sizeof(slayer_http_connection_t*)) -1) {
  	113	apr_pool_t *cmpool,*rmpool;
  	114	int j;
  	115	slayer_http_connection_t *connection;
  	116	apr_pool_create(&cmpool,NULL);
  	117	connection = apr_pcalloc(cmpool,sizeof(slayer_http_connection_t));
  	118	connection->mpool = cmpool;
  	119	apr_pool_create(&rmpool,connection->mpool);
  	120	connection->request = apr_pcalloc(rmpool,sizeof(slayer_http_request_t));
  	121	connection->request->mpool = rmpool;
  	122	slayer_http_request_parse_init(connection->request->mpool,&(connection->request->parse),server->uri_size);
  	123	connection->request->begin_request = apr_time_now();
  	124
  	125	//setup the socket
  	126	status = apr_socket_accept(&(connection->conn),conn,connection->mpool);
  	127	status = apr_socket_opt_set(connection->conn,APR_SO_NONBLOCK,1);
  	128	memset(&connection->pollfd,0,sizeof(apr_pollfd_t));
  	129
  	130	connection->pollfd.client_data = connection;
  	131	connection->pollfd.desc_type = APR_POLL_SOCKET;
  	132	connection->pollfd.desc.s = connection->conn;
  	133	connection->pollfd.reqevents = APR_POLLIN;
  	134	connections_count++;
  	135	apr_pollset_add(pollset,&(connection->pollfd));
  	136
  	137	for (j = 0; j < (sizeof(connections) / sizeof(slayer_http_connection_t*));j++) {
  	138	if (connections[j] == NULL) {
  	139	connections[j] = connection;
  	140	break;
  	141	}
  	142	}
  	143	} else {
  	144	//do nothing ? should back up and be auto rejected.
  	145	}
  	146	} else {
  	147	slayer_http_connection_t *connection= (slayer_http_connection_t*)ret_pfd[i].client_data;
  	148	if (ret_pfd[i].rtnevents & APR_POLLERR ) {
  	149	connection->request->done = 1;
  	150	} else if ( ret_pfd[i].rtnevents & APR_POLLHUP) {
  	151	connection->request->done = 1;
  	152	} else if ( ret_pfd[i].rtnevents & APR_POLLIN || ret_pfd[i].rtnevents & APR_POLLPRI) {
  	153	if (request_parse(connection->conn,connection->request->parse) == -1) {
  	154	connection->request->done = 1;
  	155	} else if (connection->request->parse->header_state == PARSE_HEADER_DONE) {
  	156	connection->request->read_done = 1;
  	157	}
  	158	} else {
  	159	printf("oddball case\n");
  	160	//print handle oddball case
  	161	}
  	162	}
  	163	}//end of for loop
  	164	for (i = 0; i < sizeof(connections) /sizeof(slayer_http_connection_t*); i++) {
  	165	if (connections[i] != NULL && connections[i]->request != NULL) {
  	166	if (connections[i]->request->read_done) {
  	167	apr_pollset_remove(pollset,&(connections[i]->pollfd));
  	168	while ((status == apr_queue_push(server->in_queue,connections[i])) == APR_EINTR);
  	169	if (status == APR_EOF) return 0;
  	170	connections[i] = NULL;
  	171	connections_count--;
  	172	} else if (connections[i]->request->done || apr_time_as_msec(apr_time_now() - connections[i]->request->begin_request) > 10000) {
  	173	apr_pollset_remove(pollset,&(connections[i]->pollfd));
  	174	apr_socket_close(connections[i]->conn);
  	175	apr_pool_destroy(connections[i]->mpool);
  	176	connections[i] = NULL;
  	177	connections_count--;
  	178	}
  	179	}
  	180	}
  	181	} else {
  	182	char ebuf[1024];
  	183	char *err_msg = apr_strerror(status,ebuf,sizeof(ebuf));
  	184	fprintf(stderr,"ERROR in apr_pollset_poll - %s\n",err_msg);
  	185	slayer_server_log_message(server->elmanager,"ERROR in apr_pollset_poll - ");
  	186	slayer_server_log_message(server->elmanager,err_msg);
  	187	slayer_server_log_message(server->elmanager,"\n");
  	188	}
  	189	}
  	190	return 0;
  	191	}
  	192
  	193	void* handle_running_request(apr_thread_t *mythread,void * _server) {
  	194	void *_connection;
  	195	void **tl_config;
  	196	int i =0;
  	197	apr_pool_t *mpool;
  	198	apr_status_t status = apr_pool_create(&mpool,NULL);
  	199	slayer_http_server_t *server= (slayer_http_server_t*) _server;
  	200	tl_config = apr_pcalloc(mpool,sizeof(void *) * server->service_map_size);
  	201	// ****** initialize in thread specific calls for the handlers *************
  	202	for(i = 0; i < server->service_map_size; i++) {
  	203	tl_config[i] = server->service_map[i]->service->service_thread_init_func !=NULL ? server->service_map[i]->service->service_thread_init_func(mpool,server->service_map[i]->global_config) : NULL;
  	204	}
  	205	do {
  	206	_connection = NULL;;
  	207	while ( (status = apr_queue_pop(server->in_queue,&_connection)) == APR_EINTR);
  	208	if (status == APR_SUCCESS) {
  	209	slayer_http_connection_t *connection = (slayer_http_connection_t*) _connection;
  	210	status = slayer_http_request_dispatch(server,connection,tl_config);
  	211	if (status != APR_SUCCESS) {
  	212	apr_queue_term(server->out_queue);
  	213	apr_queue_term(server->in_queue);
  	214	apr_atomic_set32(&(server->shutdown),1);
  	215	}
  	216	}
  	217	} while ( status == APR_SUCCESS);
  	218	//clean it all up at the end
  	219	for(i = 0; i < server->service_map_size; i++) {
  	220	if(server->service_map[i]->service->service_thread_destroy_func){ server->service_map[i]->service->service_thread_destroy_func(tl_config[i]); }
  	221	}
  	222	apr_pool_destroy(mpool);
  	223	return NULL;
  	224	}
  	225	//
  	226	//http_output_response() -
  	227	//thread that listens on the queue | outgoing_thread_run
  	228	void* handle_outgoing_response(apr_thread_t *mythread,void * _server) {
  	229	slayer_http_connection_t *connections[500];
  	230	int connection_count=0;
  	231	void *fetch = NULL;
  	232	apr_pool_t *mpool;
  	233	apr_pollset_t *pollset;
  	234
  	235	apr_status_t status = apr_pool_create(&mpool,NULL);
  	236	slayer_http_server_t *server = (slayer_http_server_t*) _server;
  	237
  	238	status = apr_pollset_create(&pollset,sizeof(connections)/sizeof(slayer_http_connection_t*),mpool,0);
  	239	memset(connections,0,sizeof(connections) );
  	240
  	241	//setup the pollset
  	242	do {
  	243	fetch = NULL;
  	244	if (connection_count > 0) {
  	245	const apr_pollfd_t *ret_pfd;
  	246	int events,i;
  	247	events =0;
  	248	status = apr_pollset_poll(pollset, 1000*500 /* .05 sec */ , &events, &ret_pfd);
  	249	for (i= 0; i < events; i++) {
  	250	slayer_http_connection_t *connection = (slayer_http_connection_t*) ret_pfd[i].client_data;
  	251	if (ret_pfd[i].rtnevents & APR_POLLHUP || ret_pfd[i].rtnevents & APR_POLLERR) {
  	252	char *http_request = apr_pstrcat(connection->request->mpool,connection->request->parse->method == HTTP_METHOD_GET ? "GET ": "POST ",connection->request->parse->uri_data,connection->request->parse->version == HTTP_10 ? " HTTP/1.0" : " HTTP/1.0",NULL);
  	253	slayer_server_log_err_message(server->elmanager,connection->request->mpool,connection->conn,http_request,"Connection closed by client");
  	254	connection->request->done =1;
  	255	} else if (ret_pfd[i].rtnevents & APR_POLLOUT) {
  	256	apr_size_t bsent = (connection->request->message_end - connection->request->message_marker);
  	257	status = apr_socket_send(connection->conn,connection->request->message_marker ,&bsent);
  	258	if (status != APR_SUCCESS || bsent == 0) {
  	259	connection->request->done = 1;
  	260	char *http_request = apr_pstrcat(connection->request->mpool,connection->request->parse->method == HTTP_METHOD_GET ? "GET ": "POST ",connection->request->parse->uri_data,connection->request->parse->version == HTTP_10 ? " HTTP/1.0" : " HTTP/1.0",NULL);
  	261	slayer_server_log_err_message(server->elmanager,connection->request->mpool,connection->conn,http_request,"Connection closed by client");
  	262	} else if (bsent > 0) {
  	263	connection->request->message_marker += bsent;
  	264	if (connection->request->message_marker == connection->request->message_end) {
  	265	connection->request->done =1;
  	266	char *http_request = apr_pstrcat(connection->request->mpool,connection->request->parse->method == HTTP_METHOD_GET ? "GET ": "POST ",connection->request->parse->uri_data,connection->request->parse->version == HTTP_10 ? " HTTP/1.0" : " HTTP/1.0",NULL);
  	267	slayer_server_stat_update(server->stats);
  	268	slayer_server_log_request(server->lmanager,connection->request->mpool,connection->conn,http_request,connection->request->response_code,connection->request->payload_size,apr_time_now() - connection->request->begin_request);
  	269	}
  	270	}
  	271	}
  	272	}
  	273	for (i = 0; connection_count > 0 && i < sizeof(connections) /sizeof(slayer_http_connection_t*); i++) {
  	274	if (connections[i] != NULL && (connections[i]->request->done || apr_time_as_msec(apr_time_now() - connections[i]->request->begin_request) > 10000)) {
  	275	apr_pollset_remove(pollset,&(connections[i]->pollfd));
  	276	apr_socket_close(connections[i]->conn);
  	277	apr_pool_destroy(connections[i]->mpool);
  	278	connections[i] = NULL;
  	279	connection_count--;
  	280	}
  	281	}
  	282	status = apr_queue_trypop(server->out_queue,&fetch);
  	283	} else {
  	284	status = apr_queue_pop(server->out_queue,&fetch);
  	285	}
  	286	if (status == APR_SUCCESS) {
  	287	int i;
  	288	slayer_http_connection_t *connection = (slayer_http_connection_t*) fetch;
  	289	for (i = 0; i < sizeof(connections) / sizeof(slayer_http_connection_t*); i++) {
  	290	if (connections[i] == NULL) {
  	291	connections[i] = connection;
  	292	connection->pollfd.reqevents = APR_POLLOUT;
  	293	apr_pollset_add(pollset,&(connection->pollfd));
  	294	connection_count++;
  	295	break;
  	296	}
  	297	}
  	298	if (i == sizeof(connections) / sizeof(slayer_http_connection_t*)) {
  	299	apr_socket_close(connection->conn);
  	300	apr_pool_destroy(connection->mpool);
  	301	}
  	302	} else if ( status == APR_EOF) {
  	303	goto terminate;
  	304	}
  	305	} while (1);
  	306	terminate:
  	307	apr_pool_destroy(mpool);
  	308	return NULL;
  	309	}
  	310
  	311	static apr_status_t slayer_http_request_dispatch(slayer_http_server_t *server, slayer_http_connection_t *client, void **tl_config) {
  	312	apr_status_t status;
  	313	slayer_http_request_parse_t *parse= client->request->parse;
  	314	int i;
  	315
  	316	apr_uri_parse(client->request->mpool,parse->uri_start,&(client->request->uri));
  	317	if (client->request->uri.path == NULL) {
  	318	apr_socket_close(client->conn);
  	319	apr_pool_destroy(client->mpool);
  	320	return APR_SUCCESS;
  	321	}
  	322	int nothandled = 1;
  	323	for(i = 0; nothandled && i < server->service_map_size ; i++) {
  	324	int j;
  	325	for(j = 0; nothandled && server->service_map[i]->urls[j] !=NULL ; j++) {
  	326	if(strcmp(client->request->uri.path,server->service_map[i]->urls[j]) == 0) {
  	327	nothandled = 0;
  	328	server->service_map[i]->service->service_handler_func(server,server->service_map[i]->global_config,client,tl_config[i]);
  	329	}
  	330	}
  	331	}
  	332	if(nothandled) {
  	333	apr_sockaddr_t *local_addr;
  	334	apr_sockaddr_t *remote_addr;
  	335	char *local_ip;
  	336	char *remote_ip;
  	337	char *message =NULL;
  	338	apr_socket_addr_get(&remote_addr,APR_REMOTE,client->conn);
  	339	apr_sockaddr_ip_get(&remote_ip,remote_addr);
  	340	apr_socket_addr_get(&local_addr,APR_LOCAL,client->conn);
  	341	apr_sockaddr_ip_get(&local_ip,local_addr);
  	342
  	343	if ( strcmp(client->request->uri.path,"/shutdown") == 0 ) {
  	344	if (strcmp(local_ip,remote_ip) != 0) {
  	345	client->request->response_code = 403;
  	346	slayer_http_handle_response(server, client, SLAYER_MT_TEXT_PLAIN,"You are not authorized!",-1);
  	347	} else {
  	348	client->request->response_code = 200;
  	349	slayer_http_handle_response(server, client ,SLAYER_MT_TEXT_PLAIN,"going down",-1);
  	350	status = apr_socket_close(client->conn);
  	351	apr_pool_destroy(client->mpool);
  	352	return APR_EOF;
  	353	}
  	354	} else if (strcmp(client->request->uri.path,"/stats") == 0) {
  	355	client->request->response_code = 200;
  	356	message = slayer_server_stats_tojson(server->stats,client->request->mpool);
  	357	slayer_http_handle_response(server, client, SLAYER_MT_TEXT_PLAIN,message,-1);
  	358	} else if (strcmp(client->request->uri.path,"/stats/log") == 0) {
  	359	client->request->response_code = 200;
  	360	message = slayer_server_log_get_entries(server->lmanager,client->request->mpool);
  	361	slayer_http_handle_response(server, client, SLAYER_MT_TEXT_PLAIN,message,-1);
  	362	} else if (strcmp(client->request->uri.path,"/stats/error") == 0) {
  	363	client->request->response_code = 200;
  	364	message = slayer_server_log_get_entries(server->elmanager,client->request->mpool);
  	365	slayer_http_handle_response(server, client, SLAYER_MT_TEXT_PLAIN,message, -1);
  	366	} else if (strcmp(client->request->uri.path,"/stats/args") == 0) {
  	367	client->request->response_code = 200;
  	368	slayer_http_handle_response(server, client, SLAYER_MT_TEXT_PLAIN,server->startup_args,-1);
  	369	} else {
  	370	slayer_http_fileserver(server,client);
  	371	}
  	372	}
  	373	return APR_SUCCESS;
  	374	}
  	375
  	376	static void slayer_server_parse_args(int argc, char **argv,slayer_http_server_t *server) {
  	377	int i;
  	378	for(i = 1; i < argc; i++) {
  	379	if(argv[i][0] == '-' && strlen(argv[i]) == 2) {
  	380	char *extra_arg = i+1 < argc && argv[i+1][0] != '-' ? argv[i+1] : NULL;
  	381	switch (argv[i][1]) {
  	382	case '?':
  	383	fprintf(stdout,"Usage %s: [-t thread-count -p port -h ip-to-bind-to -d debug -w socket-timeout -b basedir -l logfile -e error-logfile -n number-of-stats-buckets [defaults to 1 bucket per minute for 24 hours] -i interval-to-update-stats-buckets [ defaults to 60 seconds] ] -v [prints version and exits]\n",basename(argv[0]));
  	384	for(i = 0; i < server->service_map_size; i++) {
  	385	fprintf(stdout,"\t %s\n",server->service_map[i]->service->help_string);
  	386	}
  	387	exit(0);
  	388	case 'b':
  	389	server->basedir = extra_arg;
  	390	break;
  	391	case 'd':
  	392	server->debug = extra_arg;
  	393	break;
  	394	case 'e':
  	395	server->elogfile = extra_arg;
  	396	break;
  	397	case 'h':
  	398	server->hostname = extra_arg;
  	399	break;
  	400	case 'l':
  	401	server->logfile = extra_arg ;
  	402	break;
  	403	case 'p':
  	404	server->port = atoi(extra_arg);
  	405	break;
  	406	case 't':
  	407	server->thread_count = atoi(extra_arg);
  	408	break;
  	409	case 'w':
  	410	server->socket_timeout = (atoi(extra_arg) == 0 ? 10 : atoi(extra_arg)) * 1000 * 1000;
  	411	break;
  	412	case 'n':
  	413	server->nslice = (atoi(extra_arg) == 0 ? 60*24 : atoi(extra_arg)) ;
  	414	break;
  	415	case 'i':
  	416	server->tslice = (atoi(extra_arg) == 0 ? 60 : atoi(extra_arg)) ;
  	417	break;
  	418	case 'v':
  	419	fprintf(stdout,"%s\n",server->server_name);
  	420	exit(0);
  	421	default:
  	422	break;
  	423	} //end of switch
  	424	} //if
  	425	}
  	426	if ( server->thread_count == 0 || server->port == 0 ) {
  	427	fprintf(stdout,"Usage %s: [-t thread-count -p port -h ip-to-bind-to -d debug -w socket-timeout -b basedir -l logfile -e error-logfile -n number-of-stats-buckets [defaults to 1 bucket per minute for 24 hours] -i interval-to-update-stats-buckets [ defaults to 60 seconds] ] -v [prints version and exits]\n",basename(argv[0]));
  	428	for(i = 0; i < server->service_map_size; i++) {
  	429	fprintf(stdout,"\t %s\n",server->service_map[i]->service->help_string);
  	430	}
  	431	exit(0);
  	432	}
  	433	}//end of parseargs
  	434
  	435	int slayer_server_run(int service_map_size, slayer_http_service_map_t **service_map, int argc, char **argv,int uri_size, const char *server_name) {
  	436	apr_status_t status;
  	437	apr_threadattr_t *thread_attr;
  	438	apr_array_header_t *threads;
  	439	int i ;
  	440	char *reldir = NULL;
  	441	slayer_http_server_t server;
  	442
  	443	memset(&server,0,sizeof(slayer_http_server_t));
  	444	server.port = 9090;
  	445	server.socket_timeout = 2 * 1000* 1000;
  	446	server.nslice = 60 * 24;
  	447	server.tslice = 60 ;
  	448	server.service_map = service_map;
  	449	server.service_map_size = service_map_size;
  	450	server.uri_size = uri_size;
  	451	server.thread_count = 1;
  	452	server.server_name = server_name;
  	453
  	454	slayer_server_parse_args(argc,argv,&server);
  	455
  	456	server.thread_count++;
  	457
  	458	status = apr_initialize();
  	459	status = apr_pool_create(&(server.mpool),NULL);
  	460	reldir = getcwd(NULL,0);
  	461
  	462	if (server.config !=NULL && server.config[0] !='/') {
  	463	server.config = apr_pstrcat(server.mpool,reldir,"/",server.config,NULL);
  	464	}
  	465	if (server.logfile !=NULL && server.logfile[0] !='/') {
  	466	server.logfile = apr_pstrcat(server.mpool,reldir,"/",server.logfile,NULL);
  	467	}
  	468	if (server.elogfile !=NULL && server.elogfile[0] !='/') {
  	469	server.elogfile = apr_pstrcat(server.mpool,reldir,"/",server.elogfile,NULL);
  	470	}
  	471
  	472	chdir("/tmp"); // so I can dump core someplace that I am likely to have write access to
  	473
  	474	//call the global initializers
  	475	for(i = 0; i < server.service_map_size; i++) {
  	476	if(server.service_map[i]->service->service_global_init_func) server.service_map[i]->global_config = server.service_map[i]->service->service_global_init_func(server.mpool,argc,argv);
  	477	}
  	478
  	479	if (server.debug == NULL) {
  	480	apr_proc_detach(APR_PROC_DETACH_DAEMONIZE);
  	481	}
  	482
  	483	apr_queue_create(&(server.out_queue),server.thread_count,server.mpool);
  	484	apr_queue_create(&(server.in_queue),server.thread_count*2,server.mpool);
  	485
  	486	threads = apr_array_make(server.mpool,server.thread_count,sizeof(apr_thread_t*));
  	487	apr_threadattr_create(&thread_attr,server.mpool);
  	488	apr_threadattr_detach_set(thread_attr,0); // don't detach
  	489	apr_threadattr_stacksize_set(thread_attr,4096*10);
  	490
  	491	//
  	492	//100 was intended to be a command line argument but number of commandline args is growing out of control
  	493	slayer_server_log_open(&(server.lmanager),server.logfile,100,NULL);
  	494	slayer_server_log_open(&(server.elmanager),server.elogfile,100,NULL);
  	495	server.stats = slayer_server_stat_init(server.mpool,server.nslice,server.tslice);
  	496	for (i = 0; i < argc; i++) {
  	497	if (server.startup_args == NULL) {
  	498	server.startup_args = apr_pstrcat(server.mpool,argv[i],NULL);
  	499	} else {
  	500	server.startup_args = apr_pstrcat(server.mpool,server.startup_args," ",argv[i],NULL);
  	501	}
  	502	}
  	503
  	504	//setup outgoing thread.
  	505	{
  	506	apr_thread_t *thread;
  	507	apr_thread_create(&thread,thread_attr,handle_outgoing_response,&server,server.mpool);
  	508	*((apr_thread_t**)(apr_array_push(threads))) = thread;
  	509	}
  	510
  	511	for (i = 1; i < server.thread_count;i++) {
  	512	apr_thread_t *thread;
  	513	apr_thread_create(&thread,thread_attr,handle_running_request,&server,server.mpool);
  	514	*((apr_thread_t**)(apr_array_push(threads))) = thread;
  	515	}
  	516
  	517	//create a stats timer thread
  	518	slayer_server_stats_timer_thread(server.mpool,server.stats);
  	519
  	520	handle_incoming_connections(&server);
  	521
  	522	for (i = 0; i < server.thread_count;i++) {
  	523	apr_thread_t *thread = *((apr_thread_t**)(threads->elts + (threads->elt_size * i)));
  	524	apr_thread_join(&status,thread);
  	525	}
  	526
  	527	for(i = 0; i < server.service_map_size; i++) {
  	528	if(server.service_map[i]->service->service_global_destroy_func)
  	529	server.service_map[i]->service->service_global_destroy_func(server.service_map[i]->global_config);
  	530	}
  	531	slayer_server_log_close(server.lmanager);
  	532	slayer_server_log_close(server.elmanager);
  	533	apr_pool_destroy(server.mpool);
  	534	apr_terminate();
  	535	free(reldir);
  	536	return 0;
  	537	}

• /trunk/server/dbslayer.h

  ......	@@ -1,19 +0,0 @@
  1		#ifndef _QSERVER_H_
  2		#define _QSERVER_H_
  3
  4		#include <apr_general.h>
  5		#include <apr_network_io.h>
  6		#include <apr_strings.h>
  7		#include <apr_uri.h>
  8
  9		/* $Id: dbslayer.h,v 1.2 2007/05/09 20:55:00 derek Exp $ */
  10
  11		typedef struct _manager_t {
  12		char *user;
  13		char *pass;
  14		char *server;
  15		char *config;
  16		} manager_t;
  17
  18
  19		#endif

• /trunk/include/slayer_http_parse.h

  ......	@@ -0,0 +1,59 @@
  	1	#ifndef _SLAYER_HTTP_PARSE_H_
  	2	#define _SLAYER_HTTP_PARSE_H_
  	3
  	4	#include <apr_general.h>
  	5
  	6	#define INVALID_HTTP_REQUEST -1
  	7
  	8	enum PARSE_REQUEST_STATE {
  	9	PARSE_REQUEST_START = 0,
  	10	PARSE_WS_BEFORE_URI,
  	11	PARSE_REQUEST_METHOD,
  	12	PARSE_REQUEST_URI,
  	13	PARSE_WS_BEFORE_PROTOCOL,
  	14	PARSE_REQUEST_PROTOCOL_HT,
  	15	PARSE_REQUEST_PROTOCOL_HTT,
  	16	PARSE_REQUEST_PROTOCOL_HTTP,
  	17	PARSE_REQUEST_PROTOCOL_HTTP_SLASH,
  	18	PARSE_REQUEST_PROTOCOL_HTTP_MAJOR,
  	19	PARSE_REQUEST_PROTOCOL_HTTP_MAJOR_DOT,
  	20	PARSE_REQUEST_PROTOCOL_HTTP_MAJOR_DOT_MINOR,
  	21	PARSE_REQUEST_DONE_CR,
  	22	PARSE_REQUEST_DONE_LF,
  	23	PARSE_REQUEST_DONE
  	24	};
  	25	enum HTTP_METHOD { HTTP_METHOD_GET = 0, HTTP_METHOD_POST };
  	26	enum HTTP_PROTOCOL_VERSION { HTTP_10 = 0, HTTP_11 };
  	27
  	28	enum PARSE_HEADER_STATE {
  	29	PARSE_HEADER_START =0,
  	30	PARSE_HEADER_NAME,
  	31	PARSE_HEADER_START_LF,
  	32	PARSE_HEADER_SPACE_BEFORE_VALUE,
  	33	PARSE_HEADER_VALUE,
  	34	PARSE_HEADER_SPACE_AFTER_VALUE,
  	35	PARSE_HEADER_DONE_LF,
  	36	PARSE_HEADER_DONE,
  	37	};
  	38
  	39	typedef struct _slayer_http_request_parse_t {
  	40	enum PARSE_REQUEST_STATE request_state;
  	41	char method_string[6];
  	42	int method_size;
  	43	int uri_data_size;
  	44	char *uri_data;
  	45	char *uri_start;
  	46	char *uri_end;
  	47	enum HTTP_METHOD method;
  	48	enum HTTP_PROTOCOL_VERSION version;
  	49	enum PARSE_HEADER_STATE header_state;
  	50	char *buffer;
  	51	apr_size_t buffer_size;
  	52	char *buffer_marker;
  	53	} slayer_http_request_parse_t;
  	54
  	55	int slayer_http_request_parse_init(apr_pool_t *mpool, slayer_http_request_parse_t **parse, int uri_size);
  	56	int slayer_http_request_parse_destroy(slayer_http_request_parse_t *parse);
  	57	int slayer_http_request_line_parse(slayer_http_request_parse_t *parse);
  	58	int slayer_http_request_header_parse(slayer_http_request_parse_t *parse);
  	59	#endif /*_SLAYER_HTTP_PARSE_H_*/

• /trunk/common/Makefile.am

  ......	@@ -2,7 +2,7 @@
  2	2
  3	3	AM_CFLAGS = $(MYSQL_CFLAGS) $(APR_CFLAGS) $(APU_CFLAGS)
  4	4	INCLUDES = -I@top_srcdir@/include $(MYSQL_INCLUDES) $(APR_INCLUDES) $(APU_INCLUDES)
  5		SRC=simplejson.c jsonhelper.c urldecode.c serializejson.c slayer_utf8.c
  	5	SRC=json2xml.c jsonhelper.c json_skip.c qstring_parse.c serializejson.c simplejson.c slayer_http_fileserver.c slayer_http_parse.c slayer_http_server.c slayer_server_logging.c slayer_server_stats.c slayer_utf8.c urldecode.c
  6	6
  7	7	libsimplejson_a_SOURCES = $(SRC)
  8	8	#libsimplejson_a_LIBADD = $(APR_LIBS) $(APU_LIBS) $(MYSQL_LIBS)

• /trunk/common/slayer_http_parse.c

  ......	@@ -0,0 +1,339 @@
  	1	#include <stdio.h>
  	2	#include <string.h>
  	3	#include <ctype.h>
  	4	#include <stdlib.h>
  	5
  	6	#include "slayer_http_parse.h"
  	7
  	8	// NEED TO ADD IN VERSION THAT PLAYS NICE w/ apr mem pools
  	9	int slayer_http_request_parse_init(apr_pool_t *mpool, slayer_http_request_parse_t **parse, int uri_size) {
  	10	*parse = apr_pcalloc(mpool,sizeof(slayer_http_request_parse_t));
  	11
  	12	(*parse)->uri_data_size = uri_size;
  	13	(*parse)->uri_end = (*parse)->uri_start = (*parse)->uri_data = apr_pcalloc(mpool, sizeof(char) * (uri_size+1) );
  	14
  	15	(*parse)->buffer = apr_palloc(mpool,sizeof(char) * uri_size);
  	16	(*parse)->buffer_marker = NULL;
  	17	(*parse)->buffer_size = uri_size;
  	18	return 0;
  	19	}
  	20
  	21	int slayer_http_request_parse_destroy(slayer_http_request_parse_t *request) {
  	22	return 0;
  	23	}
  	24
  	25	int slayer_http_request_line_parse(slayer_http_request_parse_t *parse) {
  	26	enum PARSE_REQUEST_STATE state;
  	27	char *p = NULL;
  	28
  	29	state = parse->request_state;
  	30
  	31	for (p = parse->buffer_marker; p < (parse->buffer + parse->buffer_size);p++) {
  	32	switch (state) {
  	33	case PARSE_REQUEST_START:
  	34	if ( *p != 'G' && *p != 'P') {
  	35	return INVALID_HTTP_REQUEST;
  	36	}
  	37	parse->method_string[parse->method_size] = *p;
  	38	parse->method_size++;
  	39	state = PARSE_REQUEST_METHOD;
  	40	break;
  	41	case PARSE_REQUEST_METHOD:
  	42	if (parse->method_size > (sizeof(parse->method_string) -1) ) {
  	43	return INVALID_HTTP_REQUEST;
  	44	}
  	45	if (*p == ' ') {
  	46	switch (parse->method_size) {
  	47	case 3:
  	48	if (memcmp(parse->method_string,"GET",3)!=0) {
  	49	return INVALID_HTTP_REQUEST;
  	50	}
  	51	parse->method = HTTP_METHOD_GET;
  	52	state = PARSE_WS_BEFORE_URI;
  	53	break;
  	54	case 4:
  	55	if (memcmp(parse->method_string,"POST",4)!=0) {
  	56	return INVALID_HTTP_REQUEST;
  	57	}
  	58	parse->method = HTTP_METHOD_POST;
  	59	state = PARSE_WS_BEFORE_URI;
  	60	break;
  	61	default:
  	62	return INVALID_HTTP_REQUEST;
  	63	}
  	64	} else {
  	65	parse->method_string[parse->method_size] = *p;
  	66	parse->method_size++;
  	67	}
  	68	break;
  	69	case PARSE_WS_BEFORE_URI:
  	70	switch ( *p) {
  	71	case ' ':
  	72	break;
  	73	case '/':
  	74	*(parse->uri_end) = *p;
  	75	parse->uri_end++;
  	76	state = PARSE_REQUEST_URI;
  	77	break;
  	78	default:
  	79	return INVALID_HTTP_REQUEST;
  	80	}
  	81	break;
  	82	case PARSE_REQUEST_URI:
  	83	if ( (parse->uri_end - parse->uri_start) >= parse->uri_data_size) {
  	84	return INVALID_HTTP_REQUEST;
  	85	}
  	86	switch (*p) {
  	87	case ' ':
  	88	state = PARSE_WS_BEFORE_PROTOCOL;
  	89	break;
  	90	case '\0':
  	91	return INVALID_HTTP_REQUEST;
  	92	break;
  	93	default:
  	94	*(parse->uri_end) = *p;
  	95	parse->uri_end++;
  	96	break;
  	97	}
  	98	break;
  	99	case PARSE_WS_BEFORE_PROTOCOL:
  	100	switch ( *p) {
  	101	case ' ':
  	102	break;
  	103	case 'H':
  	104	state = PARSE_REQUEST_PROTOCOL_HT;
  	105	break;
  	106	default:
  	107	return INVALID_HTTP_REQUEST;
  	108	}
  	109	break;
  	110	case PARSE_REQUEST_PROTOCOL_HT:
  	111	switch ( *p) {
  	112	case 'T':
  	113	state = PARSE_REQUEST_PROTOCOL_HTT;
  	114	break;
  	115	default:
  	116	return INVALID_HTTP_REQUEST;
  	117	}
  	118	break;
  	119	case PARSE_REQUEST_PROTOCOL_HTT:
  	120	switch ( *p) {
  	121	case 'T':
  	122	state = PARSE_REQUEST_PROTOCOL_HTTP;
  	123	break;
  	124	default:
  	125	return INVALID_HTTP_REQUEST;
  	126	}
  	127	break;
  	128	case PARSE_REQUEST_PROTOCOL_HTTP:
  	129	switch ( *p) {
  	130	case 'P':
  	131	state = PARSE_REQUEST_PROTOCOL_HTTP_SLASH;
  	132	break;
  	133	default:
  	134	return INVALID_HTTP_REQUEST;
  	135	}
  	136	break;
  	137	case PARSE_REQUEST_PROTOCOL_HTTP_SLASH:
  	138	switch ( *p) {
  	139	case '/':
  	140	state = PARSE_REQUEST_PROTOCOL_HTTP_MAJOR;
  	141	break;
  	142	default:
  	143	return INVALID_HTTP_REQUEST;
  	144	}
  	145	break;
  	146	case PARSE_REQUEST_PROTOCOL_HTTP_MAJOR:
  	147	switch ( *p) {
  	148	case '1':
  	149	state = PARSE_REQUEST_PROTOCOL_HTTP_MAJOR_DOT;
  	150	break;
  	151	default:
  	152	return INVALID_HTTP_REQUEST;
  	153	}
  	154	break;
  	155	case PARSE_REQUEST_PROTOCOL_HTTP_MAJOR_DOT:
  	156	switch ( *p) {
  	157	case '.':
  	158	state = PARSE_REQUEST_PROTOCOL_HTTP_MAJOR_DOT_MINOR;
  	159	break;
  	160	default:
  	161	return INVALID_HTTP_REQUEST;
  	162	}
  	163	break;
  	164	case PARSE_REQUEST_PROTOCOL_HTTP_MAJOR_DOT_MINOR:
  	165	switch ( *p) {
  	166	case '0':
  	167	parse->version = HTTP_10;
  	168	state = PARSE_REQUEST_DONE_CR;
  	169	break;
  	170	case '1':
  	171	parse->version = HTTP_11;
  	172	state = PARSE_REQUEST_DONE_CR;
  	173	break;
  	174	default:
  	175	return INVALID_HTTP_REQUEST;
  	176	}
  	177	break;
  	178	case PARSE_REQUEST_DONE_CR:
  	179	switch ( *p) {
  	180	case '\n':
  	181	goto REQUEST_LINE_FINISHED;
  	182	break;
  	183	case '\r':
  	184	state = PARSE_REQUEST_DONE_LF;
  	185	break;
  	186	default:
  	187	return INVALID_HTTP_REQUEST;
  	188	}
  	189	break;
  	190	case PARSE_REQUEST_DONE_LF:
  	191	switch ( *p) {
  	192	case '\n':
  	193	goto REQUEST_LINE_FINISHED;
  	194	break;
  	195	default:
  	196	return INVALID_HTTP_REQUEST;
  	197	}
  	198	break;
  	199	case PARSE_REQUEST_DON