parser3/src/classes/file.C - diff

Return to file.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/file.C between versions 1.211 and 1.254

version 1.211, 2010/09/08 02:57:10	version 1.254, 2016/10/26 15:44:49
Line 1	Line 1
/** @file	/** @file
Parser: @b file parser class.	Parser: @b file parser class.

Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2015 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)
*/	*/

static const char * const IDENT_FILE_C="$Date$";

#include "pa_config_includes.h"	#include "pa_config_includes.h"

#include "classes.h"	#include "classes.h"
Line 27 static const char * const IDENT_FILE_C="	Line 25 static const char * const IDENT_FILE_C="
#include "pa_vregex.h"	#include "pa_vregex.h"
#include "pa_version.h"	#include "pa_version.h"

	volatile const char * IDENT_FILE_C="$Id$";

// defines	// defines

#define STDIN_EXEC_PARAM_NAME "stdin"	#define STDIN_EXEC_PARAM_NAME "stdin"
#define CHARSET_EXEC_PARAM_NAME "charset"	#define CHARSET_EXEC_PARAM_NAME "charset"

#define NAME_NAME "name"	#define NAME_NAME "name"
	#define KEEP_EMPTY_DIRS_NAME "keep-empty-dirs"
	#define SUPPRESS_EXCEPTION_NAME "exception"

// externs	// externs

extern String sql_limit_name;	extern String sql_limit_name;
extern String sql_offset_name;	extern String sql_offset_name;

	// helpers

	class File_list_table_template_columns: public ArrayString {
	public:
	File_list_table_template_columns() {
	*this+=new String("name");
	*this+=new String("dir");
	*this+=new String("size");
	*this+=new String("cdate");
	*this+=new String("mdate");
	*this+=new String("adate");
	}
	};

	Table file_list_table_template(new File_list_table_template_columns);

// class	// class

class MFile: public Methoded {	class MFile: public Methoded {
public: // VStateless_class	public: // VStateless_class

Value* create_new_value(Pool&) { return new VFile(); }	Value* create_new_value(Pool&) { return new VFile(); }

public: // Methoded
bool used_directly() { return true; }

public:	public:
MFile();	MFile();

};	};

// global variable	// global variable

DECLARE_CLASS_VAR(file, new MFile, 0);	DECLARE_CLASS_VAR(file, new MFile);

// consts	// consts

Line 112 static const String::Body cdate_name("cd	Line 124 static const String::Body cdate_name("cd

// methods	// methods

static bool is_valid_mode (const String& mode) {
return (mode==text_mode_name \|\| mode==binary_mode_name);
}

bool is_text_mode(const String& mode) {
if(mode==text_mode_name)
return true;
if(mode==binary_mode_name)
return false;
throw Exception(PARSER_RUNTIME,
&mode,
"is invalid mode, must be either '"TEXT_MODE_NAME"' or '"BINARY_MODE_NAME"'");
}

static void _save(Request& r, MethodParams& params) {	static void _save(Request& r, MethodParams& params) {
bool is_text=is_text_mode(params.as_no_junction(0, MODE_MUST_NOT_BE_CODE).as_string());	bool is_text=VFile::is_text_mode(params.as_string(0, MODE_MUST_NOT_BE_CODE));
Value& vfile_name=params.as_no_junction(1, FILE_NAME_MUST_NOT_BE_CODE);	Value& vfile_name=params.as_no_junction(1, FILE_NAME_MUST_NOT_BE_CODE);

Charset* asked_charset=0;	Charset* asked_charset=0;
if(params.count()>2)	if(params.count()>2)
if(HashStringValue* options=params.as_no_junction(2, OPTIONS_MUST_NOT_BE_CODE).get_hash()){	if(HashStringValue* options=params.as_hash(2)){
int valid_options=0;	int valid_options=0;
if(Value* vcharset_name=options->get(PA_CHARSET_NAME)){	if(Value* vcharset_name=options->get(PA_CHARSET_NAME)){
asked_charset=&::charsets.get(vcharset_name->as_string().change_case(r.charsets.source(), String::CC_UPPER));	asked_charset=&pa_charsets.get(vcharset_name->as_string());
valid_options++;	valid_options++;
}	}
if(valid_options != options->count())	if(valid_options != options->count())
Line 147 static void _save(Request& r, MethodPara	Line 145 static void _save(Request& r, MethodPara
}	}

static void _delete(Request& r, MethodParams& params) {	static void _delete(Request& r, MethodParams& params) {
Value& vfile_name=params.as_no_junction(0, FILE_NAME_MUST_NOT_BE_CODE);	const String& file_name=params.as_string(0, FILE_NAME_MUST_NOT_BE_CODE);
	bool keep_empty_dirs=false;
	bool fail_on_problem=true;

	if(params.count()>1)
	if(HashStringValue* options=params.as_hash(1)){
	int valid_options=0;
	if(Value* vkeep_empty_dirs=options->get(KEEP_EMPTY_DIRS_NAME)){
	keep_empty_dirs=r.process(*vkeep_empty_dirs).as_bool();
	valid_options++;
	}
	if(Value* vsuppress_exception=options->get(SUPPRESS_EXCEPTION_NAME)){
	fail_on_problem=r.process(*vsuppress_exception).as_bool();
	valid_options++;
	}
	if(valid_options != options->count())
	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
	}

// unlink	// unlink
file_delete(r.absolute(vfile_name.as_string()));	file_delete(r.absolute(file_name), fail_on_problem, keep_empty_dirs);
}	}

static void _move(Request& r, MethodParams& params) {	static void _move(Request& r, MethodParams& params) {
Value& vfrom_file_name=params.as_no_junction(0, "from file name must not be code");	Value& vfrom_file_name=params.as_no_junction(0, "from file name must not be code");
Value& vto_file_name=params.as_no_junction(1, "to file name must not be code");	Value& vto_file_name=params.as_no_junction(1, "to file name must not be code");
	bool keep_empty_dirs=false;

	if(params.count()>2)
	if(HashStringValue* options=params.as_hash(2)){
	int valid_options=0;
	if(Value* vkeep_empty_dirs=options->get(KEEP_EMPTY_DIRS_NAME)){
	keep_empty_dirs=r.process(*vkeep_empty_dirs).as_bool();
	valid_options++;
	}
	if(valid_options != options->count())
	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
	}

// move	// move
file_move(	file_move(
r.absolute(vfrom_file_name.as_string()),	r.absolute(vfrom_file_name.as_string()),
r.absolute(vto_file_name.as_string()));	r.absolute(vto_file_name.as_string()),
	keep_empty_dirs);
}	}

static void copy_process_source(	static void copy_process_source(struct stat& , int from_file, const String&, void *context) {
struct stat& ,
int from_file,
const String& , const char* /fname/, bool,
void *context) {
int& to_file=static_cast<int >(context);	int& to_file=static_cast<int >(context);

int nCount=0;	int nCount=0;
Line 186 static void copy_process_source(	Line 210 static void copy_process_source(
static void copy_open_target(int f, void *from_spec) {	static void copy_open_target(int f, void *from_spec) {
String& file_spec=static_cast<String >(from_spec);	String& file_spec=static_cast<String >(from_spec);
file_read_action_under_lock(file_spec, "copy", copy_process_source, &f);	file_read_action_under_lock(file_spec, "copy", copy_process_source, &f);
};	}

static void _copy(Request& r, MethodParams& params) {	static void _copy(Request& r, MethodParams& params) {
Value& vfrom_file_name=params.as_no_junction(0, "from file name must not be code");	Value& vfrom_file_name=params.as_no_junction(0, "from file name must not be code");
Line 210 static void _load_pass_param(	Line 234 static void _load_pass_param(
}	}

static void _load(Request& r, MethodParams& params) {	static void _load(Request& r, MethodParams& params) {
bool as_text=is_text_mode(params.as_no_junction(0, MODE_MUST_NOT_BE_CODE).as_string());	bool as_text=VFile::is_text_mode(params.as_string(0, MODE_MUST_NOT_BE_CODE));
const String& lfile_name=r.absolute(params.as_no_junction(1, FILE_NAME_MUST_NOT_BE_CODE).as_string());	const String& lfile_name=r.absolute(params.as_string(1, FILE_NAME_MUST_NOT_BE_CODE));

size_t param_index=params.count()-1;	size_t param_index=params.count()-1;
Value* param_value=param_index>1?&params.as_no_junction(param_index, "filename or options must not be code"):0;	Value* param_value=param_index>1?&params.as_no_junction(param_index, "file name or options must not be code"):0;

HashStringValue* options=0;	HashStringValue* options=0;
const char *user_file_name=0;	const String* user_file_name=0;

if(param_value){	if(param_value){
options=param_value->get_hash();	options=param_value->get_hash();
Line 226 static void _load(Request& r, MethodPara	Line 250 static void _load(Request& r, MethodPara
if(param_index>1){	if(param_index>1){
const String& luser_file_name=params.as_string(param_index, FILE_NAME_MUST_BE_STRING);	const String& luser_file_name=params.as_string(param_index, FILE_NAME_MUST_BE_STRING);
if(!luser_file_name.is_empty())	if(!luser_file_name.is_empty())
user_file_name=luser_file_name.taint_cstr(String::L_FILE_SPEC);	user_file_name=&luser_file_name;
}	}
}	}
if(!user_file_name)	if(!user_file_name)
user_file_name=lfile_name.taint_cstr(String::L_FILE_SPEC);	user_file_name=&lfile_name;

size_t offset=0;	size_t offset=0;
size_t limit=0;	size_t limit=0;
Line 238 static void _load(Request& r, MethodPara	Line 262 static void _load(Request& r, MethodPara
if(options){	if(options){
options=new HashStringValue(*options);	options=new HashStringValue(*options);
if(Value voffset=(Value )options->get(sql_offset_name)){	if(Value voffset=(Value )options->get(sql_offset_name)){
offset=r.process_to_value(*voffset).as_int();	offset=r.process(*voffset).as_int();
}	}
if(Value vlimit=(Value )options->get(sql_limit_name)){	if(Value vlimit=(Value )options->get(sql_limit_name)){
limit=r.process_to_value(*vlimit).as_int();	limit=r.process(*vlimit).as_int();
}	}
// no check on options count here, see file_read	// no check on options count here, see file_read
}	}
Line 254 static void _load(Request& r, MethodPara	Line 278 static void _load(Request& r, MethodPara
if(Value* remote_content_type=file.headers->get(HTTP_CONTENT_TYPE_UPPER))	if(Value* remote_content_type=file.headers->get(HTTP_CONTENT_TYPE_UPPER))
vcontent_type=new VString(*new String(remote_content_type->as_string().cstr()));	vcontent_type=new VString(*new String(remote_content_type->as_string().cstr()));
}	}
if(!vcontent_type)
vcontent_type=new VString(r.mime_type_of(user_file_name));

VFile& self=GET_SELF(r, VFile);
self.set(true/tainted/, file.str, file.length, user_file_name, vcontent_type);

self.set_mode(as_text);	VFile& self=GET_SELF(r, VFile);
	self.set(true/tainted/, as_text, file.str, file.length, user_file_name, vcontent_type, &r);

if(file.headers){	if(file.headers){
file.headers->for_each<HashStringValue*>(_load_pass_param, &self.fields());	file.headers->for_each<HashStringValue*>(_load_pass_param, &self.fields());
Line 271 static void _load(Request& r, MethodPara	Line 291 static void _load(Request& r, MethodPara
file_stat(lfile_name, size, atime, mtime, ctime);	file_stat(lfile_name, size, atime, mtime, ctime);

HashStringValue& ff=self.fields();	HashStringValue& ff=self.fields();
ff.put(adate_name, new VDate(atime));	ff.put(adate_name, new VDate((pa_time_t)atime));
ff.put(mdate_name, new VDate(mtime));	ff.put(mdate_name, new VDate((pa_time_t)mtime));
ff.put(cdate_name, new VDate(ctime));	ff.put(cdate_name, new VDate((pa_time_t)ctime));
}	}
}	}

static void _create(Request& r, MethodParams& params) {	static void _create(Request& r, MethodParams& params) {
const String& mode_name=params.as_no_junction(0, MODE_MUST_NOT_BE_CODE).as_string();	const String* mode=0;
if(!is_text_mode(mode_name))	const String* file_name=0;
throw Exception(PARSER_RUNTIME,	bool is_text=true;
0,
"only text mode is currently supported");	// new format: ^file::create[string-or-file-content[;$.mode[text\|binary] $.name[...] $.content-type[...] $.charset[...] ]]
	size_t content_index=0;
const char* user_file_name_cstr=r.absolute(	size_t options_index=1;
params.as_no_junction(1, FILE_NAME_MUST_NOT_BE_CODE).as_string()).taint_cstr(String::L_FILE_SPEC);	bool extended_options=true;

const String& content=params.as_string(2, "content must be string");	if(params.count()>=3){
String::Body content_body=content.cstr_to_string_body_untaint(String::L_AS_IS); // explode content, honor tainting changes	// old format: ^file::create[text\|binary;file-name;string-or-file-content[;options]]
	mode=&params.as_string(0, MODE_MUST_NOT_BE_CODE);
	is_text=VFile::is_text_mode(*mode);
	file_name=&params.as_string(1, FILE_NAME_MUST_NOT_BE_CODE);
	content_index=2;
	options_index=3;
	extended_options=false;
	}

VString* vcontent_type=0;	VString* vcontent_type=0;
if(params.count()>3)	Charset* to_charset=0;
if(HashStringValue* options=params.as_hash(3)){	Charset* from_charset=0;
Charset* asked_charset=0;	if(params.count()>options_index)
	if(HashStringValue* options=params.as_hash(options_index)) {
int valid_options=0;	int valid_options=0;
if(Value* vcharset_name=options->get(PA_CHARSET_NAME)){	if(extended_options) {
asked_charset=&::charsets.get(vcharset_name->as_string().change_case(r.charsets.source(), String::CC_UPPER));	if(Value* vmode=options->get(MODE_NAME)) {
	mode=&vmode->as_string();
	is_text=VFile::is_text_mode(*mode);
	valid_options++;
	}
	if(Value* vfile_name=options->get(NAME_NAME)) {
	file_name=&vfile_name->as_string();
	valid_options++;
	}
	}
	if(Value* vcharset_name=options->get("to-charset")) {
	to_charset=&pa_charsets.get(vcharset_name->as_string());
	valid_options++;
	}
	if(Value* vcharset_name=options->get("from-charset")) {
	from_charset=&pa_charsets.get(vcharset_name->as_string());
	valid_options++;
	}
	if(Value* vcharset_name=options->get(PA_CHARSET_NAME)) {
	if(to_charset)
	throw Exception(PARSER_RUNTIME, 0, "charset option can not be used with to-charset");
	to_charset=&pa_charsets.get(vcharset_name->as_string());
valid_options++;	valid_options++;
}	}
if(Value* value=options->get(CONTENT_TYPE_NAME)) {	if(Value* value=options->get(CONTENT_TYPE_NAME)) {
Line 306 static void _create(Request& r, MethodPa	Line 354 static void _create(Request& r, MethodPa
}	}
if(valid_options != options->count())	if(valid_options != options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);

if(asked_charset)
content_body=Charset::transcode(content_body, r.charsets.source(), *asked_charset);
}	}

if(!vcontent_type)	Value& vcontent=params.as_no_junction(content_index, "content must be string or file");
vcontent_type=new VString(r.mime_type_of(user_file_name_cstr));

VFile& self=GET_SELF(r, VFile);	VFile& self=GET_SELF(r, VFile);
self.set(true/tainted/, content_body.cstr(), content_body.length(), user_file_name_cstr, vcontent_type);

self.set_mode(true/as_text/);	if(const String* content_str=vcontent.get_string()){
	String::Body body=content_str->cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets); // explode content, honor tainting changes
	self.set(true/tainted/, is_text, body.cstrm(), body.length(), file_name, vcontent_type, &r);
	} else {
	VFile& fcontent=*vcontent.as_vfile(String::L_AS_IS); // can't be null
	if(mode){
	self.set(fcontent, &is_text, file_name, vcontent_type, &r);
	if(is_text && !fcontent.is_text_mode())
	from_charset=self.detect_binary_charset(from_charset);
	} else {
	self.set(fcontent, 0, file_name, vcontent_type, &r);
	is_text=fcontent.is_text_mode();
	}
	}

	if(to_charset \|\| from_charset)
	if(is_text)
	self.transcode(from_charset ? from_charset : r.charsets.source(), to_charset ? to_charset : r.charsets.source());
	else
	throw Exception(PARSER_RUNTIME, 0, "charset options can not be used with binary content");
}	}

static void _stat(Request& r, MethodParams& params) {	static void _stat(Request& r, MethodParams& params) {
Value& vfile_name=params.as_no_junction(0, FILE_NAME_MUST_NOT_BE_CODE);	const String& lfile_name=params.as_string(0, FILE_NAME_MUST_NOT_BE_CODE);

const String& lfile_name=vfile_name.as_string();

size_t size;	size_t size;
time_t atime, mtime, ctime;	time_t atime, mtime, ctime;
file_stat(r.absolute(lfile_name),	file_stat(r.absolute(lfile_name), size, atime, mtime, ctime);
size,
atime, mtime, ctime);

const char* user_file_name=lfile_name.taint_cstr(String::L_FILE_SPEC);

VFile& self=GET_SELF(r, VFile);	VFile& self=GET_SELF(r, VFile);

self.set(true/tainted/, 0/no bytes/, size, user_file_name, new VString(r.mime_type_of(user_file_name)));	self.set_binary(true/tainted/, 0/no bytes/, size, &lfile_name, 0, &r);
HashStringValue& ff=self.fields();	HashStringValue& ff=self.fields();
ff.put(adate_name, new VDate(atime));	ff.put(adate_name, new VDate((pa_time_t)atime));
ff.put(mdate_name, new VDate(mtime));	ff.put(mdate_name, new VDate((pa_time_t)mtime));
ff.put(cdate_name, new VDate(ctime));	ff.put(cdate_name, new VDate((pa_time_t)ctime));
}	}

static bool is_safe_env_key(const char* key) {	static bool is_safe_env_key(const char* key) {
for(const char* validator=key; *validator; validator++) {	for(const char* validator=key; *validator; validator++) {
char c=*validator;	char c=*validator;
if(!(c>='A' && c<='Z' \|\| c>='0' && c<='9' \|\| c=='_' \|\| c=='-'))	if(!( (c>='A' && c<='Z') \|\| (c>='0' && c<='9') \|\| (c=='_' \|\| c=='-') ))
return false;	return false;
}	}
#ifdef PA_SAFE_MODE	#ifdef PA_SAFE_MODE
Line 408 static void pass_cgi_header_attribute(	Line 464 static void pass_cgi_header_attribute(

static void append_to_argv(Request& r, ArrayString& argv, const String* str){	static void append_to_argv(Request& r, ArrayString& argv, const String* str){
if(!str->is_empty())	if(!str->is_empty())
argv+=new String(str->cstr_to_string_body_untaint(String::L_AS_IS, 0, &r.charsets), String::L_AS_IS);	argv+=new String(str->cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets), String::L_AS_IS);
}	}

/// @todo fix `` in perl - they produced flipping consoles and no output to perl	/// @todo fix `` in perl - they produced flipping consoles and no output to perl
static void _exec_cgi(Request& r, MethodParams& params, bool cgi) {	static void _exec_cgi(Request& r, MethodParams& params, bool cgi) {
bool as_text=true;	bool is_text=true;
size_t param_index=0;	size_t param_index=0;
const String& mode_name=params.as_no_junction(0, FIRST_ARG_MUST_NOT_BE_CODE).as_string();	const String& mode=params.as_string(0, FIRST_ARG_MUST_NOT_BE_CODE);
if(is_valid_mode(mode_name)){	if(VFile::is_valid_mode(mode)) {
as_text=is_text_mode(mode_name);	is_text=VFile::is_text_mode(mode);
param_index++;	param_index++;
}	}

if(param_index>=params.count())	if(param_index>=params.count())
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, FILE_NAME_MUST_BE_SPECIFIED);
0,
"file name must be specified");


Value& vfile_name=params.as_no_junction(param_index++, FILE_NAME_MUST_NOT_BE_CODE);	const String& script_name=r.absolute(params.as_string(param_index++, FILE_NAME_MUST_NOT_BE_CODE));

const String& script_name=r.absolute(vfile_name.as_string());

HashStringString env;	HashStringString env;
#define ECSTR(name, value_cstr) \	#define ECSTR(name, value_cstr) if(value_cstr) env.put(#name, value_cstr);
if(value_cstr) \	// passing environment
env.put( \	for(SAPI::Env::Iterator i(r.sapi_info); i; i.next() )
String::Body(#name), \	env.put(i.key(), i.value() );
String::Body(*value_cstr?value_cstr:0)); \
// passing SAPI::environment
if(const char const pairs=SAPI::environment(r.sapi_info)) {
while(const char* pair=*pairs++)
if(const char* eq_at=strchr(pair, '='))
if(eq_at[1]) // has value
env.put(
pa_strdup(pair, eq_at-pair),
pa_strdup(eq_at+1, 0));
}

// const	// const
ECSTR(GATEWAY_INTERFACE, "CGI/1.1");	ECSTR(GATEWAY_INTERFACE, "CGI/1.1");
ECSTR(PARSER_VARSION, PARSER_VERSION);	ECSTR(PARSER_VERSION, PARSER_VERSION);
// from Request.info	// from Request.info
ECSTR(DOCUMENT_ROOT, r.request_info.document_root);	ECSTR(DOCUMENT_ROOT, r.request_info.document_root);
ECSTR(PATH_TRANSLATED, r.request_info.path_translated);	ECSTR(PATH_TRANSLATED, r.request_info.path_translated);
Line 459 static void _exec_cgi(Request& r, Method	Line 500 static void _exec_cgi(Request& r, Method
ECSTR(CONTENT_TYPE, r.request_info.content_type);	ECSTR(CONTENT_TYPE, r.request_info.content_type);
ECSTR(CONTENT_LENGTH, format(r.request_info.content_length, "%u"));	ECSTR(CONTENT_LENGTH, format(r.request_info.content_length, "%u"));
// SCRIPT_*	// SCRIPT_*
env.put(String::Body("SCRIPT_NAME"), script_name);	env.put("SCRIPT_NAME", script_name);
//env.put(String::Body("SCRIPT_FILENAME"), ??&script_name);

bool stdin_specified=false;
// environment & stdin from param	// environment & stdin from param
String *in=new String();	String *in=new String();
Charset *charset=0; // default script works raw_in 'source' charset = no transcoding needed	Charset *charset=0; // default script works raw_in 'source' charset = no transcoding needed
if(param_index < params.count()) {	if(param_index < params.count()) {
Value& venv=params.as_no_junction(param_index++, "env must not be code");	if(HashStringValue* user_env=params.as_hash(param_index++, "env")) {
if(HashStringValue* user_env=venv.get_hash()) {
// $.charset [previewing to handle URI pieces]	// $.charset [previewing to handle URI pieces]
if(Value* vcharset=user_env->get(CHARSET_EXEC_PARAM_NAME))	if(Value* vcharset=user_env->get(CHARSET_EXEC_PARAM_NAME))
charset=&charsets.get(vcharset->as_string()	charset=&pa_charsets.get(vcharset->as_string());
.change_case(r.charsets.source(), String::CC_UPPER));

// $.others	// $.others
Append_env_pair_info info={&r.charsets, &env, 0};	Append_env_pair_info info={&r.charsets, &env, 0};
Line 484 static void _exec_cgi(Request& r, Method	Line 521 static void _exec_cgi(Request& r, Method
}	}
// $.stdin	// $.stdin
if(info.vstdin) {	if(info.vstdin) {
stdin_specified=true;
if(const String* sstdin=info.vstdin->get_string()) {	if(const String* sstdin=info.vstdin->get_string()) {
in->append(*sstdin, String::L_CLEAN, true);	// untaint stdin
	in = new String(sstdin->cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets), String::L_AS_IS);
} else	} else
if(VFile* vfile=static_cast<VFile *>(info.vstdin->as("file")))	if(VFile* vfile=static_cast<VFile *>(info.vstdin->as("file")))
in->append_know_length((const char* )vfile->value_ptr(), vfile->value_size(), String::L_TAINTED);	in->append_know_length((const char* )vfile->value_ptr(), vfile->value_size(), String::L_TAINTED);
Line 512 static void _exec_cgi(Request& r, Method	Line 549 static void _exec_cgi(Request& r, Method
} else {	} else {
Table* table=param.get_table();	Table* table=param.get_table();
if(table){	if(table){
for(size_t i=0; i<table->count(); i++) {	for(size_t j=0; j<table->count(); j++)
append_to_argv(r, argv, table->get(i)->get(0));	append_to_argv(r, argv, table->get(j)->get(0));
}
} else {	} else {
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "param must be string or table");
0,
"param must be string or table");
}	}
}	}
}	}
Line 545 static void _exec_cgi(Request& r, Method	Line 579 static void _exec_cgi(Request& r, Method
if(charset)	if(charset)
real_err=&Charset::transcode(real_err, charset, r.charsets.source());	real_err=&Charset::transcode(real_err, charset, r.charsets.source());

if(file_out->length && as_text){	if(file_out->length && is_text){
fix_line_breaks(file_out->str, file_out->length);	fix_line_breaks(file_out->str, file_out->length);
// treat output as string	// treat output as string
String *real_out = new String(file_out->str);	String *real_out = new String(file_out->str);
Line 610 static void _exec_cgi(Request& r, Method	Line 644 static void _exec_cgi(Request& r, Method
file_out->length -= headersize;	file_out->length -= headersize;

// $body	// $body
self.set(false/not tainted/, file_out->str, file_out->length);	self.set(false/not tainted/, is_text, file_out->str, file_out->length);

// $fields << header	// $fields << header
if(header) {	if(header) {
ArrayString rows;	ArrayString rows;
size_t pos_after=0;	header->split(rows, 0, eol_marker);
header->split(rows, pos_after, eol_marker);
Pass_cgi_header_attribute_info info={0, 0, 0};	Pass_cgi_header_attribute_info info={0, 0, 0};
info.charset=&r.charsets.source();	info.charset=&r.charsets.source();
info.fields=&self.fields();	info.fields=&self.fields();
Line 626 static void _exec_cgi(Request& r, Method	Line 659 static void _exec_cgi(Request& r, Method
}	}
} else { // ^file::exec	} else { // ^file::exec
// $body	// $body
self.set(false/not tainted/, file_out->str, file_out->length);	self.set(false/not tainted/, is_text, file_out->str, file_out->length);
}	}

self.set_mode(as_text);

// $status	// $status
self.fields().put(file_status_name, new VInt(execution.status));	self.fields().put(file_status_name, new VInt(execution.status));

// $stderr	// $stderr
if(!real_err->is_empty())	if(!real_err->is_empty())
self.fields().put(	self.fields().put("stderr", new VString(*real_err));
String::Body("stderr"),
new VString(*real_err));
}	}
static void _exec(Request& r, MethodParams& params) {	static void _exec(Request& r, MethodParams& params) {
_exec_cgi(r, params, false);	_exec_cgi(r, params, false);
Line 650 static void _cgi(Request& r, MethodParam	Line 679 static void _cgi(Request& r, MethodParam
static void _list(Request& r, MethodParams& params) {	static void _list(Request& r, MethodParams& params) {
Value& relative_path=params.as_no_junction(0, "path must not be code");	Value& relative_path=params.as_no_junction(0, "path must not be code");

	bool stat=false;
VRegex* vregex=0;	VRegex* vregex=0;
VRegexCleaner vrcleaner;	VRegexCleaner vrcleaner;

if(params.count()>1){	if(params.count()>1){
Value& regexp=params.as_no_junction(1, "regexp must not be code");	Value& voption=params.as_no_junction(1, "option must not be code");
if(regexp.is_defined()){	if(voption.is_defined()) {
if(Value* value=regexp.as(VREGEX_TYPE)){	Value* vfilter=0;
vregex=static_cast<VRegex*>(value);	if(HashStringValue* options=voption.get_hash()) {
	int valid_options=0;
	if(Value* vstat=options->get("stat")) {
	stat=r.process(*vstat).as_bool();
	valid_options++;
	}
	if(Value* value=options->get("filter")) {
	vfilter=value;
	valid_options++;
	}
	if(valid_options!=options->count())
	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
} else {	} else {
vregex=new VRegex(r.charsets.source(), &regexp.as_string(), 0/options/);	vfilter=&voption;
vregex->study();	}
vrcleaner.vregex=vregex;	if(vfilter) {
	if(Value* value=vfilter->as(VREGEX_TYPE)) {
	vregex=static_cast<VRegex*>(value);
	} else if(vfilter->is_string()) {
	if(!vfilter->get_string()->trim().is_empty()) {
	vregex=new VRegex(r.charsets.source(), &vfilter->as_string(), 0/options/);
	vregex->study();
	vrcleaner.vregex=vregex;
	}
	} else {
	throw Exception(PARSER_RUNTIME, 0, "filter must be regex or string");
	}
}	}
}	}
}	}

const char* absolute_path_cstr=r.absolute(relative_path.as_string()).taint_cstr(String::L_FILE_SPEC);	const char* absolute_path_cstr=r.absolute(relative_path.as_string()).taint_cstr(String::L_FILE_SPEC);

Table::columns_type columns(new ArrayString);	Table::Action_options table_options;
*columns+=new String("name");	Table& table=*new Table(file_list_table_template, table_options);
Table& table=*new Table(columns);

const int ovector_size=(1/match/)*3;	const int ovector_size=(1/match/)*3;
int ovector[ovector_size];	int ovector[ovector_size];
Line 681 static void _list(Request& r, MethodPara	Line 733 static void _list(Request& r, MethodPara
if(!vregex \|\| vregex->exec(ffblk.ff_name, file_name_size, ovector, ovector_size)>=0) {	if(!vregex \|\| vregex->exec(ffblk.ff_name, file_name_size, ovector, ovector_size)>=0) {
Table::element_type row(new ArrayString);	Table::element_type row(new ArrayString);
*row+=new String(pa_strdup(file_name_cstr, file_name_size), String::L_TAINTED);	*row+=new String(pa_strdup(file_name_cstr, file_name_size), String::L_TAINTED);
	*row+=new String(String::Body::Format(ffblk.is_dir(stat) ? 1 : 0), String::L_CLEAN);
	if(stat) {
	*row+=VDouble(ffblk.size()).get_string();
	*row+=new String(String::Body::Format((int)ffblk.c_timestamp()), String::L_CLEAN);
	*row+=new String(String::Body::Format((int)ffblk.m_timestamp()), String::L_CLEAN);
	*row+=new String(String::Body::Format((int)ffblk.a_timestamp()), String::L_CLEAN);
	}
table+=row;	table+=row;
}	}
);	);
Line 695 struct Lock_execute_body_info {	Line 754 struct Lock_execute_body_info {
Value* body_code;	Value* body_code;
};	};
#endif	#endif

static void lock_execute_body(int , void *ainfo) {	static void lock_execute_body(int , void *ainfo) {
Lock_execute_body_info& info=static_cast<Lock_execute_body_info >(ainfo);	Lock_execute_body_info& info=static_cast<Lock_execute_body_info >(ainfo);
// execute body	// execute body
info.r->write_assign_lang(info.r->process(*info.body_code));	info.r->write_pass_lang(info.r->process(*info.body_code));
};	}

static void _lock(Request& r, MethodParams& params) {	static void _lock(Request& r, MethodParams& params) {
const String& file_spec=r.absolute(params.as_string(0, FILE_NAME_MUST_BE_STRING));	const String& file_spec=r.absolute(params.as_string(0, FILE_NAME_MUST_BE_STRING));
Lock_execute_body_info info={	Lock_execute_body_info info={
Line 714 static void _lock(Request& r, MethodPara	Line 775 static void _lock(Request& r, MethodPara
&info);	&info);
}	}

	static size_t afterlastslash(const String& str) {
	size_t pos=str.strrpbrk("/\\");
	return pos!=STRING_NOT_FOUND?pos+1:0;
	}

	static size_t afterlastslash(const String& str, size_t right) {
	size_t pos=str.strrpbrk("/\\", 0, right);
	return pos!=STRING_NOT_FOUND?pos+1:0;
	}

static void _find(Request& r, MethodParams& params) {	static void _find(Request& r, MethodParams& params) {
const String& file_name=params.as_no_junction(0, FILE_NAME_MUST_NOT_BE_CODE).as_string();	const String& file_name=params.as_string(0, FILE_NAME_MUST_NOT_BE_CODE);

	Value* not_found_code=(params.count()==2)?&params.as_junction(1, "not-found param must be code"):0;

const String* file_spec;	const String* file_spec;
if(file_name.first_char()=='/')	if(file_name.first_char()=='/')
file_spec=&file_name;	file_spec=&file_name;
Line 724 static void _find(Request& r, MethodPara	Line 798 static void _find(Request& r, MethodPara

// easy way	// easy way
if(file_exist(r.absolute(*file_spec))) {	if(file_exist(r.absolute(*file_spec))) {
r.write_assign_lang(*file_spec);	r.write_pass_lang(*file_spec);
return;	return;
}	}

// monkey way	// monkey way
int after_base_slash=lastposafter(*file_spec, 0, "/", 1);	size_t last_slash=file_spec->strrpbrk("/\\");
const String* dirname=&file_spec->mid(0, after_base_slash);	const String& dirname=file_spec->mid(0, last_slash!=STRING_NOT_FOUND?last_slash:0);
const String& basename=file_spec->mid(after_base_slash, file_spec->length());	const String& basename=file_spec->mid(last_slash!=STRING_NOT_FOUND?last_slash+1:0, file_spec->length());

int after_monkey_slash;	size_t rpos=dirname.is_empty()?0:dirname.length()-1;
while((after_monkey_slash=lastposafter(*dirname, 0, "/", 1, true))>0) {	while((rpos=dirname.rskipchars("/\\", 0, rpos))!=STRING_NOT_FOUND){
	size_t slash=dirname.strrpbrk("/\\", 0, rpos);
	if(slash==STRING_NOT_FOUND)
	break;
String test_name;	String test_name;
test_name<<*(dirname=&dirname->mid(0, after_monkey_slash));	test_name << dirname.mid(0, slash+1);
test_name<<basename;	test_name << basename;
if(file_exist(r.absolute(test_name))) {	if(file_exist(r.absolute(test_name))) {
r.write_assign_lang(test_name);	r.write_pass_lang(test_name);
return;	return;
}	}
	rpos=slash;
}	}

// no way, not found	// no way, not found
if(params.count()==2) {	if(not_found_code)
Value& not_found_code=params.as_junction(1, "not-found param must be code");	r.write_pass_lang(r.process(*not_found_code));
r.write_pass_lang(r.process(not_found_code));
}
}	}

static void _dirname(Request& r, MethodParams& params) {	static void _dirname(Request& r, MethodParams& params) {
const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
	// works as *nix dirname

	// empty > .
	// / > /
	// /a > /
	// /a/ > /
// /a/some.tar.gz > /a	// /a/some.tar.gz > /a
// /a/b/ > /a	// /a/b/ > /a
int afterslash=lastposafter(file_spec, 0, "/", 1, true);	// /a///b/ > /a
if(afterslash>0)	// /a/b/// > /a
r.write_assign_lang(file_spec.mid(0, afterslash==1?1:afterslash-1));	// file > .
else
r.write_assign_lang(String("."));	if(file_spec.is_empty()) {
	r.write_pass_lang(String("."));
	return;
	}

	size_t p;
	size_t slash;
	if((p=file_spec.rskipchars("/\\"))==STRING_NOT_FOUND)
	r.write_pass_lang(String("/"));
	else {
	if((slash=file_spec.strrpbrk("/\\", 0, p))!=STRING_NOT_FOUND) {
	if((p=file_spec.rskipchars("/\\", 0, slash))==STRING_NOT_FOUND)
	p=slash;
	r.write_pass_lang(file_spec.mid(0, p+1));
	return;
	}
	r.write_pass_lang(String("."));
	}
}	}

static void _basename(Request& r, MethodParams& params) {	static void _basename(Request& r, MethodParams& params) {
const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
	// works as *nix basename

	// empty > .
	// / > /
	// /a > a
	// /a/ > a
// /a/some.tar.gz > some.tar.gz	// /a/some.tar.gz > some.tar.gz
int afterslash=lastposafter(file_spec, 0, "/", 1);	// /a/b/ > b
r.write_assign_lang(file_spec.mid(afterslash, file_spec.length()));	// /a///b/ > b
	// /a/b/// > b
	// file > file

	if(file_spec.is_empty()) {
	r.write_pass_lang(String("."));
	return;
	}

	size_t p=file_spec.rskipchars("/\\");
	if(p==STRING_NOT_FOUND)
	r.write_pass_lang(String("/"));
	else
	r.write_pass_lang(file_spec.mid(afterlastslash(file_spec, p), p+1));
}	}

static void _justname(Request& r, MethodParams& params) {	static void _justname(Request& r, MethodParams& params) {
const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
// /a/some.tar.gz > some.tar	// /a/some.tar.gz > some.tar
int afterslash=lastposafter(file_spec, 0, "/", 1);	// /a/b.c/ > empty
int afterdot=lastposafter(file_spec, afterslash, ".", 1);	// /a/b.c > b
r.write_assign_lang(file_spec.mid(afterslash, afterdot!=afterslash?afterdot-1:file_spec.length()));	size_t pos=afterlastslash(file_spec);
	size_t dotpos=file_spec.strrpbrk(".", pos);
	r.write_pass_lang(file_spec.mid(pos, dotpos!=STRING_NOT_FOUND?dotpos:file_spec.length()));
}	}

static void _justext(Request& r, MethodParams& params) {	static void _justext(Request& r, MethodParams& params) {
const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
// /a/some.tar.gz > gz	// /a/some.tar.gz > gz
int afterdot=lastposafter(file_spec, 0, ".", 1);	// /a/b.c/ > empty
if(afterdot>0)	size_t pos=afterlastslash(file_spec);
r.write_assign_lang(file_spec.mid(afterdot, file_spec.length()));	size_t dotpos=file_spec.strrpbrk(".", pos);
	if(dotpos!=STRING_NOT_FOUND)
	r.write_pass_lang(file_spec.mid(dotpos+1, file_spec.length()));
}	}

static void _fullpath(Request& r, MethodParams& params) {	static void _fullpath(Request& r, MethodParams& params) {
Line 801 static void _fullpath(Request& r, Method	Line 924 static void _fullpath(Request& r, Method
}	}
result=&full_disk_path.mid(document_root_length, full_disk_path.length());	result=&full_disk_path.mid(document_root_length, full_disk_path.length());
}	}
r.write_assign_lang(*result);	r.write_pass_lang(*result);
}	}

static void _sql_string(Request& r, MethodParams&) {	static void _sql_string(Request& r, MethodParams&) {
VFile& self=GET_SELF(r, VFile);	VFile& self=GET_SELF(r, VFile);

const char *quoted=r.connection()->quote(self.value_ptr(), self.value_size());	const char *quoted=r.connection()->quote(self.value_ptr(), self.value_size());
r.write_assign_lang(*new String(quoted));	r.write_pass_lang(*new String(quoted));
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
Line 867 public:	Line 990 public:
static void _sql(Request& r, MethodParams& params) {	static void _sql(Request& r, MethodParams& params) {
Value& statement=params.as_junction(0, "statement must be code");	Value& statement=params.as_junction(0, "statement must be code");

Temp_lang temp_lang(r, String::L_SQL);
const String& statement_string=r.process_to_string(statement);	const String& statement_string=r.process_to_string(statement);
const char* statement_cstr=statement_string.untaint_cstr(r.flang, r.connection());	const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());

File_sql_event_handlers handlers(statement_string, statement_cstr);	File_sql_event_handlers handlers(statement_string, statement_cstr);

Line 877 static void _sql(Request& r, MethodParam	Line 999 static void _sql(Request& r, MethodParam
ulong offset=0;	ulong offset=0;

if(params.count()>1)	if(params.count()>1)
if(HashStringValue* options=params.as_no_junction(1, PARAM_MUST_NOT_BE_CODE).get_hash()){	if(HashStringValue* options=params.as_hash(1, "sql options")) {
int valid_options=0;	int valid_options=0;
if(Value* vfilename=options->get(NAME_NAME)) {	if(Value* vfilename=options->get(NAME_NAME)) {
valid_options++;	valid_options++;
Line 889 static void _sql(Request& r, MethodParam	Line 1011 static void _sql(Request& r, MethodParam
}	}
if(Value* vlimit=options->get(sql_limit_name)) {	if(Value* vlimit=options->get(sql_limit_name)) {
valid_options++;	valid_options++;
limit=(ulong)r.process_to_value(*vlimit).as_double();	limit=(ulong)r.process(*vlimit).as_double();
}	}
if(Value* voffset=options->get(sql_offset_name)) {	if(Value* voffset=options->get(sql_offset_name)) {
valid_options++;	valid_options++;
offset=(ulong)r.process_to_value(*voffset).as_double();	offset=(ulong)r.process(*voffset).as_double();
}	}
if(valid_options!=options->count())	if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
Line 907 static void _sql(Request& r, MethodParam	Line 1029 static void _sql(Request& r, MethodParam
handlers,	handlers,
statement_string);	statement_string);

if(!handlers.value)	if(!handlers.value.str)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "produced no result");
0,
"produced no result");

const char* user_file_name_cstr=handlers.user_file_name? handlers.user_file_name->cstr(): 0;

VString* vcontent_type=handlers.user_content_type?
new VString(*handlers.user_content_type)
: user_file_name_cstr?
new VString(r.mime_type_of(user_file_name_cstr))
: 0;
VFile& self=GET_SELF(r, VFile);	VFile& self=GET_SELF(r, VFile);
self.set(true/tainted/, handlers.value.str, handlers.value.length, user_file_name_cstr, vcontent_type);
self.set_mode(false/binary/);	self.set_binary(true/tainted/, handlers.value.str, handlers.value.length, handlers.user_file_name
	, handlers.user_content_type ? new VString(*handlers.user_content_type) : 0
	, &r);
}	}

static void _base64(Request& r, MethodParams& params) {	static void _base64(Request& r, MethodParams& params) {
Line 931 static void _base64(Request& r, MethodPa	Line 1046 static void _base64(Request& r, MethodPa
if(params.count()) {	if(params.count()) {
// decode:	// decode:
// ^file::base64[encoded] // backward	// ^file::base64[encoded] // backward
// ^file::base64[mode;user-file-name;encoded[;$.content-type[...]]]	// ^file::base64[mode;user-file-name;encoded[;$.content-type[...] $.strict(true\|false)]]
bool is_text=false;	bool is_text=false;
	bool strict=false;
VString* vcontent_type=0;	VString* vcontent_type=0;
const char* user_file_name_cstr=0;	const String* user_file_name=0;
size_t param_index=0;	size_t param_index=0;

if(params.count() > 1) {	if(params.count() > 1) {
if(params.count() < 3)	if(params.count() < 3)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME,
0,	0,
"constructor can't have less then 3 parameters (has %d parameters)",	"constructor can not have less then 3 parameters (has %d parameters)",
params.count()); // actually it accepts 1 parameter (backward)	params.count()); // actually it accepts 1 parameter (backward)

is_text=is_text_mode(params.as_no_junction(0, MODE_MUST_NOT_BE_CODE).as_string());	is_text=VFile::is_text_mode(params.as_string(0, MODE_MUST_NOT_BE_CODE));
user_file_name_cstr=params.as_string(1, FILE_NAME_MUST_BE_STRING).taint_cstr(String::L_FILE_SPEC);	user_file_name=&params.as_string(1, FILE_NAME_MUST_BE_STRING);

if(params.count() == 4)	if(params.count() == 4)
if(HashStringValue* options=params.as_hash(3)) {	if(HashStringValue* options=params.as_hash(3)) {
Line 954 static void _base64(Request& r, MethodPa	Line 1070 static void _base64(Request& r, MethodPa
vcontent_type=new VString(value->as_string());	vcontent_type=new VString(value->as_string());
valid_options++;	valid_options++;
}	}
	if(Value* vstrict=options->get(BASE64_STRICT_OPTION_NAME)) {
	strict=r.process(*vstrict).as_bool();
	valid_options++;
	}
if(valid_options!=options->count())	if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
}	}

if(!vcontent_type)
vcontent_type=new VString(r.mime_type_of(user_file_name_cstr));

param_index=2;	param_index=2;
}	}

Line 968 static void _base64(Request& r, MethodPa	Line 1085 static void _base64(Request& r, MethodPa

char* decoded=0;	char* decoded=0;
size_t length=0;	size_t length=0;
pa_base64_decode(encoded, strlen(encoded), decoded, length);	pa_base64_decode(encoded, strlen(encoded), decoded, length, strict);

if(length && is_text)	self.set(true/tainted/, is_text, decoded, length, user_file_name, vcontent_type, &r);
fix_line_breaks(decoded, length);

self.set(true/tainted/, decoded, length, user_file_name_cstr, vcontent_type);

if(params.count() > 1)
self.set_mode(is_text);
} else {	} else {
// encode: ^f.base64[]	// encode: ^f.base64[]
const char* encoded=pa_base64_encode(self.value_ptr(), self.value_size());	const char* encoded=pa_base64_encode(self.value_ptr(), self.value_size());
r.write_assign_lang(new String(encoded, String::L_TAINTED/once ?param=base64(something) was needed**/));	r.write_pass_lang(new String(encoded, String::L_TAINTED/once ?param=base64(something) was needed**/));
}	}
} else {	} else {
// encode: ^file:base64[filespec]	// encode: ^file:base64[filespec]
const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
const char* encoded=pa_base64_encode(r.absolute(file_spec));	const char* encoded=pa_base64_encode(r.absolute(file_spec));
r.write_assign_lang(new String(encoded, String::L_TAINTED/once ?param=base64(something) was needed*/));	r.write_pass_lang(new String(encoded, String::L_TAINTED/once ?param=base64(something) was needed*/));
}	}
}	}

Line 998 static void _crc32(Request& r, MethodPar	Line 1109 static void _crc32(Request& r, MethodPar
const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
crc32=pa_crc32(r.absolute(file_spec));	crc32=pa_crc32(r.absolute(file_spec));
} else {	} else {
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, FILE_NAME_MUST_BE_SPECIFIED);
0,
"file name must be defined");
}	}
} else {	} else {
// ^file.crc32[]	// ^file.crc32[]
Line 1011 static void _crc32(Request& r, MethodPar	Line 1120 static void _crc32(Request& r, MethodPar
}	}


static void file_md5_file_action(	static void file_md5_file_action(struct stat& finfo, int f, const String&, void *context)
struct stat& finfo,
int f,
const String& , const char* /fname/, bool,
void *context)
{	{
PA_MD5_CTX& md5context=static_cast<PA_MD5_CTX >(context);	PA_MD5_CTX& md5context=static_cast<PA_MD5_CTX >(context);
if(finfo.st_size) {	if(finfo.st_size) {
Line 1060 static void _md5(Request& r, MethodParam	Line 1165 static void _md5(Request& r, MethodParam
const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
md5=pa_md5(r.absolute(file_spec));	md5=pa_md5(r.absolute(file_spec));
} else {	} else {
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, FILE_NAME_MUST_BE_SPECIFIED);
0,
"file name must be defined");
}	}
} else {	} else {
// ^file.md5[]	// ^file.md5[]
Line 1076 static void _md5(Request& r, MethodParam	Line 1179 static void _md5(Request& r, MethodParam
// constructor	// constructor

MFile::MFile(): Methoded("file") {	MFile::MFile(): Methoded("file") {
// ^file::create[text;user-name;string]	// ^file::create[text\|binary;file-name;string-or-file[;options hash]]
// ^file::create[text;user-name;string;options hash]	// ^file::create[string-or-file[;options hash]]
// ^file::create[binary;user-name;SOMEDAY SOMETHING]	add_native_method("create", Method::CT_DYNAMIC, _create, 1, 4);
// ^file::create[binary;user-name;SOMEDAY SOMETHING;options hash]
add_native_method("create", Method::CT_DYNAMIC, _create, 3, 4);

// ^file.save[mode;file-name]	// ^file.save[mode;file-name]
// ^file.save[mode;file-name;$.charset[...]]	// ^file.save[mode;file-name;$.charset[...]]
add_native_method("save", Method::CT_DYNAMIC, _save, 2, 3);	add_native_method("save", Method::CT_DYNAMIC, _save, 2, 3);

// ^file:delete[file-name]	// ^file:delete[file-name]
add_native_method("delete", Method::CT_STATIC, _delete, 1, 1);	// ^file:delete[file-name;$.keep-empty-dir(true)$.exception(false)]
	add_native_method("delete", Method::CT_STATIC, _delete, 1, 2);

// ^file:move[from-file-name;to-file-name]	// ^file:move[from-file-name;to-file-name]
add_native_method("move", Method::CT_STATIC, _move, 2, 2);	// ^file:move[from-file-name;to-file-name;$.keep-empty-dir(true)]
	add_native_method("move", Method::CT_STATIC, _move, 2, 3);

// ^file::load[mode;disk-name]	// ^file::load[mode;disk-name]
// ^file::load[mode;disk-name;user-name]	// ^file::load[mode;disk-name;user-name]
Line 1113 MFile::MFile(): Methoded("file") {	Line 1216 MFile::MFile(): Methoded("file") {

// ^file:list[path]	// ^file:list[path]
// ^file:list[path][regexp]	// ^file:list[path][regexp]
	// ^file:list[path][$.filter[regexp] $.stat(true)]
add_native_method("list", Method::CT_STATIC, _list, 1, 2);	add_native_method("list", Method::CT_STATIC, _list, 1, 2);

// ^file:lock[path]{code}	// ^file:lock[path]{code}

E-mail:

Removed from v.1.211
changed lines
	Added in v.1.254