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.154 and 1.181

version 1.154, 2007/04/13 16:58:15	version 1.181, 2009/01/12 07:46:13
Line 9 static const char * const IDENT_FILE_C="	Line 9 static const char * const IDENT_FILE_C="

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

#include "pcre.h"

#include "classes.h"	#include "classes.h"
#include "pa_vmethod_frame.h"	#include "pa_vmethod_frame.h"

Line 36 static const char * const IDENT_FILE_C="	Line 34 static const char * const IDENT_FILE_C="

#define NAME_NAME "name"	#define NAME_NAME "name"

#define FILE_NAME_MUST_BE_STRING "file name must be string"
#define FILE_NAME_MUST_NOT_BE_CODE "file name must not be code"

// externs	// externs

extern String sql_limit_name;	extern String sql_limit_name;
Line 117 static const String::Body cdate_name("cd	Line 112 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);
	}

static bool is_text_mode(const String& mode) {	static bool is_text_mode(const String& mode) {
if(mode==TEXT_MODE_NAME)	if(mode==TEXT_MODE_NAME)
return true;	return true;
if(mode==BINARY_MODE_NAME)	if(mode==BINARY_MODE_NAME)
return false;	return false;
throw Exception("parser.runtime",	throw Exception(PARSER_RUNTIME,
&mode,	&mode,
"is invalid mode, must be either '"TEXT_MODE_NAME"' or '"BINARY_MODE_NAME"'");	"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) {
Value& vmode_name=params. as_no_junction(0, "mode must not be code");	Value& vmode_name=params.as_no_junction(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);

// save	// save
Line 154 static void _move(Request& r, MethodPara	Line 153 static void _move(Request& r, MethodPara
}	}

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

int nCount=0;	int nCount=0;
Line 166 static void copy_process_source(	Line 165 static void copy_process_source(
nCount = file_block_read(from_file, buffer, sizeof(buffer));	nCount = file_block_read(from_file, buffer, sizeof(buffer));
int written=write(to_file, buffer, nCount);	int written=write(to_file, buffer, nCount);
if( written < 0 )	if( written < 0 )
throw Exception(0,	throw Exception("file.access",
0,	0,
"write failed: %s (%d)", strerror(errno), errno);	"write failed: %s (%d)", strerror(errno), errno);

Line 185 static void _copy(Request& r, MethodPara	Line 184 static void _copy(Request& r, MethodPara
String from_spec = r.absolute(vfrom_file_name.as_string());	String from_spec = r.absolute(vfrom_file_name.as_string());
const String& to_spec = r.absolute(vto_file_name.as_string());	const String& to_spec = r.absolute(vto_file_name.as_string());

// create_dir_for_file(to_spec);

file_write_action_under_lock(	file_write_action_under_lock(
to_spec,	to_spec,
"copy",	"copy",
Line 195 static void _copy(Request& r, MethodPara	Line 192 static void _copy(Request& r, MethodPara
}	}

static void _load_pass_param(	static void _load_pass_param(
HashStringValue::key_type key,	HashStringValue::key_type key,
HashStringValue::value_type value,	HashStringValue::value_type value,
HashStringValue *dest) {	HashStringValue *dest) {
dest->put(key, value);	dest->put(key, value);
}	}

static void _load(Request& r, MethodParams& params) {	static void _load(Request& r, MethodParams& params) {
Value& vmode_name=params. as_no_junction(0, "mode must not be code");	bool as_text=is_text_mode(params.as_no_junction(0, MODE_MUST_NOT_BE_CODE).as_string());
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_no_junction(1, FILE_NAME_MUST_NOT_BE_CODE).as_string());
Value* third_param=params.count()>2?&params.as_no_junction(2, "filename or options must not be code")
:0;
HashStringValue* third_param_hash=third_param?third_param->get_hash():0;
size_t alt_filename_param_index=2;
if(third_param_hash)
alt_filename_param_index++;

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

	param_index--;

size_t offset=0;	size_t offset=0;
size_t limit=0;	size_t limit=0;
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_to_value(*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_to_value(*vlimit).as_int();
}	}
// no check on options count here, see file_read	// no check on options count here, see file_read
}	}
File_read_result file=file_read(r.charsets, lfile_name,	File_read_result file=file_read(r.charsets, lfile_name,
is_text_mode(vmode_name.as_string()),	as_text, options, true, 0, offset, limit
options, true, 0, offset, limit
);	);

const char *user_file_name=params.count()>alt_filename_param_index?	const char *user_file_name=(param_index>=2)?
params.as_string(alt_filename_param_index, FILE_NAME_MUST_BE_STRING).cstr()	params.as_string(param_index, FILE_NAME_MUST_BE_STRING).cstr(String::L_FILE_SPEC)
:lfile_name.cstr(String::L_FILE_SPEC);	:lfile_name.cstr(String::L_FILE_SPEC);

Value* vcontent_type=0;	Value* vcontent_type=0;
if(file.headers)	if(file.headers){
{	if(Value* remote_content_type=file.headers->get(HTTP_CONTENT_TYPE_UPPER))
if(Value* remote_content_type=file.headers->get("CONTENT-TYPE"))
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)	if(!vcontent_type)
Line 243 static void _load(Request& r, MethodPara	Line 239 static void _load(Request& r, MethodPara

VFile& self=GET_SELF(r, VFile);	VFile& self=GET_SELF(r, VFile);
self.set(true/tainted/, file.str, file.length, user_file_name, vcontent_type);	self.set(true/tainted/, file.str, file.length, user_file_name, vcontent_type);
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());
	} else {
	size_t size;
	time_t atime, mtime, ctime;

	file_stat(lfile_name, size, atime, mtime, ctime);

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

}	}

static void _create(Request& r, MethodParams& params) {	static void _create(Request& r, MethodParams& params) {
Value& vmode_name=params. as_no_junction(0, "mode must not be code");	Value& vmode_name=params.as_no_junction(0, MODE_MUST_NOT_BE_CODE);
if(!is_text_mode(vmode_name.as_string()))	if(!is_text_mode(vmode_name.as_string()))
throw Exception("parser.runtime",	throw Exception(PARSER_RUNTIME,
0,	0,
"only text mode is currently supported");	"only text mode is currently supported");

Line 277 static void _stat(Request& r, MethodPara	Line 286 static void _stat(Request& r, MethodPara
size,	size,
atime, mtime, ctime);	atime, mtime, ctime);

	const char* user_file_name=lfile_name.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);
	self.set(true/tainted/, 0/no bytes/, size, user_file_name, new VString(r.mime_type_of(user_file_name)));
HashStringValue& ff=self.fields();	HashStringValue& ff=self.fields();
ff.put(adate_name, new VDate(atime));	ff.put(adate_name, new VDate(atime));
ff.put(mdate_name, new VDate(mtime));	ff.put(mdate_name, new VDate(mtime));
ff.put(cdate_name, new VDate(ctime));	ff.put(cdate_name, new VDate(ctime));
ff.put(content_type_name, new VString(r.mime_type_of(lfile_name.cstr(String::L_FILE_SPEC))));
}	}

static bool is_safe_env_key(const char* key) {	static bool is_safe_env_key(const char* key) {
Line 310 struct Append_env_pair_info {	Line 321 struct Append_env_pair_info {
};	};
#endif	#endif
static void append_env_pair(	static void append_env_pair(
HashStringValue::key_type akey,	HashStringValue::key_type akey,
HashStringValue::value_type avalue,	HashStringValue::value_type avalue,
Append_env_pair_info *info) {	Append_env_pair_info *info) {
if(akey==STDIN_EXEC_PARAM_NAME) {	if(akey==STDIN_EXEC_PARAM_NAME) {
info->vstdin=avalue;	info->vstdin=avalue;
} else if(akey==CHARSET_EXEC_PARAM_NAME) {	} else if(akey==CHARSET_EXEC_PARAM_NAME) {
// ignore, already processed	// ignore, already processed
} else {	} else {
if(!is_safe_env_key(akey.cstr()))	if(!is_safe_env_key(akey.cstr()))
throw Exception("parser.runtime",	throw Exception(PARSER_RUNTIME,
new String(akey, String::L_TAINTED),	new String(akey, String::L_TAINTED),
"not safe environment variable");	"not safe environment variable");
info->env->put(akey, avalue->as_string().cstr_to_string_body(String::L_UNSPECIFIED, 0, info->charsets));	info->env->put(akey, avalue->as_string().cstr_to_string_body(String::L_UNSPECIFIED, 0, info->charsets));
Line 333 struct Pass_cgi_header_attribute_info {	Line 344 struct Pass_cgi_header_attribute_info {
};	};
#endif	#endif
static void pass_cgi_header_attribute(	static void pass_cgi_header_attribute(
ArrayString::element_type astring,	ArrayString::element_type astring,
Pass_cgi_header_attribute_info* info) {	Pass_cgi_header_attribute_info* info) {
size_t colon_pos=astring->pos(':');	size_t colon_pos=astring->pos(':');
if(colon_pos!=STRING_NOT_FOUND) {	if(colon_pos!=STRING_NOT_FOUND) {
const String& key=astring->mid(0, colon_pos).change_case(	const String& key=astring->mid(0, colon_pos).change_case(
*info->charset, String::CC_UPPER);	*info->charset, String::CC_UPPER);
Value* value=new VString(astring->mid(colon_pos+1, astring->length()).trim());	Value* value=new VString(astring->mid(colon_pos+1, astring->length()).trim());
info->fields->put(key, value);	info->fields->put(key, value);
if(key=="CONTENT-TYPE")	if(key==HTTP_CONTENT_TYPE_UPPER)
info->content_type=value;	info->content_type=value;
}	}
}	}

	static void append_to_argv(Request& r, ArrayString& argv, const String* str){
	if( str->length() ){
	argv+=new String(str->cstr_to_string_body(String::L_UNSPECIFIED, 0, &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,	static void _exec_cgi(Request& r, MethodParams& params,
bool cgi) {	bool cgi) {

Value& vfile_name=params.as_no_junction(0, FILE_NAME_MUST_NOT_BE_CODE);	Value& first_param=params.as_no_junction(0, FIRST_ARG_MUST_NOT_BE_CODE);

	bool is_mode_specified=is_valid_mode(first_param.as_string());
	const String& mode_name=(is_mode_specified) ? first_param.as_string() : *new String(TEXT_MODE_NAME);

	size_t param_index=1;
	if(!is_mode_specified){
	--param_index;
	}

	if(param_index>=params.count())
	throw Exception(PARSER_RUNTIME,
	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(vfile_name.as_string());	const String& script_name=r.absolute(vfile_name.as_string());

Line 390 static void _exec_cgi(Request& r, Method	Line 424 static void _exec_cgi(Request& r, Method
// 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(params.count()>1) {	if(param_index < params.count()) {
Value& venv=params.as_no_junction(1, "env must not be code");	Value& venv=params.as_no_junction(param_index++, "env must not be code");
if(HashStringValue* user_env=venv.get_hash()) {	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))
Line 415 static void _exec_cgi(Request& r, Method	Line 449 static void _exec_cgi(Request& r, Method
if(VFile* vfile=static_cast<VFile *>(info.vstdin->as("file", false)))	if(VFile* vfile=static_cast<VFile *>(info.vstdin->as("file", false)))
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);
else	else
throw Exception("parser.runtime",	throw Exception(PARSER_RUNTIME,
0,	0,
STDIN_EXEC_PARAM_NAME " parameter must be string or file");	STDIN_EXEC_PARAM_NAME " parameter must be string or file");
}	}
Line 424 static void _exec_cgi(Request& r, Method	Line 458 static void _exec_cgi(Request& r, Method

// argv from params	// argv from params
ArrayString argv;	ArrayString argv;
if(params.count()>2) {	if(param_index < params.count()) {
// influence tainting	// influence tainting
// main target -- URLencoding of tainted pieces to String::L_URI lang	// main target -- URLencoding of tainted pieces to String::L_URI lang
Temp_client_charset temp(r.charsets, charset? *charset: r.charsets.source());	Temp_client_charset temp(r.charsets, charset? *charset: r.charsets.source());

for(size_t i=2; i<params.count(); i++) {	for(size_t i=param_index; i<params.count(); i++) {
Value& param=params.as_no_junction(i, "parameter must not be code");	Value& param=params.as_no_junction(i, PARAM_MUST_NOT_BE_CODE);
if(param.is_defined()){	if(param.is_defined()){
if(param.is_string()){	if(param.is_string()){
const String& pstring=*param.get_string();	append_to_argv(r, argv, param.get_string());
if(pstring.length() > 0) {
argv+=new String(pstring.cstr_to_string_body(String::L_UNSPECIFIED, 0, &r.charsets), String::L_AS_IS);
}
} else {	} else {
Table* ptable=param.get_table();	Table* table=param.get_table();
if(ptable){	if(table){
for(size_t i=0; i<ptable->count(); i++) {	for(size_t i=0; i<table->count(); i++) {
argv+=new String(ptable->get(i)->get(0)->cstr_to_string_body(String::L_UNSPECIFIED, 0, &r.charsets), String::L_AS_IS);	append_to_argv(r, argv, table->get(i)->get(0));
}	}
} else {	} else {
throw Exception("parser.runtime",	throw Exception(PARSER_RUNTIME,
0,	0,
"parameter must be string or table");	"param must be string or table");
}	}
}	}
}	}
Line 464 static void _exec_cgi(Request& r, Method	Line 495 static void _exec_cgi(Request& r, Method
// match silent conversion in OS	// match silent conversion in OS

// exec!	// exec!
PA_exec_result execution=	PA_exec_result execution=pa_exec(false/forced_allow/, script_name, &env, argv, *in);
pa_exec(false/forced_allow/, script_name, &env, argv, *in);

String *real_out=&execution.out;	File_read_result *file_out=&execution.out;
String *real_err=&execution.err;	String *real_err=&execution.err;
// transcode if necessary
if(charset) {	// transcode err if necessary (@todo: need fix line breaks in err as well )
real_out=&Charset::transcode(real_out, charset, r.charsets.source());	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 && is_text_mode(mode_name)){
	fix_line_breaks(file_out->str, file_out->length);
	// treat output as string
	String *real_out = new String(file_out->str, file_out->length);

	// transcode out if necessary
	if(charset)
	real_out=&Charset::transcode(real_out, charset, r.charsets.source());

	// FIXME: unsafe cast
	file_out->str=const_cast<char *>(real_out->cstr()); // hacking a little
	file_out->length = real_out->length();
}	}

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

const String* body=real_out; // ^file:exec	if(cgi) { // ^file::cgi
const char* eol_marker=0; size_t eol_marker_size;	const char* eol_marker=0;
const String* header=0;	size_t eol_marker_size;
if(cgi) { // ^file:cgi
// construct with 'out' body and header	// construct with 'out' body and header
size_t dos_pos=real_out->pos("\r\n\r\n", 4);	size_t dos_pos=(file_out->length)?strpos(file_out->str, "\r\n\r\n"):STRING_NOT_FOUND;
size_t unix_pos=real_out->pos("\n\n", 2);	size_t unix_pos=(file_out->length)?strpos(file_out->str, "\n\n"):STRING_NOT_FOUND;

bool unix_header_break;	bool unix_header_break;
switch((dos_pos!=STRING_NOT_FOUND?10:00) + (unix_pos!=STRING_NOT_FOUND?01:00)) {	switch((dos_pos!=STRING_NOT_FOUND?10:00) + (unix_pos!=STRING_NOT_FOUND?01:00)) {
case 10: // dos	case 10: // dos
unix_header_break=false;	unix_header_break=false;
break;	break;
case 01: // unix	case 01: // unix
unix_header_break=true;	unix_header_break=true;
break;	break;
case 11: // dos & unix	case 11: // dos & unix
unix_header_break=unix_pos<dos_pos;	unix_header_break=unix_pos<dos_pos;
break;	break;
default: // 00	default: // 00
unix_header_break=false; // calm down, compiler	unix_header_break=false; // calm down, compiler
throw Exception(0,	throw Exception("file.execute",
0,	0,
"output does not contain CGI header; "	"output does not contain CGI header; "
"exit status=%d; stdoutsize=%u; stdout: \"%s\"; stderrsize=%u; stderr: \"%s\"",	"exit status=%d; stdoutsize=%u; stdout: \"%s\"; stderrsize=%u; stderr: \"%s\"",
execution.status,	execution.status,
(uint)real_out->length(), real_out->cstr(),	(size_t)file_out->length, (file_out->length) ? (file_out->str) : "",
(uint)real_err->length(), real_err->cstr());	(size_t)real_err->length(), real_err->cstr());
break; //never reached	break; //never reached
}	}

int header_break_pos;	size_t header_break_pos;
if(unix_header_break) {	if(unix_header_break) {
header_break_pos=unix_pos;	header_break_pos=unix_pos;
eol_marker="\n"; eol_marker_size=1;	eol_marker="\n";
	eol_marker_size=1;
} else {	} else {
header_break_pos=dos_pos;	header_break_pos=dos_pos;
eol_marker="\r\n"; eol_marker_size=2;	eol_marker="\r\n";
	eol_marker_size=2;
}	}

header=&real_out->mid(0, header_break_pos);	file_out->str[header_break_pos] = 0;
body=&real_out->mid(header_break_pos+eol_marker_size*2, real_out->length());	String *header=new String(file_out->str, header_break_pos);
}	unsigned long headersize = header_break_pos+eol_marker_size*2;
// body	file_out->str += headersize;
self.set(false/not tainted/, body->cstr(), body->length());	file_out->length -= headersize;

// $fields << header	// $body
if(header && eol_marker) {	self.set(false/not tainted/, file_out->str, file_out->length);
ArrayString rows;
size_t pos_after=0;	// $fields << header
header->split(rows, pos_after, eol_marker);	if(header && eol_marker) {
Pass_cgi_header_attribute_info info={0, 0, 0};	ArrayString rows;
info.charset=&r.charsets.source();	size_t pos_after=0;
info.fields=&self.fields();	header->split(rows, pos_after, eol_marker);
rows.for_each(pass_cgi_header_attribute, &info);	Pass_cgi_header_attribute_info info={0, 0, 0};
if(info.content_type)	info.charset=&r.charsets.source();
self.fields().put(content_type_name, info.content_type);	info.fields=&self.fields();
	rows.for_each(pass_cgi_header_attribute, &info);
	if(info.content_type)
	self.fields().put(content_type_name, info.content_type);
	}
	} else { // ^file::exec
	// $body
	self.set(false/not tainted/, file_out->str, file_out->length);
}	}

// $status	// $status
Line 562 static void _list(Request& r, MethodPara	Line 614 static void _list(Request& r, MethodPara
if(params.count()>1) {	if(params.count()>1) {
regexp=&params.as_no_junction(1, "regexp must not be code").as_string();	regexp=&params.as_no_junction(1, "regexp must not be code").as_string();

const char* pattern=regexp->cstr();	const char* pattern=regexp->cstr(String::L_UNSPECIFIED);
const char* errptr;	const char* errptr;
int erroffset;	int erroffset;
regexp_code=pcre_compile(pattern, PCRE_EXTRA \| PCRE_DOTALL,	int options=PCRE_EXTRA \| PCRE_DOTALL;
	if(r.charsets.source().isUTF8())
	options=options\|PCRE_UTF8;

	regexp_code=pcre_compile(pattern, options,
&errptr, &erroffset,	&errptr, &erroffset,
r.charsets.source().pcre_tables);	r.charsets.source().pcre_tables);

if(!regexp_code)	if(!regexp_code)
throw Exception(0,	throw Exception(PCRE_EXCEPTION_TYPE,
&regexp->mid(erroffset, regexp->length()),	&regexp->mid(erroffset, regexp->length()),
"regular expression syntax error - %s", errptr);	"regular expression syntax error - %s", errptr);
} else {	} else {
Line 598 static void _list(Request& r, MethodPara	Line 654 static void _list(Request& r, MethodPara
suits=false;	suits=false;
else if(exec_result<0) {	else if(exec_result<0) {
(*pcre_free)(regexp_code);	(*pcre_free)(regexp_code);
throw Exception(0,	throw Exception(PCRE_EXCEPTION_TYPE,
regexp,	regexp,
"regular expression execute (%d)",	print_pcre_exec_error_text(exec_result),
exec_result);	exec_result);
}	}
}	}
Line 637 static void _lock(Request& r, MethodPara	Line 693 static void _lock(Request& r, MethodPara
&params.as_junction(1, "body must be code")	&params.as_junction(1, "body must be code")
};	};

file_write_action_under_lock(file_spec, "lock", lock_execute_body, &info);	file_write_action_under_lock(
	file_spec,
	"lock",
	lock_execute_body,
	&info);
}	}

static int lastposafter(const String& s, size_t after, const char* substr, size_t substr_size, bool beforelast=false) {	static int lastposafter(const String& s, size_t after, const char* substr, size_t substr_size, bool beforelast=false) {
Line 694 static void _find(Request& r, MethodPara	Line 754 static void _find(Request& r, MethodPara

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);
// /a/some.tar.gz > /a	// /a/some.tar.gz > /a
// /a/b/ > /a	// /a/b/ > /a
int afterslash=lastposafter(file_spec, 0, "/", 1, true);	int afterslash=lastposafter(file_spec, 0, "/", 1, true);
if(afterslash>0)	if(afterslash>0)
Line 705 static void _dirname(Request& r, MethodP	Line 765 static void _dirname(Request& r, MethodP

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);
// /a/some.tar.gz > some.tar.gz	// /a/some.tar.gz > some.tar.gz
int afterslash=lastposafter(file_spec, 0, "/", 1);	int afterslash=lastposafter(file_spec, 0, "/", 1);
r.write_assign_lang(file_spec.mid(afterslash, file_spec.length()));	r.write_assign_lang(file_spec.mid(afterslash, file_spec.length()));
}	}

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);	int afterslash=lastposafter(file_spec, 0, "/", 1);
int afterdot=lastposafter(file_spec, afterslash, ".", 1);	int afterdot=lastposafter(file_spec, afterslash, ".", 1);
r.write_assign_lang(file_spec.mid(afterslash, afterdot!=afterslash?afterdot-1:file_spec.length()));	r.write_assign_lang(file_spec.mid(afterslash, afterdot!=afterslash?afterdot-1: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);	int afterdot=lastposafter(file_spec, 0, ".", 1);
if(afterdot>0)	if(afterdot>0)
r.write_assign_lang(file_spec.mid(afterdot, file_spec.length()));	r.write_assign_lang(file_spec.mid(afterdot, file_spec.length()));
Line 772 public:	Line 832 public:

bool add_column(SQL_Error& error, const char* /str/, size_t /length/) {	bool add_column(SQL_Error& error, const char* /str/, size_t /length/) {
if(got_columns++==3) {	if(got_columns++==3) {
error=SQL_Error("parser.runtime", "result must contain not more then 3 columns");	error=SQL_Error(PARSER_RUNTIME, "result must contain not more then 3 columns");
return true;	return true;
}	}
return false;	return false;
Line 794 public:	Line 854 public:
user_content_type=new String(str, length, true);	user_content_type=new String(str, length, true);
break;	break;
default:	default:
error=SQL_Error("parser.runtime", "result must not contain more then one row, three rows");	error=SQL_Error(PARSER_RUNTIME, "result must not contain more then one row, three rows");
return true;	return true;
}	}
return false;	return false;
Line 814 static void _sql(Request& r, MethodParam	Line 874 static void _sql(Request& r, MethodParam
statement_string.cstr(String::L_UNSPECIFIED, r.connection());	statement_string.cstr(String::L_UNSPECIFIED, r.connection());
File_sql_event_handlers handlers(statement_string, statement_cstr);	File_sql_event_handlers handlers(statement_string, statement_cstr);

	ulong limit=SQL_NO_LIMIT;
	ulong offset=0;

if(params.count()>1)	if(params.count()>1)
if(HashStringValue* options=	if(HashStringValue* options=params.as_no_junction(1, PARAM_MUST_NOT_BE_CODE).get_hash()){
params.as_no_junction(1, "param must not be code").get_hash()) {
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 826 static void _sql(Request& r, MethodParam	Line 888 static void _sql(Request& r, MethodParam
valid_options++;	valid_options++;
handlers.user_content_type=&vcontent_type->as_string();	handlers.user_content_type=&vcontent_type->as_string();
}	}
	if(Value* vlimit=options->get(sql_limit_name)) {
	valid_options++;
	limit=(ulong)r.process_to_value(*vlimit).as_double();
	}
	if(Value* voffset=options->get(sql_offset_name)) {
	valid_options++;
	offset=(ulong)r.process_to_value(*voffset).as_double();
	}
if(valid_options!=options->count())	if(valid_options!=options->count())
throw Exception("parser.runtime",	throw Exception(PARSER_RUNTIME,
0,	0,
"called with invalid option");	"called with invalid option");
}	}
Line 836 static void _sql(Request& r, MethodParam	Line 906 static void _sql(Request& r, MethodParam
r.connection()->query(	r.connection()->query(
statement_cstr,	statement_cstr,
0, 0,	0, 0,
0, 0,	offset, limit,
handlers,	handlers,
statement_string);	statement_string);

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

Line 858 static void _sql(Request& r, MethodParam	Line 928 static void _sql(Request& r, MethodParam

static void _base64(Request& r, MethodParams& params) {	static void _base64(Request& r, MethodParams& params) {
bool dynamic = !(&r.get_self() == file_class);	bool dynamic = !(&r.get_self() == file_class);
if ( dynamic ){	if(dynamic){
VFile& self=GET_SELF(r, VFile);	VFile& self=GET_SELF(r, VFile);
if(params.count()) {	if(params.count()) {
// decode	// decode: ^file::base64[encoded]
const char* cstr=params.as_string(0, "parameter must be string").cstr();	const char* cstr=params.as_string(0, PARAMETER_MUST_BE_STRING).cstr();
char* decoded_cstr=0;	char* decoded=0;
size_t decoded_size=0;	size_t length=0;
pa_base64_decode(cstr, strlen(cstr), decoded_cstr, decoded_size);	pa_base64_decode(cstr, strlen(cstr), decoded, length);
if(decoded_cstr && decoded_size)	if(decoded && length)
self.set(true/tainted/, decoded_cstr, decoded_size);	self.set(true/tainted/, decoded, length);
} else {	} else {
// encode	// 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, 0, true/once ?param=base64(something) was needed*/));	r.write_assign_lang(new String(encoded, 0, true/tainted. once ?param=base64(something) was needed**/));
}	}
} else {	} else {
// encode	// 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, 0, true/once ?param=base64(something) was needed*/));	r.write_assign_lang(new String(encoded, 0, true/tainted. once ?param=base64(something) was needed*/));
}	}
}	}

Line 889 static void _crc32(Request& r, MethodPar	Line 959 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,	0,
"file name must be defined");	"file name must be defined");
}	}
Line 903 static void _crc32(Request& r, MethodPar	Line 973 static void _crc32(Request& r, MethodPar


static void file_md5_file_action(	static void file_md5_file_action(
struct stat& finfo,	struct stat& finfo,
int f,	int f,
const String& , const char* /fname/, bool,	const String& , const char* /fname/, bool,
void *context)	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 951 static void _md5(Request& r, MethodParam	Line 1021 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,	0,
"file name must be defined");	"file name must be defined");
}	}
Line 982 MFile::MFile(): Methoded("file") {	Line 1052 MFile::MFile(): Methoded("file") {

// ^file::load[mode;disk-name]	// ^file::load[mode;disk-name]
// ^file::load[mode;disk-name;user-name]	// ^file::load[mode;disk-name;user-name]
add_native_method("load", Method::CT_DYNAMIC, _load, 2, 3);	add_native_method("load", Method::CT_DYNAMIC, _load, 2, 4);

// ^file::stat[disk-name]	// ^file::stat[disk-name]
add_native_method("stat", Method::CT_DYNAMIC, _stat, 1, 1);	add_native_method("stat", Method::CT_DYNAMIC, _stat, 1, 1);

// ^file::cgi[file-name]	// ^file::cgi[mode;file-name]
// ^file::cgi[file-name;env hash]	// ^file::cgi[mode;file-name;env hash]
// ^file::cgi[file-name;env hash;1cmd;2line;3ar;4g;5s]	// ^file::cgi[mode;file-name;env hash;1cmd;2line;3ar;4g;5s]
add_native_method("cgi", Method::CT_DYNAMIC, _cgi, 1, 2+50);	add_native_method("cgi", Method::CT_DYNAMIC, _cgi, 1, 3+50);

// ^file::exec[file-name]	// ^file::exec[mode;file-name]
// ^file::exec[file-name;env hash]	// ^file::exec[mode;file-name;env hash]
// ^file::exec[file-name;env hash;1cmd;2line;3ar;4g;5s]	// ^file::exec[mode;file-name;env hash;1cmd;2line;3ar;4g;5s]
add_native_method("exec", Method::CT_DYNAMIC, _exec, 1, 2+50);	add_native_method("exec", Method::CT_DYNAMIC, _exec, 1, 3+50);

// ^file:list[path]	// ^file:list[path]
// ^file:list[path][regexp]	// ^file:list[path][regexp]

E-mail:

Removed from v.1.154
changed lines
	Added in v.1.181