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.28 and 1.245.2.37.2.33

version 1.245.2.37.2.28, 2003/04/03 15:36:04	version 1.245.2.37.2.33, 2003/04/21 06:17:48
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 566 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, main_alias, register_file(*file_spec));	use_buf(aclass, source, main_alias, register_file(*file_spec));
}	}

Line 612 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 660 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 686 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 778 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.28
changed lines
	Added in v.1.245.2.37.2.33