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.255 and 1.288

version 1.255, 2020/11/03 16:25:49	version 1.288, 2026/10/16 13:55:16
Line 1	Line 1
/** @file	/** @file
Parser: request class decl.	Parser: request class decl.

Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2026 Art. Lebedev Studio (https://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
*/	*/

#ifndef PA_REQUEST_H	#ifndef PA_REQUEST_H
Line 12	Line 12

#include "pa_pool.h"	#include "pa_pool.h"
#include "pa_hash.h"	#include "pa_hash.h"
	#include "pa_file.h"
#include "pa_wcontext.h"	#include "pa_wcontext.h"
#include "pa_value.h"	#include "pa_value.h"
	#include "pa_vhash.h"
	#include "pa_vresponse.h"
#include "pa_stack.h"	#include "pa_stack.h"
#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"

	// externs

	extern const String main_method_name;
	extern const String auto_method_name;

	// defines for statics

	#define MAIN_CLASS_NAME "MAIN"
	#define AUTO_FILE_NAME "auto.p"

// consts	// consts

const size_t pseudo_file_no__process=1;	const size_t pseudo_file_no__process=1;

// forwards	// forwards

class Temp_lang;
class Methoded;	class Methoded;
class VMethodFrame;	class VMethodFrame;
class VMail;	class VMail;
class VForm;	class VForm;
class VResponse;
class VCookie;	class VCookie;
class VStateless_class;	class VStateless_class;
class VConsole;	class VConsole;
	class WebSocket;
	class VException;

extern int pa_loop_limit;	extern int pa_loop_limit;
extern int pa_execute_recoursion_limit;	extern int pa_array_limit;
	extern int pa_execute_recursion_limit;
	extern int pa_httpd_timeout;
extern size_t pa_file_size_limit;	extern size_t pa_file_size_limit;

	class Code_cache;

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

public:	public:
class Trace {	class Trace {
Line 102 private:	Line 121 private:
size_t bottom_index() { return fbottom; }	size_t bottom_index() { return fbottom; }
void set_bottom_index(size_t abottom) { fbottom=abottom; }	void set_bottom_index(size_t abottom) { fbottom=abottom; }
element_type bottom_value() { return get(bottom_index()); }	element_type bottom_value() { return get(bottom_index()); }
	void set_range(size_t bottom, size_t top) { fbottom=bottom; fsize=top; }

void clear() {	void clear() {
fused=fbottom=0;	fsize=fbottom=0;
}	}

bool is_empty() {	bool is_empty() {
return fused==fbottom;	return fsize==fbottom;
}	}

	Table &table(Request &r, const String* problem_source) {
	return table(r, problem_source, bottom_index(), top_index());
	}
	Table &table(Request &r, const String* problem_source, size_t bottom, size_t top);
};	};

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

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

/// already used files to avoid cyclic uses	/// already used files to avoid cyclic uses
HashString<bool> used_files;	HashString<bool> used_files;
Line 124 private:	Line 149 private:
Array<String::Body> file_list;	Array<String::Body> file_list;

/// endless execute(execute(... preventing counter	/// endless execute(execute(... preventing counter
int anti_endless_execute_recoursion;	int anti_endless_execute_recursion;
	int execute_recursion_limit;
	void recursion_limit_reached();

///@}	///@}

/// execution stack	/// execution stack
Stack<StackItem> stack;	Stack<StackItem> stack;

	public:
/// exception stack trace	/// exception stack trace
Exception_trace exception_trace;	Exception_trace exception_trace;
public:

bool allow_class_replace;	bool allow_class_replace;

Line 142 public:	Line 169 public:
VMethodFrame* method_frame;	VMethodFrame* method_frame;
Value* rcontext;	Value* rcontext;
WContext* wcontext;	WContext* wcontext;
/// current language
String::Language flang;
/// current connection	/// current connection
SQL_Connection* fconnection;	SQL_Connection* fconnection;
//@}	//@}
Line 157 private:	Line 182 private:
public:	public:
uint register_file(String::Body file_spec);	uint register_file(String::Body file_spec);

struct Exception_details {	const char* get_exception_cstr(const Exception& e, VException& details);
const Operation::Origin origin;
const String* problem_source;
VHash& vhash;
Exception_details(const Operation::Origin aorigin, const String* aproblem_source, VHash& avhash): origin(aorigin), problem_source(aproblem_source), vhash(avhash) {}
};
Exception_details get_details(const Exception& e);
const char* get_exception_cstr(const Exception& e, Exception_details& details);

/// @see Stack::wipe_unused	/// @see Stack::wipe_unused
void wipe_unused_execution_stack() {	void wipe_unused_execution_stack() {
Line 183 public:	Line 201 public:
~Request();	~Request();

/// global classes	/// global classes
HashString<VStateless_class*>& classes() { return fclasses; }	OrderedHashString<VStateless_class*>& classes() { return fclasses; }
VStateless_class* get_class(const String& name);	VStateless_class* get_class(const String& name);
	VStateless_class& get_class_ref(const String& name);
void put_class(VStateless_class *aclass){ classes().put(aclass->type(), aclass); }	void put_class(VStateless_class *aclass){ classes().put(aclass->type(), aclass); }
	bool add_class(const char* atype, VStateless_class *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(const char* config_filespec, bool header_only);	void core(const char* config_filespec, const String& amain_method_name = main_method_name, const String* amain_class_name = NULL);

	/// ^response:stream[part]: the headers go with the first part
	void stream(Value& part);

	/// sends headers and sets response.started
	void start(VResponse::Started mode);

/// executes ops	/// executes ops
void execute(ArrayOperation& ops); // execute.C	void execute(ArrayOperation& ops); // execute.C
Line 224 public:	Line 250 public:

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

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

	/// take the recovery reserve back if recursion limit is far enough
	void recursion_limit_try_restore() {
	if(execute_recursion_limit>pa_execute_recursion_limit && anti_endless_execute_recursion<pa_execute_recursion_limit/2)
	execute_recursion_limit=pa_execute_recursion_limit;
}	}

///	///
Line 243 public:	Line 273 public:
/// for @USE only, calls ^use (which may be user-defined)	/// for @USE only, calls ^use (which may be user-defined)
void use_file(const String& file_name, const String* use_filespec, Operation::Origin origin);	void use_file(const String& file_name, const String* use_filespec, Operation::Origin origin);

/// compiles a @a source buffer	/// compiles a @a source buffer, recording it into @a code if given, or replays the cached @a code
void use_buf(VStateless_class& aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset=0);	void use_buf(VStateless_class& aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset=0, Code_cache* code=0);

/// processes any code-junction there may be inside of @a value	/// processes any code-junction there may be inside of @a value
Value& process_getter(Junction& junction); // execute.C	Value& process_getter(Junction& junction); // execute.C
Line 279 public:	Line 309 public:
/// 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);

/// returns an absolute @a path to relative @a name	/// '/'-normalized disk path of a file name; a uri of another scheme is returned as is if allowed, otherwise throws
const String& absolute(const String& relative_name);	const String& full_disk_path(const String& relative_name, uint allowed=0);
	/// '/'-normalized full_disk_path of a real file on disk, which does not throw: 0 for a uri or a remote, invalid or tainted file:// one
	const String* real_disk_path(const String& name);

/// returns the mime type of 'user_file_name'	/// returns the mime type of 'user_file_name'
const String& mime_type_of(const String* file_name);	const String& mime_type_of(const String* file_name);
Line 327 public:	Line 359 public:
VCookie& cookie;	VCookie& cookie;
/// $console	/// $console
VConsole& console;	VConsole& console;
	/// inited in httpd mode
	WebSocket* websocket;

/// classes configured data	/// classes configured data
HashString<void*> classes_conf;	HashString<void*> classes_conf;
Line 346 public: // status read methods	Line 380 public: // status read methods

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

//}	//}

Line 372 private:	Line 407 private:

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

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

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

Line 381 private: // execute.C	Line 416 private: // execute.C
Value& get_element4call(Value& ncontext, const String& name);	Value& get_element4call(Value& ncontext, const String& name);
#endif	#endif

private: // defaults

const String::Language fdefault_lang;

private: // mime types	private: // mime types

/// $MAIN:MIME-TYPES	/// $MAIN:MIME-TYPES
Line 406 private:	Line 437 private:
void output_result(VFile* body_file, bool header_only, bool as_attachment);	void output_result(VFile* body_file, bool header_only, bool as_attachment);
};	};

	/// Hash-compatible exception; hash is built on demand.
	class VException: public VHashReference {
	Exception fexception;
	String::Body ffile;
	Value* fhandled;
	size_t ftrace_bottom, ftrace_top;
	public:
	Operation::Origin origin;
	const String* problem_source;

	VException(Request& r, const Exception& e);

	override HashStringValue& hash();
	override Value* get_element(const String& name);
	override const VJunction* put_element(const String& name, Value* value);

	Value* handled();
	Table& stack(Request& r);
	void expire_trace() { ftrace_top=size_t(-1); }
	};

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

/// exception stack trace
size_t exception_trace_top;
size_t exception_trace_bottom;
/// execution stack	/// execution stack
size_t stack;	size_t stack;
uint anti_endless_execute_recoursion;	int anti_endless_execute_recursion;
/// contexts	/// contexts
VMethodFrame* method_frame;	VMethodFrame* method_frame;
Value* rcontext;	Value* rcontext;
WContext* wcontext;	WContext* wcontext;
/// current language
String::Language flang;
/// current connection	/// current connection
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_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_recursion(ar.anti_endless_execute_recursion),
method_frame(ar.method_frame),	method_frame(ar.method_frame),
rcontext(ar.rcontext),	rcontext(ar.rcontext),
wcontext(ar.wcontext),	wcontext(ar.wcontext),
flang(ar.flang),
fconnection(ar.fconnection) {}	fconnection(ar.fconnection) {}
void restore() {	void restore() {
fr.exception_trace.set_top_index(exception_trace_top);
fr.exception_trace.set_bottom_index(exception_trace_bottom);
fr.stack.set_top_index(stack);	fr.stack.set_top_index(stack);
fr.anti_endless_execute_recoursion=anti_endless_execute_recoursion;	fr.anti_endless_execute_recursion=anti_endless_execute_recursion;
fr.method_frame=method_frame, fr.rcontext=rcontext; fr.wcontext=wcontext;	fr.method_frame=method_frame, fr.rcontext=rcontext; fr.wcontext=wcontext;
fr.flang=flang;
fr.fconnection=fconnection;	fr.fconnection=fconnection;
}	}
};	};
Line 514 public:	Line 555 public:
~Temp_value_element();	~Temp_value_element();
};	};

// defines for externs	/// Auto-object that temporarily increases recursion
	class Temp_recursion {
#define EXCEPTION_HANDLED_PART_NAME "handled"	Request& frequest;
	public:
	Temp_recursion(Request& arequest) : frequest(arequest){
// externs	frequest.anti_endless_execute_recursion++;
	}
extern const String main_method_name;	~Temp_recursion(){
extern const String auto_method_name;	frequest.anti_endless_execute_recursion--;
	}
extern const String exception_type_part_name;	};
extern const String exception_source_part_name;
extern const String exception_comment_part_name;
extern const String exception_handled_part_name;

// defines for statics

#define MAIN_CLASS_NAME "MAIN"
#define AUTO_FILE_NAME "auto.p"

#endif	#endif

E-mail:

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