parser3/src/main/pa_request.C - diff

Return to pa_request.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_request.C between versions 1.245.2.37.2.24 and 1.245.2.37.2.34

version 1.245.2.37.2.24, 2003/04/03 10:18:24	version 1.245.2.37.2.34, 2003/07/23 08:40:54
Line 189 Request::~Request() {	Line 189 Request::~Request() {

Value& Request::get_self() { return method_frame/always have!/->self(); }	Value& Request::get_self() { return method_frame/always have!/->self(); }

static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, int) {	static void load_charset(HashStringValue::key_type akey,
::charsets.load_charset(*new String(akey, String::L_CLEAN), avalue->as_string());	HashStringValue::value_type avalue,
	Request_charsets* charsets) {
	const StringBody NAME=String(akey, String::L_CLEAN).change_case(charsets->source(), String::CC_UPPER);
	::charsets.load_charset(*charsets, NAME, avalue->as_string());
}	}
void Request::configure_admin(VStateless_class& conf_class) {	void Request::configure_admin(VStateless_class& conf_class) {
if(configure_admin_done)	if(configure_admin_done)
Line 210 void Request::configure_admin(VStateless	Line 213 void Request::configure_admin(VStateless
if(Value* vcharsets=conf_class.get_element(charsets_name, conf_class, false)) {	if(Value* vcharsets=conf_class.get_element(charsets_name, conf_class, false)) {
if(!vcharsets->is_string())	if(!vcharsets->is_string())
if(HashStringValue* charsets=vcharsets->get_hash())	if(HashStringValue* charsets=vcharsets->get_hash())
charsets->for_each(load_charset, 0);	charsets->for_each(load_charset, &this->charsets);
else	else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
0,	0,
Line 246 gettimeofday(&mt[0],NULL);	Line 249 gettimeofday(&mt[0],NULL);
if(config_filespec) {	if(config_filespec) {
const String& filespec=*new String(config_filespec);	const String& filespec=*new String(config_filespec);
use_file(main_class,	use_file(main_class,
filespec, true/* ignore class_path */,	filespec, 0 /main_alias/,
config_fail_on_read_problem, true/* file must exist if 'fail on read problem' not set */);	true /ignore class_path/,
	config_fail_on_read_problem,
	true /file must exist if 'fail on read problem' not set/);
}	}

// loading auto.p files from document_root/..	// loading auto.p files from document_root/..
Line 272 gettimeofday(&mt[0],NULL);	Line 277 gettimeofday(&mt[0],NULL);
sfile_spec << "/" AUTO_FILE_NAME;	sfile_spec << "/" AUTO_FILE_NAME;

use_file(main_class,	use_file(main_class,
sfile_spec, true/* ignore class_path */,	sfile_spec,
true/* fail on read problem /, false/ but ignore absence, sole user */);	0 /main_alias/,
	true /ignore class_path/,
	true /fail on read problem/,
	false /but ignore absence, sole user/);
}	}
after=before+1;	after=before+1;
}	}
Line 283 gettimeofday(&mt[0],NULL);	Line 291 gettimeofday(&mt[0],NULL);
String& spath_translated=*new String;	String& spath_translated=*new String;
spath_translated.append_help_length(request_info.path_translated, 0, String::L_TAINTED);	spath_translated.append_help_length(request_info.path_translated, 0, String::L_TAINTED);
use_file(main_class,	use_file(main_class,
spath_translated, true/* ignore class_path */,	spath_translated,
true/* fail on read problem/, true/ fail on abscence */);	0 /main_alias/,
	true /ignore class_path/);

// configure method_frame options if not configured yet	// configure method_frame options if not configured yet
if(!configure_admin_done)	if(!configure_admin_done)
Line 389 t[9]-t[3]	Line 398 t[9]-t[3]

if(details.problem_source) { // do we know the guy?	if(details.problem_source) { // do we know the guy?
if(details.trace) { // do whe know where he came from?	if(details.trace) { // do whe know where he came from?
Operation::Info origin=details.trace.origin();	Operation::Origin origin=details.trace.origin();
SAPI::log(sapi_info,	SAPI::log(sapi_info,
PA_URI_FORMAT	PA_URI_FORMAT
PA_ORIGIN_FILE_POS_FORMAT	PA_ORIGIN_FILE_POS_FORMAT
PA_SOURCE_FORMAT PA_COMMENT_TYPE_FORMAT,	PA_SOURCE_FORMAT PA_COMMENT_TYPE_FORMAT,
request_info.uri,	request_info.uri,
file_list[origin.file_no], 1+origin.line, 1+origin.col,	file_list[origin.file_no].cstr(), 1+origin.line, 1+origin.col,
details.problem_source->cstr(),	details.problem_source->cstr(),
e.comment(), e.type()	e.comment(), e.type()
);	);
Line 447 Table::columns_type stack_trace_columns(	Line 456 Table::columns_type stack_trace_columns(
*stack_trace_columns+=new String("colno");	*stack_trace_columns+=new String("colno");
Table& stack_trace=*new Table(stack_trace_columns);	Table& stack_trace=*new Table(stack_trace_columns);
if(!exception_trace.is_empty()/signed!/)	if(!exception_trace.is_empty()/signed!/)
for(size_t i=exception_trace.bottom_index(); i<=exception_trace.top_index(); i++) {	for(size_t i=exception_trace.bottom_index(); i<exception_trace.top(); i++) {
Trace trace=exception_trace.get(i);	Trace trace=exception_trace.get(i);
Table::element_type row(new ArrayString);	Table::element_type row(new ArrayString);

*row+=trace.name(); // name column	*row+=trace.name(); // name column
Operation::Info origin=trace.origin();	Operation::Origin origin=trace.origin();
if(origin.file_no) {	if(origin.file_no) {
*row+=new String(file_list[origin.file_no], String::L_TAINTED); // 'file' column	*row+=new String(file_list[origin.file_no], String::L_TAINTED); // 'file' column
*row+=new String(StringBody::Format(1+origin.line), String::L_CLEAN); // 'lineno' column	*row+=new String(StringBody::Format(1+origin.line), String::L_CLEAN); // 'lineno' column
Line 515 size_t Request::register_file(StringBody	Line 524 size_t Request::register_file(StringBody
}	}

void Request::use_file(VStateless_class& aclass,	void Request::use_file(VStateless_class& aclass,
const String& file_name, bool ignore_class_path,	const String& file_name, const String* main_alias,
bool fail_on_read_problem, bool fail_on_file_absence) {	bool ignore_class_path,
	bool fail_on_read_problem,
	bool fail_on_file_absence) {
// cyclic dependence check	// cyclic dependence check
if(used_files.get(file_name))	if(used_files.get(file_name))
return;	return;
Line 558 void Request::use_file(VStateless_class&	Line 569 void Request::use_file(VStateless_class&
if(!entry_exists(*file_spec))	if(!entry_exists(*file_spec))
return;	return;

if(const char* source=file_read_text(charsets.source(), *file_spec, fail_on_read_problem))	if(const char* source=file_read_text(charsets, *file_spec, fail_on_read_problem))
use_buf(aclass, source, register_file(*file_spec));	use_buf(aclass, source, main_alias, register_file(*file_spec));
}	}


void Request::use_buf(VStateless_class& aclass,	void Request::use_buf(VStateless_class& aclass,
const char* source,	const char* source, const String* main_alias,
uint file_no) {	uint file_no) {
// temporary zero @conf so to maybe-replace it in compiled code	// temporary zero @conf so to maybe-replace it in compiled code
Temp_method temp_method_conf(aclass, conf_method_name, 0);	Temp_method temp_method_conf(aclass, conf_method_name, 0);
Line 572 void Request::use_buf(VStateless_class&	Line 583 void Request::use_buf(VStateless_class&
Temp_method temp_method_auto(aclass, auto_method_name, 0);	Temp_method temp_method_auto(aclass, auto_method_name, 0);

// compile loaded class	// compile loaded class
VStateless_class& cclass=compile(&aclass, source, file_no);	VStateless_class& cclass=compile(&aclass, source, main_alias, file_no);

// locate and execute possible @conf[] static	// locate and execute possible @conf[] static
VString* vfilespec=	VString* vfilespec=
Line 604 const String& Request::absolute(const St	Line 615 const String& Request::absolute(const St
result << relative_name;	result << relative_name;
return result;	return result;
} else	} else
return relative_name.pos("://")==STRING_NOT_FOUND?	if(relative_name.pos("://")!=STRING_NOT_FOUND // something like "http://xxx"
relative(request_info.path_translated, relative_name)	#ifdef WIN32
:relative_name; // something like "http://xxx"	\|\| relative_name.pos(":")==1 // DRIVE:
	\|\| relative_name.starts_with("\\\\") // UNC1
	\|\| relative_name.starts_with("//") // UNC2
	#endif
	)
	return relative_name;
	else
	return relative(request_info.path_translated, relative_name);
}	}

static void add_header_attribute(	static void add_header_attribute(
Line 652 void Request::output_result(VFile* body_	Line 670 void Request::output_result(VFile* body_
// prepare header: $response:fields without :body	// prepare header: $response:fields without :body
response.fields().for_each(add_header_attribute, this);	response.fields().for_each(add_header_attribute, this);

const void *client_body;
size_t client_content_length;
// transcode text body when "text/*" or simple result	// transcode text body when "text/*" or simple result
if(body_file_content_type)	if(body_file_content_type)
if(HashStringValue *hash=body_file_content_type->get_hash())	if(HashStringValue *hash=body_file_content_type->get_hash())
body_file_content_type=hash->get(value_name);	body_file_content_type=hash->get(value_name);
if(!body_file_content_type/vstring.as_vfile/ \|\| body_file_content_type->as_string().pos("text/")==0) {	String::C output(body_file->value_ptr(), body_file->value_size());
Charset::transcode(	if(!body_file_content_type/vstring.as_vfile/ \|\| body_file_content_type->as_string().pos("text/")==0)
charsets.source(), body_file->value_ptr(), body_file->value_size(),	output=Charset::transcode(output,
charsets.client(), client_body, client_content_length	charsets.source(),
);	charsets.client());
} else {
client_body=body_file->value_ptr();
client_content_length=body_file->value_size();
}

// prepare header: content-length	// prepare header: content-length
char content_length_cstr[MAX_NUMBER];	char content_length_cstr[MAX_NUMBER];
snprintf(content_length_cstr, MAX_NUMBER, "%u", client_content_length);	snprintf(content_length_cstr, MAX_NUMBER, "%u", output.length);
SAPI::add_header_attribute(sapi_info, "content-length", content_length_cstr);	SAPI::add_header_attribute(sapi_info, "content-length", content_length_cstr);

// send header	// send header
Line 678 void Request::output_result(VFile* body_	Line 690 void Request::output_result(VFile* body_

// send body	// send body
if(!header_only)	if(!header_only)
SAPI::send_body(sapi_info, client_body, client_content_length);	SAPI::send_body(sapi_info, output.str, output.length);
}	}

const String& Request::mime_type_of(const char* user_file_name_cstr) {	const String& Request::mime_type_of(const char* user_file_name_cstr) {
if(mime_types)	if(mime_types)
if(const char* cext=strrchr(user_file_name_cstr, '.')) {	if(const char* cext=strrchr(user_file_name_cstr, '.')) {
String sext(++cext);	String sext(++cext);
if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER)))	Table::Action_options options;
	if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER), options))
if(const String* result=mime_types->item(1))	if(const String* result=mime_types->item(1))
return *result;	return *result;
else	else
Line 725 const Request::Trace Request::Exception_	Line 738 const Request::Trace Request::Exception_
fbottom++;	fbottom++;
} else if(result.name()==problem_source) // it is that same guy?	} else if(result.name()==problem_source) // it is that same guy?
fbottom++; // throw away that trace	fbottom++; // throw away that trace
else // stack top contains not us	// else stack top contains not us,
result.clear();	// leaving result intact
	// it would help ^throw
}	}

return result;	return result;
Line 752 Request::Exception_details Request::get_	Line 766 Request::Exception_details Request::get_

// $.file lineno colno	// $.file lineno colno
if(trace) {	if(trace) {
const Operation::Info origin=trace.origin();	const Operation::Origin origin=trace.origin();
hash.put(StringBody("file"),	hash.put(StringBody("file"),
new VString(*new String(file_list[origin.file_no], String::L_TAINTED)));	new VString(*new String(file_list[origin.file_no], String::L_TAINTED)));
hash.put(StringBody("lineno"), new VInt(1+origin.line));	hash.put(StringBody("lineno"), new VInt(1+origin.line));
Line 769 Request::Exception_details Request::get_	Line 783 Request::Exception_details Request::get_

return Request::Exception_details(trace, problem_source, vhash);	return Request::Exception_details(trace, problem_source, vhash);
}	}

//

E-mail:

Removed from v.1.245.2.37.2.24
changed lines
	Added in v.1.245.2.37.2.34