parser3/src/targets/cgi/parser3.C - diff

Return to parser3.C CVS log

Up to [parser3project] / parser3 / src / targets / cgi

Diff for /parser3/src/targets/cgi/parser3.C between versions 1.151 and 1.194

version 1.151, 2002/01/31 10:20:21	version 1.194, 2002/08/14 11:37:14
Line 1	Line 1
/** @file	/** @file
Parser: scripting and CGI main.	Parser: scripting and CGI main.

Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)	Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexander Petrosyan <paf@design.ru>(http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)

$Id$
*/	*/

	static const char* IDENT_PARSER3_C="$Date$";

#include "pa_config_includes.h"	#include "pa_config_includes.h"

#if _MSC_VER	#if _MSC_VER
# include <new.h>	# include <new.h>
# include <crtdbg.h>	# include <crtdbg.h>
#else
# include "pa_config_paths.h"
#endif	#endif

#include "pa_sapi.h"	#include "pa_sapi.h"
Line 26	Line 24

#ifdef WIN32	#ifdef WIN32
# include <windows.h>	# include <windows.h>
	# include "getopt.h"
	#else
	# include <getopt.h>
#endif	#endif

	#include "fixopt.h"

//#define DEBUG_POOL_MALLOC	//#define DEBUG_POOL_MALLOC
	//#define DEBUG_STRING_APPENDS_VS_EXPANDS
	//#define DEBUG_MAILRECEIVE "test.eml"

	#ifdef DEBUG_STRING_APPENDS_VS_EXPANDS
	extern ulong
	string_piece_appends,
	wcontext_result_size,
	total_alloc_size,
	string_string_shortcut_economy;
	#endif

// consts	// consts

extern const char *main_RCSIds[];	#define REDIRECT_PREFIX "REDIRECT_"
#ifdef USE_SMTP	#define PARSER_CONFIG_ENV_NAME "CGI_PARSER_CONFIG"
extern const char *smtp_RCSIds[];
#endif
extern const char *gd_RCSIds[];
extern const char *classes_RCSIds[];
extern const char *types_RCSIds[];
extern const char *parser3_RCSIds[];
const char **RCSIds[]={
main_RCSIds,
#ifdef USE_SMTP
smtp_RCSIds,
#endif
gd_RCSIds,
classes_RCSIds,
types_RCSIds,
parser3_RCSIds,
0
};

/// IIS refuses to read bigger chunks	/// IIS refuses to read bigger chunks
const size_t READ_POST_CHUNK_SIZE=0x400*0x400; // 1M	const size_t READ_POST_CHUNK_SIZE=0x400*0x400; // 1M

const char *argv0;	static const char *argv0;
Pool_storage pool_storage;	static const char *config_filespec_cstr=0;
Pool pool(&pool_storage); // global pool [dont describe to doxygen: it confuses it with param names]	static bool fail_on_config_read_problem=true;
bool cgi; ///< we were started as CGI?
	static Pool *pool; // global pool [dont describe to doxygen: it confuses it with param names]
	static bool cgi; ///< we were started as CGI?
	static bool mail_received=false; ///< we were started with -m option? [asked to parse incoming message to $mail:received]

// SAPI	// SAPI

static void log(const char *fmt, va_list args) {	static void log(const char *fmt, va_list args) {
bool opened;	bool opened=false;
FILE *f=0;	FILE *f=0;

if(argv0) {	if(config_filespec_cstr) {
// beside by binary	char beside_config_path[MAX_STRING];
	strncpy(beside_config_path, config_filespec_cstr, MAX_STRING-1); beside_config_path[MAX_STRING-1]=0;
	if(!(
	rsplit(beside_config_path, '/') \|\|
	rsplit(beside_config_path, '\\'))) { // strip filename
	// no path, just filename
	beside_config_path[0]='.'; beside_config_path[1]=0;
	}

char file_spec[MAX_STRING];	char file_spec[MAX_STRING];
strncpy(file_spec, argv0, MAX_STRING-1); file_spec[MAX_STRING-1]=0; // filespec of my binary	snprintf(file_spec, MAX_STRING,
rsplit(file_spec, '/'); rsplit(file_spec, '\\');// strip filename	"%s/parser3.log", beside_config_path);
strcat(file_spec, "/parser3.log");
f=fopen(file_spec, "at");	f=fopen(file_spec, "at");
	opened=f!=0;
}	}
opened=f!=0;	// fallback to stderr
if(!opened)	if(!opened)
f=stderr;	f=stderr;

// prefix	// prefix
time_t t=time(0);	time_t t=time(0);
const char *stamp=ctime(&t);	if(const char *stamp=ctime(&t)) { // never saw that
fprintf(f, "[%.*s] ", strlen(stamp)-1, stamp);	if(size_t len=strlen(stamp)) // saw once stamp being =""
	fprintf(f, "[%.*s] ", len-1, stamp);
	}
// message	// message

char buf[MAX_STRING];	char buf[MAX_STRING];
Line 109 void SAPI::log(Pool& , const char *fmt,	Line 118 void SAPI::log(Pool& , const char *fmt,
void SAPI::die(const char *fmt, ...) {	void SAPI::die(const char *fmt, ...) {
#ifdef DEBUG_POOL_MALLOC	#ifdef DEBUG_POOL_MALLOC
extern void log_pool_stats(Pool& pool);	extern void log_pool_stats(Pool& pool);
log_pool_stats(pool);	log_pool_stats(*pool);
#endif	#endif

va_list args;	va_list args;
Line 130 void SAPI::die(const char *fmt, ...) {	Line 139 void SAPI::die(const char *fmt, ...) {

// prepare header	// prepare header
// let's be honest, that's bad we couldn't produce valid output	// let's be honest, that's bad we couldn't produce valid output
SAPI::add_header_attribute(pool, "status", "500");	SAPI::add_header_attribute(*pool, "status", "500");
SAPI::add_header_attribute(pool, "content-type", "text/plain");	SAPI::add_header_attribute(*pool, "content-type", "text/plain");
char content_length_cstr[MAX_NUMBER];	char content_length_cstr[MAX_NUMBER];
snprintf(content_length_cstr, MAX_NUMBER, "%u", content_length);	snprintf(content_length_cstr, sizeof(content_length_cstr), "%u", content_length);
SAPI::add_header_attribute(pool, "content-length", content_length_cstr);	SAPI::add_header_attribute(*pool, "content-length", content_length_cstr);

// send header	// send header
SAPI::send_header(pool);	SAPI::send_header(*pool);

// body	// body
SAPI::send_body(pool, body, content_length);	SAPI::send_body(*pool, body, content_length);

exit(1);	exit(1);
}	}
Line 149 const char *SAPI::get_env(Pool& , const	Line 158 const char *SAPI::get_env(Pool& , const
return getenv(name);	return getenv(name);
}	}

	const char const SAPI::environment(Pool&) {
	#ifdef _MSC_VER
	extern char **_environ;
	return _environ;
	#else
	extern char **environ;
	return environ;
	#endif
	}

size_t SAPI::read_post(Pool& , char *buf, size_t max_bytes) {	size_t SAPI::read_post(Pool& , char *buf, size_t max_bytes) {
size_t read_size=0;	size_t read_size=0;
do {	do {
Line 183 void SAPI::send_body(Pool& , const void	Line 202 void SAPI::send_body(Pool& , const void

//	//

char full_file_spec(char file_name) {	static void full_file_spec(const char file_name, char buf, size_t buf_size) {
if(file_name && !strchr(file_name, '/')) {	if(file_name)
static char cwd[MAX_STRING]; getcwd(cwd, MAX_STRING);	if(file_name[0]=='/'
static char buf[MAX_STRING];	#ifdef WIN32
snprintf(buf, MAX_STRING, "%s/%s", cwd, file_name);	\|\| (file_name[0] && file_name[1]==':')
return buf;	#endif
}	)
return file_name;	strncpy(buf, file_name, buf_size);
	else {
	char cwd[MAX_STRING]; getcwd(cwd, MAX_STRING);
	snprintf(buf, buf_size, "%s/%s", cwd, file_name);
	}
	else
	buf[0]=0;
	#ifdef WIN32
	back_slashes_to_slashes(buf);
	#endif
}	}

/**	/**
Line 202 main workhorse	Line 230 main workhorse
wich is tested but seems slow.	wich is tested but seems slow.
IIS5 todo find out proper 'illegal call' check	IIS5 todo find out proper 'illegal call' check
*/	*/
void real_parser_handler(	static void real_parser_handler(
const char *filespec_to_process,	const char *filespec_to_process,
const char *request_method, bool header_only) {	const char *request_method, bool header_only) {
// init socks	// init socks
init_socks(pool);	init_socks(*pool);

// init global classes	// init global classes
init_methoded_array(pool);	init_methoded_array(*pool);
// init global variables	// init global variables
pa_globals_init(pool);	pa_globals_init(*pool);

if(!filespec_to_process)	if(!filespec_to_process \|\| !*filespec_to_process)
SAPI::die("Parser/%s", PARSER_VERSION);	SAPI::die("Parser/%s", PARSER_VERSION);

// Request info	// Request info
Request::Info request_info;	Request::Info request_info;
	char document_root_buf[MAX_STRING];
if(cgi) {	if(cgi) {
if(const char *env_document_root=SAPI::get_env(pool, "DOCUMENT_ROOT"))	if(const char env_document_root=SAPI::get_env(pool, "DOCUMENT_ROOT"))
request_info.document_root=env_document_root;	request_info.document_root=env_document_root;
else if(const char *path_info=SAPI::get_env(pool, "PATH_INFO")) {	else if(const char path_info=SAPI::get_env(pool, "PATH_INFO")) {
// IIS	// IIS
size_t len=strlen(filespec_to_process)-strlen(path_info);	size_t len=min(sizeof(document_root_buf)-1, strlen(filespec_to_process)-strlen(path_info));
char buf=(char )pool.malloc(len+1);	memcpy(document_root_buf, filespec_to_process, len); document_root_buf[len]=0;
memcpy(buf, filespec_to_process, len); buf[len]=0;	request_info.document_root=document_root_buf;
request_info.document_root=buf;
} else	} else
throw Exception(0, 0,	throw Exception("parser.runtime",
0,	0,
"CGI: no PATH_INFO defined(in reinventing DOCUMENT_ROOT)");	"CGI: no PATH_INFO defined(in reinventing DOCUMENT_ROOT)");
} else {	} else {
static char buf[MAX_STRING];	full_file_spec("", document_root_buf, sizeof(document_root_buf));
strncpy(buf, filespec_to_process, MAX_STRING-1); buf[MAX_STRING-1]=0;	request_info.document_root=document_root_buf;
if(rsplit(buf, '/') \|\| rsplit(buf, '\\')) // strip filename
request_info.document_root=buf;
else
request_info.document_root="";
}	}
request_info.path_translated=filespec_to_process;	request_info.path_translated=filespec_to_process;
request_info.method=request_method ? request_method : "GET";	request_info.method=request_method ? request_method : "GET";
const char *query_string=SAPI::get_env(pool, "QUERY_STRING");	const char query_string=SAPI::get_env(pool, "QUERY_STRING");
request_info.query_string=query_string;	request_info.query_string=query_string;
if(cgi) {	if(cgi) {
if(const char *env_request_uri=SAPI::get_env(pool, "REQUEST_URI"))	if(const char env_request_uri=SAPI::get_env(pool, "REQUEST_URI"))
request_info.uri=env_request_uri;	request_info.uri=env_request_uri;
else if(const char *path_info=SAPI::get_env(pool, "PATH_INFO"))	else if(const char path_info=SAPI::get_env(pool, "PATH_INFO"))
if(query_string) {	if(query_string) {
char reconstructed_uri=(char )pool.malloc(	char reconstructed_uri=(char )pool->malloc(
strlen(path_info)+1/'?'/+	strlen(path_info)+1/'?'/+
strlen(query_string)+1/0/);	strlen(query_string)+1/0/);
strcpy(reconstructed_uri, path_info);	strcpy(reconstructed_uri, path_info);
Line 257 void real_parser_handler(	Line 281 void real_parser_handler(
request_info.uri=reconstructed_uri;	request_info.uri=reconstructed_uri;
} else	} else
request_info.uri=path_info;	request_info.uri=path_info;
else	else
throw Exception(0, 0,	throw Exception("parser.runtime",
0,	0,
"CGI: no PATH_INFO defined(in reinventing REQUEST_URI)");	"CGI: no PATH_INFO defined(in reinventing REQUEST_URI)");

#ifndef WIN32	#ifndef WIN32
// they've changed this under IIS5.	// they've changed this under IIS5.
if(const char *script_name=SAPI::get_env(pool, "SCRIPT_NAME")) {	if(const char script_name=SAPI::get_env(pool, "SCRIPT_NAME")) {
size_t script_name_len=strlen(script_name);	size_t script_name_len=strlen(script_name);
size_t uri_len=strlen(request_info.uri);	size_t uri_len=strlen(request_info.uri);
if(strncmp(request_info.uri,script_name, script_name_len)==0 &&	if(strncmp(request_info.uri,script_name, script_name_len)==0 &&
Line 273 void real_parser_handler(	Line 297 void real_parser_handler(
}	}
#endif	#endif
} else	} else
request_info.uri=0;	request_info.uri="";

request_info.content_type=SAPI::get_env(pool, "CONTENT_TYPE");	request_info.content_type=SAPI::get_env(*pool, "CONTENT_TYPE");
const char *content_length=SAPI::get_env(pool, "CONTENT_LENGTH");	const char content_length=SAPI::get_env(pool, "CONTENT_LENGTH");
request_info.content_length=(content_length?atoi(content_length):0);	request_info.content_length=(content_length?atoi(content_length):0);
request_info.cookie=SAPI::get_env(pool, "HTTP_COOKIE");	request_info.cookie=SAPI::get_env(*pool, "HTTP_COOKIE");
request_info.user_agent=SAPI::get_env(pool, "HTTP_USER_AGENT");	request_info.mail_received=mail_received;

// prepare to process request	// prepare to process request
Request request(pool,	Request request(*pool,
request_info,	request_info,
#ifdef _DEBUG	/*#ifdef _DEBUG
String::UL_HTML\|String::UL_OPTIMIZE_BIT	String::UL_HTML\|String::UL_OPTIMIZE_BIT
#else	#else*/
cgi ? String::UL_HTML\|String::UL_OPTIMIZE_BIT : String::UL_AS_IS	cgi ? String::UL_HTML\|String::UL_OPTIMIZE_BIT : String::UL_AS_IS
#endif	/#endif/
,	,
true /* status_allowed */);	true /* status_allowed */);

// some root-controlled location	char config_filespec_buf[MAX_STRING];
#ifdef PARSER_ROOT_CONFIG_DIR	if(!config_filespec_cstr) {
const char *root_config_filespec=PARSER_ROOT_CONFIG_DIR "/" CONFIG_FILE_NAME;	const char *config_by_env=getenv(PARSER_CONFIG_ENV_NAME);
#else	if(!config_by_env)
# ifdef WIN32	config_by_env=getenv(REDIRECT_PREFIX PARSER_CONFIG_ENV_NAME);
// c:\windows	if(config_by_env)
char root_config_path[MAX_STRING];	config_filespec_cstr=config_by_env;
GetWindowsDirectory(root_config_path, MAX_STRING);	else {
	// beside by binary
char root_config_filespec[MAX_STRING];	char beside_binary_path[MAX_STRING];
snprintf(root_config_filespec, MAX_STRING,	strncpy(beside_binary_path, argv0, MAX_STRING-1); beside_binary_path[MAX_STRING-1]=0; // filespec of my binary
"%s/%s",	if(!(
root_config_path, CONFIG_FILE_NAME);	rsplit(beside_binary_path, '/') \|\|
# else	rsplit(beside_binary_path, '\\'))) { // strip filename
#error must be compiled either configure/make or MSVC++	// no path, just filename
# endif	// @todo full path, not ./!
#endif	beside_binary_path[0]='.'; beside_binary_path[1]=0;
	}
// beside by binary	snprintf(config_filespec_buf, MAX_STRING,
// @todo full path, not ./!	"%s/%s",
static char site_config_path[MAX_STRING];	beside_binary_path, AUTO_FILE_NAME);
strncpy(site_config_path, argv0, MAX_STRING-1); site_config_path[MAX_STRING-1]=0; // filespec of my binary	config_filespec_cstr=config_filespec_buf;
if(!(	fail_on_config_read_problem=false;
rsplit(site_config_path, '/') \|\|	}
rsplit(site_config_path, '\\'))) { // strip filename
// no path, just filename
site_config_path[0]='.'; site_config_path[1]=0;
}	}

char site_config_filespec[MAX_STRING];
snprintf(site_config_filespec, MAX_STRING,
"%s/%s",
site_config_path, CONFIG_FILE_NAME);

// process the request	// process the request
request.core(	request.core(
root_config_filespec, false,	config_filespec_cstr, fail_on_config_read_problem,
site_config_filespec, false,
header_only);	header_only);

//	//
Line 337 void real_parser_handler(	Line 352 void real_parser_handler(

#ifdef DEBUG_POOL_MALLOC	#ifdef DEBUG_POOL_MALLOC
extern void log_pool_stats(Pool& pool);	extern void log_pool_stats(Pool& pool);
log_pool_stats(pool);	log_pool_stats(*pool);
	#endif

	#ifdef DEBUG_STRING_APPENDS_VS_EXPANDS
	SAPI::log(*pool,
	"string piece appends=%lu, wcontext_result_size=%lu, string_string_shortcut_economy_closer=%lu, total_alloc_size=%lu",
	string_piece_appends,
	wcontext_result_size,
	string_string_shortcut_economy,
	total_alloc_size);
#endif	#endif

}	}

void call_real_parser_handler__do_SEH(	static void call_real_parser_handler__do_SEH(
const char *filespec_to_process,	const char *filespec_to_process,
const char *request_method, bool header_only) {	const char *request_method, bool header_only) {
#if _MSC_VER && !defined(_DEBUG)	#if _MSC_VER && !defined(_DEBUG)
Line 359 void call_real_parser_handler__do_SEH(	Line 384 void call_real_parser_handler__do_SEH(

if(system_exception)	if(system_exception)
if(_EXCEPTION_RECORD *er=system_exception->ExceptionRecord)	if(_EXCEPTION_RECORD *er=system_exception->ExceptionRecord)
throw Exception(0, 0,	throw Exception(0,
0,	0,
"Exception 0x%08X at 0x%08X", er->ExceptionCode, er->ExceptionAddress);	"Exception 0x%08X at 0x%08X", er->ExceptionCode, er->ExceptionAddress);
else	else
throw Exception(0, 0, 0, "Exception <no exception record>");	throw Exception(0, 0, "Exception <no exception record>");
else	else
throw Exception(0, 0, 0, "Exception <no exception information>");	throw Exception(0, 0, "Exception <no exception information>");
}	}
#endif	#endif
}	}
Line 378 int failed_new(size_t size) {	Line 403 int failed_new(size_t size) {
#endif	#endif

#ifdef HAVE_SET_NEW_HANDLER	#ifdef HAVE_SET_NEW_HANDLER
void failed_new() {	static void failed_new() {
SAPI::die("out of memory in 'new'");	SAPI::die("out of memory in 'new'");
}	}
#endif	#endif

int main(int argc, char *argv[]) {	static void usage(const char *program) {
	printf(
	"Parser/%s Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)\n"
	"Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)\n"
	"\n"
	"Usage: %s [options] file\n"
	"Options are:\n"
	#ifdef WITH_MAILRECEIVE
	" -m Parse mail, put received letter to $mail:received\n"
	#endif
	" -f config_file Use this config file (/path/to/auto.p)\n"
	" -h Display usage information (this message)\n"
	, PARSER_VERSION,
	program);
	exit(EINVAL);
	}

	int main(int raw_argc, char *raw_argv[]) {
	int argc;
	char **argv;
	fixopt(
	raw_argc, raw_argv,
	argc, argv);

	Pool_storage global_pool_storage;
	Pool global_pool(&global_pool_storage);
	pool=&global_pool;

	#ifdef DEBUG_MAILRECEIVE
	if(FILE *fake_in=fopen(DEBUG_MAILRECEIVE, "rt")) {
	dup2(fake_in->_file, 0/STDIN_FILENO/);
	}
	#endif

	#ifdef _DEBUG
	// _crtBreakAlloc=33112;
	#endif
// _asm int 3;	// _asm int 3;
argv0=argv[0];	argv0=argv[0];

Line 396 int main(int argc, char *argv[]) {	Line 457 int main(int argc, char *argv[]) {
getenv("GATEWAY_INTERFACE") \|\|	getenv("GATEWAY_INTERFACE") \|\|
getenv("REQUEST_METHOD");	getenv("REQUEST_METHOD");

if(!cgi) {	char *raw_filespec_to_process;
if(argc<2) {	if(cgi)
printf(	raw_filespec_to_process=getenv("PATH_TRANSLATED");
"Parser/%s Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)\n"	else {
"Author: Alexander Petrosyan <paf@design.ru>(http://paf.design.ru)\n"	optind = 1;
"\n"	opterr = 0;
"Usage: %s <file>\n",	int c;
PARSER_VERSION,	while((c = getopt(argc, argv, "hf:"
argv0?argv0:"parser3");	#ifdef WITH_MAILRECEIVE
return 1;	"m"
	#endif
	)) > 0) {
	switch (c) {
	case 'h':
	usage(argv[0]);
	break;
	case 'f':
	config_filespec_cstr=optarg;
	break;
	#ifdef WITH_MAILRECEIVE
	case 'm':
	mail_received=true;
	break;
	#endif
	default:
	fprintf(stderr, "%s: invalid option '%c'\n", argv[0], optopt);
	usage(argv[0]);
	break;
	}
	}
	if (optind != argc - 1) {
	fprintf(stderr, "%s: file not specified\n", argv[0]);
	usage(argv[0]);
}	}

	raw_filespec_to_process=argv[optind++];
}	}

#ifdef WIN32	#ifdef WIN32
Line 437 int main(int argc, char *argv[]) {	Line 523 int main(int argc, char *argv[]) {
std::set_new_handler(failed_new);	std::set_new_handler(failed_new);
#endif	#endif

char *filespec_to_process=cgi?getenv("PATH_TRANSLATED"):argv[1];	char filespec_to_process[MAX_STRING];
#ifdef WIN32	full_file_spec(raw_filespec_to_process, filespec_to_process, sizeof(filespec_to_process));
back_slashes_to_slashes(filespec_to_process);
#endif
filespec_to_process=full_file_spec(filespec_to_process);

const char *request_method=getenv("REQUEST_METHOD");	const char *request_method=getenv("REQUEST_METHOD");
bool header_only=request_method && strcasecmp(request_method, "HEAD")==0;	bool header_only=request_method && strcasecmp(request_method, "HEAD")==0;
Line 466 int main(int argc, char *argv[]) {	Line 549 int main(int argc, char *argv[]) {
#ifndef WIN32	#ifndef WIN32
//	//
if(!cgi)	if(!cgi)
SAPI::send_body(pool, "\n", 1);	SAPI::send_body(*pool, "\n", 1);
#endif	#endif
	//_asm int 3;
return 0;	return 0;
}	}

E-mail:

Removed from v.1.151
changed lines
	Added in v.1.194