parser3/src/include/pa_request.h - diff

Return to pa_request.h CVS log

Up to [parser3project] / parser3 / src / include

Diff for /parser3/src/include/pa_request.h between versions 1.96 and 1.148

version 1.96, 2001/09/21 15:35:45	version 1.148, 2002/09/18 08:52:50
Line 1	Line 1
/** @file	/** @file
Parser: request class decl.	Parser: request class decl.

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

$Id$
*/	*/

#ifndef PA_REQUEST_H	#ifndef PA_REQUEST_H
#define PA_REQUEST_H	#define PA_REQUEST_H

#include "pa_config_includes.h"	static const char* IDENT_REQUEST_H="$Date$";

#include "pa_pool.h"	#include "pa_pool.h"
#include "pa_hash.h"	#include "pa_hash.h"
#include "pa_wcontext.h"	#include "pa_wcontext.h"
Line 20	Line 18
#include "pa_vclass.h"	#include "pa_vclass.h"
#include "pa_vobject.h"	#include "pa_vobject.h"
#include "pa_venv.h"	#include "pa_venv.h"
	#include "pa_vstatus.h"
#include "pa_vform.h"	#include "pa_vform.h"
	#include "pa_vmail.h"
#include "pa_vmath.h"	#include "pa_vmath.h"
#include "pa_vrequest.h"	#include "pa_vrequest.h"
#include "pa_vresponse.h"	#include "pa_vresponse.h"
#include "pa_vcookie.h"	#include "pa_vcookie.h"
#include "pa_sql_driver_manager.h"	#include "pa_sql_driver_manager.h"

	#ifdef RESOURCES_DEBUG
	#include <sys/resource.h>
	#endif

	// consts

	#define MAIN_METHOD_NAME "main"
	const uint ANTI_ENDLESS_EXECUTE_RECOURSION=500;

	// defines

#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
# define COMPILE_PARAMS \	# define COMPILE_PARAMS \
const char *source, \	const char *source, \
Line 46	Line 57

class Temp_lang;	class Temp_lang;
class Methoded;	class Methoded;
	class VMethodFrame;

/// Main workhorse.	/// Main workhorse.
class Request : public Pooled {	class Request : public Pooled {
friend Temp_lang;	friend class Temp_lang;
	friend class Temp_connection;
	friend class Request_context_saver;
public:	public:

	#ifdef RESOURCES_DEBUG
	/// measures
	double sql_connect_time;
	double sql_request_time;
	#endif

/// some information from web server	/// some information from web server
class Info {	class Info {
public:	public:
Line 63 public:	Line 83 public:
const char *content_type;	const char *content_type;
size_t content_length;	size_t content_length;
const char *cookie;	const char *cookie;
const char *user_agent;	bool mail_received;
};	};

Request(Pool& apool,	Request(Pool& apool,
Info& ainfo,	Info& ainfo,
String::Untaint_lang adefault_lang ///< all tainted data default untainting lang	uchar adefault_lang, ///< all tainted data default untainting lang
	bool status_allowed ///< status class allowed
);	);
~Request() {}	~Request();

/// global classes	/// global classes
Hash& classes() { return fclasses; }	Hash& classes() { return fclasses; }
Line 81 public:	Line 102 public:
BEWARE: may throw exception to you: catch it!	BEWARE: may throw exception to you: catch it!
*/	*/
void core(	void core(
const char *root_config_filespec, ///< system config filespec	const char *config_filespec, ///< system config filespec
bool root_config_fail_on_read_problem, ///< fail if system config file not found	bool config_fail_on_read_problem, ///< fail if system config file not found
const char *site_config_filespec, ///< site config filespec
bool site_config_fail_on_read_problem, ///< fail if site config file not found
bool header_only);	bool header_only);

/// executes ops	/// executes ops
void execute(const Array& ops); // execute.C	void execute(const Array& ops); // execute.C
	/// execute ops with anti-recoursion check
	void recoursion_checked_execute(const String *name, const Array& ops) {
	// anti_endless_execute_recoursion
	if(++anti_endless_execute_recoursion==ANTI_ENDLESS_EXECUTE_RECOURSION) {
	anti_endless_execute_recoursion=0; // give @exception a chance
	throw Exception("parser.runtime",
	name,
	"call canceled - endless recursion detected");
	}
	execute(ops); // execute it
	anti_endless_execute_recoursion--;
	}

/// compiles the file, maybe forcing it's class @a name and @a base_class.	/// compiles the file, maybe forcing it's class @a name and @a base_class.
VStateless_class *use_file(	VStateless_class *use_file(
Line 98 public:	Line 129 public:
VStateless_class *base_class=0); // core.C	VStateless_class *base_class=0); // core.C
/// compiles a @a source buffer	/// compiles a @a source buffer
VStateless_class *use_buf(	VStateless_class *use_buf(
const char source, const char file,	const char source, const String& filespec, const char filespec_cstr,
VStateless_class aclass=0, const String name=0,	VStateless_class aclass=0, const String name=0,
VStateless_class *base_class=0); // core.C	VStateless_class *base_class=0); // core.C

/// processes any code-junction there may be inside of @a value	/// processes any code-junction there may be inside of @a value
Value& process(	StringOrValue process(Value& input_value, bool intercept_string=true); // execute.C
Value& value,	//@{ convinient helpers
const String *name=0,	const String& process_to_string(Value& input_value) {
bool intercept_string=true); // execute.C	return process(input_value, true/intercept_string/).as_string();
	}
	Value& process_to_value(Value& input_value, bool intercept_string=true) {
	return process(input_value, intercept_string).as_value();
	}
	//@}


	#define DEFINE_DUAL(modification) \
	void write_##modification##_lang(StringOrValue dual) { \
	if(const String *string=dual.get_string()) \
	write_##modification##_lang(*string); \
	else \
	write_##modification##_lang(*dual.get_value()); \
	}
	#define DEFINE_DUAL_CHECKED(modification) \
	void write_##modification##_lang(StringOrValue dual, const String *origin) { \
	if(const String *string=dual.get_string()) \
	write_##modification##_lang(*string); \
	else \
	write_##modification##_lang(*dual.get_value(), origin); \
	}

/// appending, sure of clean string inside	/// appending, sure of clean string inside
void write_no_lang(const String& astring) {	void write_no_lang(const String& astring) {
wcontext->write(astring, String::UL_CLEAN);	wcontext->write(astring,
	String::UL_CLEAN \| flang&String::UL_OPTIMIZE_BIT);
}	}
	/// appending sure value, that would be converted to clean string
	void write_no_lang(Value& avalue) {
	if(wcontext->get_in_expression())
	wcontext->write(avalue);
	else
	wcontext->write(avalue,
	String::UL_CLEAN \| flang&String::UL_OPTIMIZE_BIT);
	}
	//DEFINE_DUAL(no)

/// appending string, passing language built into string being written	/// appending string, passing language built into string being written
void write_pass_lang(const String& astring) {	void write_pass_lang(const String& astring) {
wcontext->write(astring, String::UL_PASS_APPENDED);	wcontext->write(astring, String::UL_PASS_APPENDED);
}	}
/// appending possible string, assigning untaint language
void write_assign_lang(Value& avalue) {
wcontext->write(avalue, flang);
}
/// appending possible string, passing language built into string being written	/// appending possible string, passing language built into string being written
void write_pass_lang(Value& avalue) {	void write_pass_lang(Value& avalue) {
wcontext->write(avalue, String::UL_PASS_APPENDED);	wcontext->write(avalue, String::UL_PASS_APPENDED);
}	}
/// appending sure value, that would be converted to clean string	DEFINE_DUAL(pass)
void write_no_lang(Value& avalue) {
wcontext->write(avalue, String::UL_CLEAN);	/// appending possible string, assigning untaint language
	void write_assign_lang(Value& avalue) {
	wcontext->write(avalue, flang);
	}
	/// appending possible string, assigning untaint language
	void write_assign_lang(Value& avalue, const String *origin) {
	wcontext->write(avalue, flang, origin);
}	}
/// appending sure value, not VString	/// appending string, assigning untaint language
void write_expr_result(Value& avalue) {	void write_assign_lang(const String& astring) {
wcontext->write(avalue);	wcontext->write(astring, flang);
}	}
	DEFINE_DUAL(assign)
	DEFINE_DUAL_CHECKED(assign)

/// returns relative to @a path path to @a file	/// returns relative to @a path path to @a file
const String& relative(const char *apath, const String& relative_name);	const String& relative(const char *apath, const String& relative_name);
Line 141 public:	Line 209 public:
/// returns the mime type of 'user_file_name_cstr'	/// returns the mime type of 'user_file_name_cstr'
const String& mime_type_of(const char *user_file_name_cstr);	const String& mime_type_of(const char *user_file_name_cstr);

	/// returns current SQL connection if any
	SQL_Connection connection(const String source) {
	if(!fconnection && source)
	throw Exception("parser.runtime",
	source,
	"outside of 'connect' operator");

	return fconnection;
	}

	bool origins_mode() {
	return main_class->get_element(*origins_mode_name, main_class, false)!=0; // $ORIGINS mode
	}

public:	public:

/// info from web server	/// info from web server
Info& info;	Info& info;
/// user's post data	/// user's post data
char *post_data; size_t post_size;	const char *post_data; size_t post_size;

	/// name of 'main' method
	const String main_method_name;

/// operators are methods of this class	/// operators are methods of this class
Methoded& OP;	Methoded& OP;
/// $env:fields	/// $env:fields
VEnv env;	VEnv env;
	/// $status:fields
	VStatus status;
/// $form:elements	/// $form:elements
VForm form;	VForm form;
	/// $mail
	VMail mail;
/// $math:constants	/// $math:constants
VMath math;	VMath math;
/// $request:elements	/// $request:elements
Line 163 public:	Line 252 public:
/// $cookie:elements	/// $cookie:elements
VCookie cookie;	VCookie cookie;

/// contexts
Value self, root, *rcontext;
/// contexts
WContext *wcontext;

/// 'MAIN' class conglomerat	/// 'MAIN' class conglomerat
VStateless_class *main_class;	VStateless_class *main_class;

/// connection
SQL_Connection *connection;
/// PCRE character tables
unsigned char *pcre_tables;

/// classes configured data	/// classes configured data
Hash classes_conf;	Hash classes_conf;

	private:

	//@{ request processing status
	/// exception stack trace
	Stack exception_trace;
	/// execution stack
	Stack stack;
	/// contexts
	Value *self;
	VMethodFrame *method_frame;
	Value *rcontext;
	WContext *wcontext;
	/// current language
	uchar flang;
	/// current connection
	SQL_Connection *fconnection;
	//@}

	public: // status read methods

	Value *get_self() { return self; }
	VMethodFrame *get_method_frame() { return method_frame; }

private: // core data	private: // core data

Line 188 private: // core data	Line 289 private: // core data
/// already used files to avoid cyclic uses	/// already used files to avoid cyclic uses
Hash used_files;	Hash used_files;

/// execution stack
Stack stack;

/** endless execute(execute(... preventing counter	/** endless execute(execute(... preventing counter
@see ANTI_ENDLESS_EXECUTE_RECOURSION	@see ANTI_ENDLESS_EXECUTE_RECOURSION
*/	*/
uint anti_endless_execute_recoursion;	uint anti_endless_execute_recoursion;

	private:

	/// already executed some @conf method
	bool configure_admin_done;

	void configure_admin(VStateless_class& conf_class, const String *source);

private: // compile.C	private: // compile.C

VStateless_class& real_compile(COMPILE_PARAMS);	VStateless_class& real_compile(COMPILE_PARAMS);

private: // execute.C	private: // execute.C

const String *execute_method(Value& aself,	/// for @postprocess[body]
const Method& method, bool return_cstr=true);	const String& execute_method(VMethodFrame& amethodFrame, const Method& method);
const String *execute_virtual_method(Value& aself,	//{ for @conf[filespec] and @auto[filespec]
const String& method_name, bool return_cstr=true);	void execute_method(Value& aself,
const String *execute_nonvirtual_method(VStateless_class& aclass,	const Method& method, VString *optional_param,
const String& method_name, bool return_cstr=true);	const String **return_string);
	void execute_nonvirtual_method(VStateless_class& aclass,
	const String& method_name, VString *optional_param,
	const String **return_string,
	const Method **return_method=0);
	//}
	/// for @main[]
	const String *execute_virtual_method(Value& aself, const String& method_name);

Value *get_element();	Value get_element(const String & remember_name, bool can_call_operator);

private: // lang&raw

String::Untaint_lang flang;

private: // defaults	private: // defaults

const String::Untaint_lang fdefault_lang;	const uchar fdefault_lang;
Value *default_content_type;	Value *default_content_type;

private: // mime types	private: // mime types
Line 227 private: // mime types	Line 335 private: // mime types

private: // lang manipulation	private: // lang manipulation

String::Untaint_lang set_lang(String::Untaint_lang alang) {	uchar set_lang(uchar alang) {
String::Untaint_lang result=flang;	uchar result=flang;
flang=alang;	flang=alang;
return result;	return result;
}	}
void restore_lang(String::Untaint_lang alang) {	void restore_lang(uchar alang) {
flang=alang;	flang=alang;
}	}

	private: // connection manipulation

	SQL_Connection set_connection(SQL_Connection aconnection) {
	SQL_Connection *result=fconnection;
	fconnection=aconnection;
	return result;
	}
	void restore_connection(SQL_Connection *aconnection) {
	fconnection=aconnection;
	}

private:	private:

void output_result(const VFile& body_file, bool header_only);	void output_result(const VFile& body_file, bool header_only);
};	};

	/// Auto-object used to save request context across ^try body
	class Request_context_saver {

	Request& fr;

	/// exception stack trace
	int exception_trace;
	/// execution stack
	int stack;
	/// contexts
	Value *self;
	VMethodFrame *method_frame;
	Value *rcontext;
	WContext *wcontext;
	/// current language
	uchar flang;
	/// current connection
	SQL_Connection *fconnection;

	public:
	Request_context_saver(Request& ar) :
	exception_trace(ar.exception_trace.top_index()),
	stack(ar.stack.top_index()),
	self(ar.self),
	method_frame(ar.method_frame),
	rcontext(ar.rcontext),
	wcontext(ar.wcontext),
	flang(ar.flang),
	fconnection(ar.fconnection),
	fr(ar) {}
	~Request_context_saver() {
	fr.exception_trace.top_index(exception_trace);
	fr.stack.top_index(stack);
	fr.self=self; fr.method_frame=method_frame, fr.rcontext=rcontext; fr.wcontext=wcontext;
	fr.flang=flang;
	fr.fconnection=fconnection;
	}
	};

/// Auto-object used for temporary changing Request::flang.	/// Auto-object used for temporary changing Request::flang.
class Temp_lang {	class Temp_lang {
Request& frequest;	Request& frequest;
String::Untaint_lang saved_lang;	uchar saved_lang;
public:	public:
Temp_lang(Request& arequest, String::Untaint_lang alang) :	Temp_lang(Request& arequest, uchar alang) :
frequest(arequest),	frequest(arequest),
saved_lang(arequest.set_lang(alang)) {	saved_lang(arequest.set_lang(alang)) {
}	}
Line 255 public:	Line 413 public:
}	}
};	};

	/// Auto-object used for temporary changing Request::fconnection.
	class Temp_connection {
	Request& frequest;
	SQL_Connection *saved_connection;
	public:
	Temp_connection(Request& arequest, SQL_Connection *aconnection) :
	frequest(arequest),
	saved_connection(arequest.set_connection(aconnection)) {
	}
	~Temp_connection() {
	frequest.restore_connection(saved_connection);
	}
	};

/**	/**
@b method parameters passed in this array.	@b method parameters passed in this array.
contains handy typecast ad junction/not junction ensurers	contains handy typecast ad junction/not junction ensurers
Line 279 public:	Line 451 public:
return get_as(index, false, msg);	return get_as(index, false, msg);
}	}
/// handy expression auto-processing to double	/// handy expression auto-processing to double
double as_double(int index, Request& r) {	double as_double(int index, const char *msg, Request& r) {
return get_processed(index, r).as_double();	return get_processed(index, msg, r).as_double();
}	}
/// handy expression auto-processing to int	/// handy expression auto-processing to int
int as_int(int index, Request& r) {	int as_int(int index, const char *msg, Request& r) {
return get_processed(index, r).as_int();	return get_processed(index, msg, r).as_int();
	}
	/// handy expression auto-processing to bool
	bool as_bool(int index, const char *msg, Request& r) {
	return get_processed(index, msg, r).as_bool();
}	}
/// handy string ensurer	/// handy string ensurer
const String& as_string(int index, const char *msg) {	const String& as_string(int index, const char *msg) {
Line 297 private:	Line 473 private:
Value& get_as(int index, bool as_junction, const char *msg) {	Value& get_as(int index, bool as_junction, const char *msg) {
Value& result=get(index);	Value& result=get(index);
if((result.get_junction()!=0) ^ as_junction)	if((result.get_junction()!=0) ^ as_junction)
THROW(0, 0,	throw Exception("parser.runtime",
&fmethod_name,	&fmethod_name,
"%s (parameter #%d)", msg, 1+index);	"%s (parameter #%d)", msg, 1+index);

return result;	return result;
}	}

Value& get_processed(int index, Request& r) {	Value& get_processed(int index, const char *msg, Request& r) {
return r.process(get(index),	return r.process_to_value(as_junction(index, msg), 0/no name/);
0/no name/,
false/don't intercept string/);
}	}

private:	private:

E-mail:

Removed from v.1.96
changed lines
	Added in v.1.148