Return to pa_request.h CVS log

Up to [parser3project] / parser3 / src / include

mail compiled

/** @file
	Parser: request class decl.

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

#ifndef PA_REQUEST_H
#define PA_REQUEST_H

static const char* IDENT_REQUEST_H="$Date: 2003/02/06 16:05:23 $";

#include "pa_pool.h"
#include "pa_request_info.h"
#include "pa_hash.h"
#include "pa_wcontext.h"
#include "pa_value.h"
#include "pa_stack.h"
#include "pa_vclass.h"
#include "pa_vobject.h"
#include "pa_venv.h"
#include "pa_vstatus.h"
#include "pa_vform.h"
#include "pa_vmail.h"
#include "pa_vmath.h"
#include "pa_vrequest.h"
#include "pa_vresponse.h"
#include "pa_vcookie.h"
#include "pa_request_info.h"
#include "pa_request_charsets.h"
#include "pa_sapi.h"

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

// consts

const uint ANTI_ENDLESS_EXECUTE_RECOURSION=500;

// defines

#ifndef NO_STRING_ORIGIN
#	define COMPILE_PARAMS  \
		VStateless_class* aclass, const char* source \
		, const char* file
#	define COMPILE(aclass, source, file)  \
		real_compile(aclass, source, file)
#else
#	define COMPILE_PARAMS  \
		VStateless_class* aclass, const char* source
#	define COMPILE(aclass, source, file)  \
		real_compile(aclass, source)
#endif

// forwards

class Temp_lang;
class Methoded;
class VMethodFrame;

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

	/// all files and classes and other hard-to-place allocations go to this pool
	Pool fpool;

	///@{ core data

	/// classes
	HashStringValue fclasses;

	/// already used files to avoid cyclic uses
	Hash<StringPtr, bool> used_files;

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

	///@}

public:

	class StackItem {
	public:
		StringPtr string;
		ValuePtr value;
		ArrayOperationPtr ops;
		void *unknown;

		/// needed to fill unused Array entries
		StackItem() {}
		StackItem(StringPtr astring): string(astring) {}
		StackItem(ValuePtr avalue): value(avalue) {}		
		StackItem(ArrayOperationPtr aops): ops(aops) {}
		StackItem(void *aunknown): unknown(aunknown) {}
	};

	//@{ request processing status
	/// exception stack trace
	Stack<StringPtr> exception_trace;
	/// execution stack
	Stack<StackItem> stack;
	/// contexts
	VMethodFrame *method_frame;
	Value *rcontext;
	WContext *wcontext;
	/// current language
	uchar flang; 
	/// current connection
	SQL_Connection *fconnection;
	//@}
	/// interrupted flag, raised on signals [SIGPIPE]
	bool finterrupted;

public:

	/// all files and classes and other hard-to-place allocations go to this pool
	Pool& pool() { return fpool; }

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

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

	/// global classes
	HashStringValue& classes() { return fclasses; }

	/**
		core request processing

		BEWARE: may throw exception to you: catch it!
	*/
	void core(
		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
	void execute(ArrayOperation& ops); // execute.C
	/// execute ops with anti-recoursion check
	void recoursion_checked_execute(StringPtr name, ArrayOperation& 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.
	VStateless_classPtr use_file(VStateless_class& aclass,
		StringPtr file_name, 
		bool ignore_class_path=false, 
		bool fail_on_read_problem=true, bool fail_on_file_absence=true); // pa_request.C
	/// compiles a @a source buffer
	VStateless_classPtr use_buf(VStateless_class& aclass,
		const char* source, 
		StringPtr filespec, const char* filespec_cstr); // pa_request.C

	/// processes any code-junction there may be inside of @a value
	StringOrValue process(ValuePtr input_value, bool intercept_string=true); // execute.C
	//@{ convinient helpers
	StringPtr process_to_string(ValuePtr input_value) {
		return process(input_value, true/*intercept_string*/).as_string(&pool());
	}
	ValuePtr process_to_value(ValuePtr 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(StringPtr 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, StringPtr origin) { \
		if(StringPtr string=dual.get_string()) \
			write_##modification##_lang(*string); \
		else \
			write_##modification##_lang(dual.get_value(), origin); \
	}

	/// appending, sure of clean string inside
	void write_no_lang(const String& astring) {
		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(ValuePtr avalue) {
		if(wcontext->get_in_expression())
			wcontext->write(pool(), avalue);
		else
			wcontext->write(pool(), avalue, 
				String::UL_CLEAN | flang&String::UL_OPTIMIZE_BIT);
	}

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

	/// appending possible string, assigning untaint language
	void write_assign_lang(ValuePtr avalue) {
		wcontext->write(pool(), avalue, flang); 
	}
	/// appending possible string, assigning untaint language
	void write_assign_lang(ValuePtr avalue, StringPtr origin) {
		wcontext->write(pool(), avalue, flang, origin); 
	}
	/// appending string, assigning untaint language
	void write_assign_lang(const String& astring) {
		wcontext->write(astring, flang); 
	}
	DEFINE_DUAL(assign)
	DEFINE_DUAL_CHECKED(assign)

	/// returns relative to @a path  path to @a file 
	StringPtr relative(const char* apath, StringPtr relative_name);

	/// returns an absolute @a path to relative @a name
	StringPtr absolute(StringPtr relative_name);

	/// returns the mime type of 'user_file_name_cstr'
	StringPtr mime_type_of(const char* user_file_name_cstr);

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

		return fconnection; 
	}

	bool origins_mode();

	void interrupt() { finterrupted=true; }
	bool interrupted() { return finterrupted; }

public:
	
	/// info from web server
	Request_info& request_info;

	/// info about ServerAPI
	SAPI_Info& sapi_info;

	/// source, client, mail charsets
	Request_charsets charsets;

	/// 'MAIN' class conglomerat & operators are methods of this class
	VStateless_classPtr main_class;
	/// $env:fields
	//VEnv env;
	/// $status:fields
	//VStatus status;
	/// $form:elements
	VFormPtr form;
	/// $mail
	VMailPtr mail;
	/// $math:constants
	//VMath math;
	/// $request:elements
	//VRequest request;
	/// $response:elements
	VResponsePtr response;
	/// $cookie:elements
	VCookiePtr cookie;

	/// classes configured data
	HashStringValue classes_conf;

public: // status read methods

	VMethodFrame *get_method_frame() { return method_frame; }
	ValuePtr get_self();
#define GET_SELF(request, type) (*static_cast<type *>(request.get_self().get()))
	/* for strange reason call to this: 
		r.get_self<VHash>() 
		refuses to compile

	template<typename T> T& get_self() {
		return *static_cast<T*>(get_self().get());
	}
	*/



private:

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

	void configure_admin(VStateless_class& conf_class, StringPtr source);

private: // compile.C

	VStateless_class& real_compile(COMPILE_PARAMS);

private: // execute.C

	/// for @postprocess[body]
	StringPtr execute_method(VMethodFrame& amethodFrame, const Method& method);
	//{ for @conf[filespec] and @auto[filespec]
	StringPtr execute_method(ValuePtr aself, 
		const Method& method, VStringPtr optional_param,
		bool do_return_string);
	StringPtr execute_nonvirtual_method(VStateless_class& aclass, 
		StringPtr method_name, VStringPtr optional_param,
		bool do_return_string,
		const Method **return_method=0);
	//}
	/// for @main[]
	StringPtr execute_virtual_method(ValuePtr aself, StringPtr method_name);

	ValuePtr get_element(StringPtr& remember_name, bool can_call_operator);

private: // defaults

	const uchar fdefault_lang;
	Value *default_content_type;

private: // mime types

	/// $MAIN:MIME-TYPES
	Table *mime_types;

private: // lang manipulation

	uchar set_lang(uchar alang) {
		uchar result=flang;
		flang=alang;
		return result;
	}
	void restore_lang(uchar 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:

	void output_result(VFilePtr body_file, bool header_only, bool as_attachment);
};

/// 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
	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()),
		method_frame(ar.method_frame),
		rcontext(ar.rcontext),
		wcontext(ar.wcontext),
		flang(ar.flang),
		fconnection(ar.fconnection),
		fr(ar) {}
	void restore() {
		fr.exception_trace.top_index(exception_trace);
		fr.stack.top_index(stack);
		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.
class Temp_lang {
	Request& frequest;
	String_UL saved_lang;
public:
	Temp_lang(Request& arequest, String_UL alang) : 
		frequest(arequest),
		saved_lang(arequest.set_lang(alang)) {
	}
	~Temp_lang() { 
		frequest.restore_lang(saved_lang); 
	}
};

///	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); 
	}
};


// defines for externs

#define CONTENT_DISPOSITION_NAME "content-disposition"
#define CONTENT_DISPOSITION_VALUE "attachment"
#define CONTENT_DISPOSITION_FILENAME_NAME "filename"

// externs

extern StringPtr main_method_name;
extern StringPtr body_name;
extern StringPtr content_disposition_name;
extern StringPtr content_disposition_value;
extern StringPtr content_disposition_filename_name;

// defines for statics

#define MAIN_CLASS_NAME "MAIN"

#endif