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.192 and 1.255

version 1.192, 2009/05/04 09:26:08	version 1.255, 2020/11/03 16:25:49
Line 1	Line 1
/** @file	/** @file
Parser: request class decl.	Parser: request class decl.

Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

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

static const char * const IDENT_REQUEST_H="$Date$";	#define IDENT_PA_REQUEST_H "$Id$"

#include "pa_pool.h"	#include "pa_pool.h"
#include "pa_hash.h"	#include "pa_hash.h"
Line 18 static const char * const IDENT_REQUEST_	Line 18 static const char * const IDENT_REQUEST_
#include "pa_request_info.h"	#include "pa_request_info.h"
#include "pa_request_charsets.h"	#include "pa_request_charsets.h"
#include "pa_sapi.h"	#include "pa_sapi.h"
#include "pa_vconsole.h"

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

// consts	// consts

const uint ANTI_ENDLESS_EXECUTE_RECOURSION=1000;
const size_t pseudo_file_no__process=1;	const size_t pseudo_file_no__process=1;

// forwards	// forwards
Line 39 class VForm;	Line 33 class VForm;
class VResponse;	class VResponse;
class VCookie;	class VCookie;
class VStateless_class;	class VStateless_class;
	class VConsole;

	extern int pa_loop_limit;
	extern int pa_execute_recoursion_limit;
	extern size_t pa_file_size_limit;

/// Main workhorse.	/// Main workhorse.
class Request: public PA_Object {	class Request: public PA_Object {
friend class Temp_lang;	friend class Temp_lang;
friend class Temp_connection;	friend class Temp_connection;
friend class Request_context_saver;
friend class Temp_request_self;	friend class Temp_request_self;
	friend class Temp_value_element;
	friend class Request_context_saver;
friend class Exception_trace;	friend class Exception_trace;

public:	public:
Line 55 public:	Line 55 public:
public:	public:
Trace(): fname(0) {}	Trace(): fname(0) {}
void clear() { fname=0; }	void clear() { fname=0; }
operator bool() const { return fname!=0; }

Trace(const String* aname, const Operation::Origin aorigin):	Trace(const String* aname, const Operation::Origin aorigin):
fname(aname), forigin(aorigin) {}	fname(aname), forigin(aorigin) {}
Line 66 public:	Line 65 public:

enum Skip {	enum Skip {
SKIP_NOTHING,	SKIP_NOTHING,
	SKIP_CONTINUE,
SKIP_BREAK,	SKIP_BREAK,
SKIP_CONTINUE	SKIP_RETURN,
	SKIP_INTERRUPTED
};	};

private:	private:
Line 88 private:	Line 89 private:
ArrayOperation& ops() const { return *fops; }	ArrayOperation& ops() const { return *fops; }
VMethodFrame& method_frame() const { return *fmethod_frame; }	VMethodFrame& method_frame() const { return *fmethod_frame; }

/// needed to fill unused Array entries	StackItem(Value& avalue): fvalue(&avalue) {}
StackItem() {}
StackItem(Value& avalue): fvalue(&avalue) {}
StackItem(ArrayOperation& aops): fops(&aops) {}	StackItem(ArrayOperation& aops): fops(&aops) {}
StackItem(VMethodFrame& amethod_frame): fmethod_frame(&amethod_frame) {}	StackItem(VMethodFrame& amethod_frame): fmethod_frame(&amethod_frame) {}
};	};
Line 111 private:	Line 110 private:
bool is_empty() {	bool is_empty() {
return fused==fbottom;	return fused==fbottom;
}	}

const element_type extract_origin(const String*& problem_source);
};	};

///@{ core data	///@{ core data

/// classes	/// classes
HashStringValue fclasses;	HashString<VStateless_class*> fclasses;

/// already used files to avoid cyclic uses	/// already used files to avoid cyclic uses
Hash<const String::Body, bool> used_files;	HashString<bool> used_files;
	HashString<bool> searched_along_class_path;
/// list of all used files, Operation::file_no = index to it	/// list of all used files, Operation::file_no = index to it
Array<String::Body> file_list;	Array<String::Body> file_list;

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

///@}	///@}

Line 139 private:	Line 135 private:
Exception_trace exception_trace;	Exception_trace exception_trace;
public:	public:

	bool allow_class_replace;

//@{ request processing status	//@{ request processing status
/// contexts	/// contexts
VMethodFrame* method_frame;	VMethodFrame* method_frame;
Value* rcontext;	Value* rcontext;
WContext* wcontext;	WContext* wcontext;
/// current language	/// current language
String::Language flang;	String::Language flang;
/// current connection	/// current connection
SQL_Connection* fconnection;	SQL_Connection* fconnection;
//@}	//@}
/// interrupted flag, raised on signals [SIGPIPE]
bool finterrupted;	private:

	int fin_cycle;
Skip fskip;	Skip fskip;
	VMethodFrame* freturn_method_frame;

public:	public:
uint register_file(String::Body file_spec);	uint register_file(String::Body file_spec);

struct Exception_details {	struct Exception_details {
const Trace trace;	const Operation::Origin origin;
const String* problem_source;	const String* problem_source;
VHash& vhash;	VHash& vhash;
	Exception_details(const Operation::Origin aorigin, const String* aproblem_source, VHash& avhash): origin(aorigin), problem_source(aproblem_source), vhash(avhash) {}
Exception_details(
const Trace atrace,
const String* aproblem_source,
VHash& avhash): trace(atrace), problem_source(aproblem_source), vhash(avhash) {}
};	};
Exception_details get_details(const Exception& e);	Exception_details get_details(const Exception& e);
const char* get_exception_cstr(const Exception& e, Exception_details& details);	const char* get_exception_cstr(const Exception& e, Exception_details& details);
Line 181 public:	Line 178 public:
#endif	#endif

Request(SAPI_Info& asapi_info, Request_info& arequest_info,	Request(SAPI_Info& asapi_info, Request_info& arequest_info,
String::Language adefault_lang, ///< all tainted data default untainting lang	String::Language adefault_lang ///< all tainted data default untainting lang
bool status_allowed ///< status class allowed
);	);
~Request();	~Request();

/// global classes	/// global classes
HashStringValue& classes() { return fclasses; }	HashString<VStateless_class*>& classes() { return fclasses; }
	VStateless_class* get_class(const String& name);
	void put_class(VStateless_class *aclass){ classes().put(aclass->type(), aclass); }

/**	/**
core request processing	core request processing

BEWARE: may throw exception to you: catch it!	BEWARE: may throw exception to you: catch it!
*/	*/
void core(	void core(const char* config_filespec, bool header_only);
const char* config_filespec, ///< system config filespec
bool config_fail_on_read_problem, ///< fail if system config file not found
bool header_only);

/// executes ops	/// executes ops
void execute(ArrayOperation& ops); // execute.C	void execute(ArrayOperation& ops); // execute.C
void op_call(VMethodFrame &frame);
void op_call_write(VMethodFrame &frame);	template<typename Frame> void call(Frame& frame){
	VMethodFrame *saved_method_frame=method_frame;
	Value* saved_rcontext=rcontext;
	WContext *saved_wcontext=wcontext;

	rcontext=wcontext=method_frame=&frame;

	frame.call(*this);

	wcontext=saved_wcontext;
	rcontext=saved_rcontext;
	method_frame=saved_method_frame;
	}

	template<typename Frame> void call_write(Frame& frame){
	VMethodFrame *saved_method_frame=method_frame;
	Value* saved_rcontext=rcontext;

	rcontext=method_frame=&frame;

	frame.call(*this);

	rcontext=saved_rcontext;
	method_frame=saved_method_frame;
	}

	Value& construct(VStateless_class &class_value, const Method &method);

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

/// compiles the file, maybe forcing it's class @a name and @a base_class.	///
void use_file(VStateless_class& aclass,	void use_file_directly(const String& file_spec, bool fail_on_file_absence=true, bool with_auto_p=false);
const String& file_name,
const String* main_alias=0,	/// compiles the file in main class context by default
bool ignore_class_path=false,	void use_file(const String& file_name, const String* use_filespec, bool with_auto_p=false);
bool fail_on_read_problem=true,
bool fail_on_file_absence=true); // pa_request.C	/// for @USE only, calls ^use (which may be user-defined)
	void use_file(const String& file_name, const String* use_filespec, Operation::Origin origin);

/// compiles a @a source buffer	/// compiles a @a source buffer
void use_buf(VStateless_class& aclass,	void use_buf(VStateless_class& aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset=0);
const char* source,
const String* main_alias,
uint file_no,
int line_no_offset=0); // pa_request.C

/// processes any code-junction there may be inside of @a value	/// processes any code-junction there may be inside of @a value
StringOrValue process(Value& input_value, bool intercept_string=true); // execute.C	Value& process_getter(Junction& junction); // execute.C
	Value& process(Value& input_value); // execute.C
void process_write(Value& input_value); // execute.C	void process_write(Value& input_value); // execute.C

//@{ convinient helpers	//@{ convinient helpers
const String& process_to_string(Value& input_value) {	const String& process_to_string(Value& input_value) {
return process(input_value, true/intercept_string/).as_string();	return process(input_value).as_string();
}
Value& process_to_value(Value& input_value, bool intercept_string=true) {
return process(input_value, intercept_string).as_value();
}	}
//@}	//@}
	const Operation::Origin get_method_origin(const Method* method); // execute.C
	const String* get_method_filespec(const Method* method); // execute.C
	const String* get_used_filespec(uint file_no);

	/// appending string with it's languages
	inline void write(const String& astring) {
	wcontext->write(astring);
	}

#define DEFINE_DUAL(modification) \	/// in [] and {} appending string if get_string is not null, else appending value
void write_##modification##_lang(StringOrValue dual) { \	/// in () appending string if is_string, else appending value
if(const String* string=dual.get_string()) \	inline void write(Value& avalue) {
write_##modification##_lang(*string); \	wcontext->write_as_string(avalue);
else \	}
write_##modification##_lang(*dual.get_value()); \
}	/// allways appending value
	inline void write_value(Value& avalue) {
/// appending, sure of clean string inside	wcontext->write(avalue);
void write_no_lang(const String& astring) {
wcontext->write(astring,
(String::Language)(String::L_CLEAN \| flang&String::L_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::Language)(String::L_CLEAN \| flang&String::L_OPTIMIZE_BIT));
}

/// appending string, passing language built into string being written
void write_pass_lang(const String& astring) {
wcontext->write(astring, String::L_PASS_APPENDED);
}
/// appending possible string, passing language built into string being written
void write_pass_lang(Value& avalue) {
wcontext->write(avalue, String::L_PASS_APPENDED);
}
DEFINE_DUAL(pass)

/// appending possible string, assigning untaint language
void write_assign_lang(Value& avalue) {
wcontext->write(avalue, flang);
}
/// appending string, assigning untaint language
void write_assign_lang(const String& astring) {
wcontext->write(astring, flang);
}	}
DEFINE_DUAL(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 291 public:	Line 282 public:
/// returns an absolute @a path to relative @a name	/// returns an absolute @a path to relative @a name
const String& absolute(const String& relative_name);	const String& absolute(const String& relative_name);

	/// returns the mime type of 'user_file_name'
	const String& mime_type_of(const String* file_name);

/// 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	/// returns current SQL connection if any
SQL_Connection* connection(bool fail_on_error=true) {	SQL_Connection* connection(bool fail_on_error=true) {
if(fail_on_error && !fconnection)	if(fail_on_error && !fconnection)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "outside of 'connect' operator");
0,	return fconnection;
"outside of 'connect' operator");

return fconnection;
}	}

void set_interrupted(bool ainterrupted) { finterrupted=ainterrupted; }
bool get_interrupted() { return finterrupted; }

void set_skip(Skip askip) { fskip=askip; }
Skip get_skip() { return fskip; }	Skip get_skip() { return fskip; }
	void set_skip(Skip askip) { fskip=askip; }
	void set_skip_return(VMethodFrame& amethod_frame) { fskip=SKIP_RETURN; freturn_method_frame=&amethod_frame; }
	inline bool check_skip_break() { bool result=fskip >= SKIP_BREAK; if(fskip <= SKIP_BREAK) fskip=SKIP_NOTHING; return result; }
	inline void check_skip_return() { if(fskip==SKIP_RETURN && method_frame==freturn_method_frame) fskip=SKIP_NOTHING; }

	void set_in_cycle(int adelta) { fin_cycle+=adelta; }
	bool get_in_cycle() { return fin_cycle>0; }

public:	public:

Line 335 public:	Line 329 public:
VConsole& console;	VConsole& console;

/// classes configured data	/// classes configured data
Hash<const String::Body, void*> classes_conf;	HashString<void*> classes_conf;

public: // status read methods	public: // status read methods

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

#define GET_SELF(request, type) (static_cast<type &>(request.get_self()))	#define GET_SELF(request, type) (static_cast<type &>(request.get_self()))
/* for strange reason call to this:
r.get_self<VHash>()
refuses to compile

template<typename T> T& get_self() {	/// public for ^reflection:copy[]
return static_cast<T>(get_self().get());	void put_element(Value& ncontext, const String& name, Value* value);
}
*/

/// for @main[]	/// for @main[] and parser://method/call
const String* execute_virtual_method(Value& aself, const String& method_name);	const String* execute_method(VStateless_class& aclass, const String& method_name, Value* optional_param = 0);

	//{ for @conf[filespec] and @auto[filespec]
	bool execute_method_if_exists(VStateless_class& aclass, const String& method_name, Value* optional_param);

/// for @postprocess[body]
StringOrValue execute_method(VMethodFrame& amethodFrame, const Method& method);
//{ for @conf[filespec] and @auto[filespec] and parser://method/call
const String* execute_method(Value& aself,
const Method& method, Value* optional_param,
bool do_return_string);
struct Execute_nonvirtual_method_result {
const String* string;
Method* method;
Execute_nonvirtual_method_result(): string(0), method(0) {}
};
Execute_nonvirtual_method_result execute_nonvirtual_method(VStateless_class& aclass,
const String& method_name,
VString* optional_param,
bool do_return_string);
//}	//}

#ifdef XML	#ifdef XML
Line 394 private:	Line 372 private:

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

ArrayClass& compile(VStateless_class* aclass,	ArrayClass& compile(VStateless_class* aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset);
const char* source, const String* main_alias,
uint file_no,
int line_no_offset);

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

void put_element(Value& ncontext, const String& name, Value* value);
Value& get_element(Value& ncontext, const String& name);	Value& get_element(Value& ncontext, const String& name);
	#ifdef FEATURE_GET_ELEMENT4CALL
	Value& get_element4call(Value& ncontext, const String& name);
	#endif

private: // defaults	private: // defaults

Line 413 private: // mime types	Line 390 private: // mime types
/// $MAIN:MIME-TYPES	/// $MAIN:MIME-TYPES
Table *mime_types;	Table *mime_types;

private: // lang manipulation

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

private: // connection manipulation	private: // connection manipulation

SQL_Connection* set_connection(SQL_Connection* aconnection) {	SQL_Connection* set_connection(SQL_Connection* aconnection) {
Line 460 class Request_context_saver {	Line 426 class Request_context_saver {
SQL_Connection* fconnection;	SQL_Connection* fconnection;

public:	public:
Request_context_saver(Request& ar) :	Request_context_saver(Request& ar) :
fr(ar),	fr(ar),
exception_trace_top(ar.exception_trace.top_index()),	exception_trace_top(ar.exception_trace.top_index()),
exception_trace_bottom(ar.exception_trace.bottom_index()),	exception_trace_bottom(ar.exception_trace.bottom_index()),
stack(ar.stack.top_index()),	stack(ar.stack.top_index()),
anti_endless_execute_recoursion(ar.anti_endless_execute_recoursion),	anti_endless_execute_recoursion(ar.anti_endless_execute_recoursion),
method_frame(ar.method_frame),	method_frame(ar.method_frame),
Line 482 public:	Line 448 public:
}	}
};	};

/// Auto-object used for temporary changing Request::flang.	/// Auto-object used for temporary changing Request::fconnection.
class Temp_lang {	class Temp_connection {
Request& frequest;	Request& frequest;
String::Language saved_lang;	SQL_Connection* saved_connection;
public:	public:
Temp_lang(Request& arequest, String::Language alang) :	Temp_connection(Request& arequest, SQL_Connection* aconnection) :
frequest(arequest),	frequest(arequest),
saved_lang(arequest.set_lang(alang)) {	saved_connection(arequest.set_connection(aconnection)) {
}	}
~Temp_lang() {	~Temp_connection() {
frequest.restore_lang(saved_lang);	frequest.restore_connection(saved_connection);
}	}
};	};

/// Auto-object used for temporary changing Request::fconnection.	/// Auto-object used for break out of cycle check
class Temp_connection {	class InCycle {
Request& frequest;	Request& frequest;
SQL_Connection* saved_connection;
public:	public:
Temp_connection(Request& arequest, SQL_Connection* aconnection) :	InCycle(Request& arequest) : frequest(arequest) {
frequest(arequest),	frequest.set_in_cycle(1);
saved_connection(arequest.set_connection(aconnection)) {
}	}
~Temp_connection() {	~InCycle() {
frequest.restore_connection(saved_connection);	frequest.set_in_cycle(-1);
}	}
};	};

	/// Auto-object used for break out of cycle check
	class TempSkip4Delimiter {
	Request& frequest;
	Request::Skip fskip;
	public:
	TempSkip4Delimiter(Request& arequest) : frequest(arequest), fskip(arequest.get_skip()) {
	frequest.set_skip(Request::SKIP_NOTHING);
	}
	// returns true if break required, should be called
	bool check_break() {
	if(frequest.get_skip())
	fskip=frequest.get_skip();
	frequest.set_skip(fskip <= Request::SKIP_BREAK ? Request::SKIP_NOTHING : fskip);
	return fskip >= Request::SKIP_BREAK;
	}
	};

// defines for externs	/// Auto-object used for temporary changing Request::allow_class_replace.
	class Temp_class_replace {
	Request& frequest;
	public:
	Temp_class_replace(Request& arequest, bool avalue) : frequest(arequest){
	frequest.allow_class_replace=avalue;
	}
	~Temp_class_replace() {
	frequest.allow_class_replace=false;
	}
	};

	/// Auto-object used for temporarily substituting/removing elements
	class Temp_value_element {
	Request& frequest;
	Value& fwhere;
	const String& fname;
	Value* saved;
	public:
	Temp_value_element(Request& arequest, Value& awhere, const String& aname, Value* awhat);
	~Temp_value_element();
	};

#define CONTENT_TRANSFER_ENCODING_NAME "content-transfer-encoding"	// defines for externs
#define CONTENT_DISPOSITION_NAME "content-disposition"
#define CONTENT_DISPOSITION_ATTACHMENT "attachment"
#define CONTENT_DISPOSITION_INLINE "inline"
#define CONTENT_DISPOSITION_FILENAME_NAME "filename"

#define EXCEPTION_HANDLED_PART_NAME "handled"	#define EXCEPTION_HANDLED_PART_NAME "handled"

Line 526 public:	Line 523 public:

extern const String main_method_name;	extern const String main_method_name;
extern const String auto_method_name;	extern const String auto_method_name;
extern const String body_name;

extern const String content_transfer_encoding_name;
extern const String content_disposition_name;
extern const String content_disposition_attachment;
extern const String content_disposition_inline;
extern const String content_disposition_filename_name;

extern const String exception_type_part_name;	extern const String exception_type_part_name;
extern const String exception_source_part_name;	extern const String exception_source_part_name;

E-mail:

Removed from v.1.192
changed lines
	Added in v.1.255