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.68 and 1.111

version 1.68, 2001/03/24 10:59:47	version 1.111, 2001/11/19 12:17:05
Line 2	Line 2
Parser: request class decl.	Parser: request class decl.

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

$Id$	$Id$
*/	*/
Line 11	Line 10
#ifndef PA_REQUEST_H	#ifndef PA_REQUEST_H
#define PA_REQUEST_H	#define PA_REQUEST_H

	#include "pa_config_includes.h"
#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 19	Line 19
#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_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"

#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
# define COMPILE_PARAMS \	# define COMPILE_PARAMS \
Line 42	Line 45
#endif	#endif

class Temp_lang;	class Temp_lang;
	class Methoded;

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

/// some information from web server	/// some information from web server
Line 59 public:	Line 63 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;
};	};

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() {}

Line 76 public:	Line 82 public:
BEWARE: may throw exception to you: catch it!	BEWARE: may throw exception to you: catch it!
*/	*/
void core(	void core(
const char *root_auto_path, ///< path to system auto.p file	const char *root_config_filespec, ///< system config filespec
bool root_auto_fail, ///< fail if system auto.p file not found	bool root_config_fail_on_read_problem, ///< fail if system config file not found
const char *site_auto_path, ///< path to site auto.p file	const char *site_config_filespec, ///< site config filespec
bool site_auto_fail, ///< fail if site auto.p file not found	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);	void execute(const Array& ops); // execute.C

/// 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(
const char *file, bool fail_on_read_problem=true,	const String& file_name,
	bool ignore_class_path=false, bool fail_on_read_problem=true,
const String *name=0,	const String *name=0,
VStateless_class *base_class=0); // core.C	VStateless_class *base_class=0); // core.C
/// compiles a @a source buffer	/// compiles a @a source buffer
Line 103 public:	Line 110 public:

/// 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_NO);	wcontext->write(astring,
	String::UL_CLEAN \| flang&String::UL_OPTIMIZE_BIT);
}	}
/// 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) {
Line 113 public:	Line 121 public:
void write_assign_lang(Value& avalue) {	void write_assign_lang(Value& avalue) {
wcontext->write(avalue, flang);	wcontext->write(avalue, flang);
}	}
	/// appending string, assigning untaint language
	void write_assign_lang(const String& astring) {
	wcontext->write(astring, 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	/// appending sure value, that would be converted to clean string
void write_no_lang(Value& avalue) {	void write_no_lang(Value& avalue) {
wcontext->write(avalue, String::UL_NO);	wcontext->write(avalue,
	String::UL_CLEAN \| flang&String::UL_OPTIMIZE_BIT);
}	}
/// appending sure value, not VString	/// appending sure value, not VString
void write_expr_result(Value& avalue) {	void write_expr_result(Value& avalue) {
wcontext->write(avalue);	wcontext->write(avalue);
}	}

/// handy is-value-a-junction ensurer
void fail_if_junction_(bool is, Value& value,
const String& method_name, const char *msg);

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

/// returns an absolute @a path to relative @a name	/// returns an absolute @a path to relative @a name
char absolute(const char name);	const String& absolute(const String& relative_name);

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

	/// PCRE character tables
	const unsigned char *pcre_tables();

public:	public:

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

/// default base	/// operators are methods of this class
VClass ROOT;	Methoded& OP;
/// $env:fields here	/// $env:fields
VEnv env;	VEnv env;
/// $form:elements here	/// $status:fields
	VStatus status;
	/// $form:elements
VForm form;	VForm form;
/// $request:elements here	/// $math:constants
	VMath math;
	/// $request:elements
VRequest request;	VRequest request;
/// $response:	/// $response:elements
VResponse response;	VResponse response;
/// $cookie:	/// $cookie:elements
VCookie cookie;	VCookie cookie;

/// contexts	/// contexts
Line 159 public:	Line 180 public:
/// contexts	/// contexts
WContext *wcontext;	WContext *wcontext;

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

	/// connection
	SQL_Connection *connection;

	/// classes configured data
	Hash classes_conf;

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

// classes	/// classes
Hash fclasses;	Hash fclasses;

// already used files to avoid cyclic uses	/// already used files to avoid cyclic uses
Hash used_files;	Hash used_files;

// execution stack	/// execution stack
Stack stack;	Stack stack;

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

	/// charset->pcre_tables
	Hash CTYPE;

	/// stack trace
	Stack trace;

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, const Method& method,	const String *execute_method(Value& aself,
bool return_cstr=true);	const Method& method, bool return_cstr=true);
const String *execute_method(Value& aself, const String& method_name,	const String *execute_virtual_method(Value& aself,
bool return_cstr=true);	const String& method_name, bool return_cstr=true);
	const String *execute_nonvirtual_method(VStateless_class& aclass,
	const String& method_name, bool return_cstr=true);

Value *get_element();	Value *get_element();

private: // lang&raw	private: // lang&raw

String::Untaint_lang flang;	uchar 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

	/// $MAIN:MIME-TYPES
	Table *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:	private:

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

/// 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 222 public:	Line 270 public:
}	}
};	};

	/**
	@b method parameters passed in this array.
	contains handy typecast ad junction/not junction ensurers

	*/
	class MethodParams : public Array {
	public:
	MethodParams(Pool& pool, const String& amethod_name) : Array(pool),
	fmethod_name(amethod_name) {
	}

	/// handy typecast. I long for templates
	Value& get(int index) {
	return static_cast<Value >(Array::get(index));
	}
	/// handy is-value-a-junction ensurer
	Value& as_junction(int index, const char *msg) {
	return get_as(index, true, msg);
	}
	/// handy value-is-not-a-junction ensurer
	Value& as_no_junction(int index, const char *msg) {
	return get_as(index, false, msg);
	}
	/// handy expression auto-processing to double
	double as_double(int index, const char *msg, Request& r) {
	return get_processed(index, msg, r).as_double();
	}
	/// handy expression auto-processing to int
	int as_int(int index, const char *msg, Request& r) {
	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
	const String& as_string(int index, const char *msg) {
	return as_no_junction(index, msg).as_string();
	}

	private:

	/// handy value-is/not-a-junction ensurer
	Value& get_as(int index, bool as_junction, const char *msg) {
	Value& result=get(index);
	if((result.get_junction()!=0) ^ as_junction)
	throw Exception(0, 0,
	&fmethod_name,
	"%s (parameter #%d)", msg, 1+index);

	return result;
	}

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

	private:

	const String& fmethod_name;

	};

#endif	#endif

E-mail:

Removed from v.1.68
changed lines
	Added in v.1.111