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.107.2.16.2.8 and 1.123

version 1.107.2.16.2.8, 2003/03/24 13:43:39	version 1.123, 2004/06/18 15:55:46
Line 1	Line 1
/** @file	/** @file
Parser: @b file parser class.	Parser: @b file parser class.

Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2004 ArtLebedev Group (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* IDENT_FILE_C="$Date$";	static const char * const IDENT_FILE_C="$Date$";

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

Line 23 static const char* IDENT_FILE_C="$Date$"	Line 23 static const char* IDENT_FILE_C="$Date$"
#include "pa_dir.h"	#include "pa_dir.h"
#include "pa_vtable.h"	#include "pa_vtable.h"
#include "pa_charset.h"	#include "pa_charset.h"
	#include "pa_charsets.h"
	#include "pa_sql_connection.h"

// defines	// defines

#define TEXT_MODE_NAME "text"	#define TEXT_MODE_NAME "text"
#define STDIN_EXEC_PARAM_NAME "stdin"	#define STDIN_EXEC_PARAM_NAME "stdin"
	#define CHARSET_EXEC_PARAM_NAME "charset"

// class	// class

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

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

public: // Methoded	public: // Methoded
bool used_directly() { return true; }	bool used_directly() { return true; }
Line 96 static const char* suexec_safe_env_lst[]	Line 99 static const char* suexec_safe_env_lst[]

// statics	// statics

static const StringBody adate_name("adate");	static const String::Body adate_name("adate");
static const StringBody mdate_name("mdate");	static const String::Body mdate_name("mdate");
static const StringBody cdate_name("cdate");	static const String::Body cdate_name("cdate");

// methods	// methods

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
GET_SELF(r, VFile).save(r.absolute(vfile_name.as_string()),	GET_SELF(r, VFile).save(r.absolute(vfile_name.as_string()),
vmode_name.as_string()==TEXT_MODE_NAME);	vmode_name.as_string()==TEXT_MODE_NAME);
}	}

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");	Value& vfile_name=params.as_no_junction(0, "file name must not be code");

// unlink	// unlink
file_delete(r.absolute(vfile_name.as_string()));	file_delete(r.absolute(vfile_name.as_string()));
}	}

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");

// move	// move
file_move(	file_move(
Line 134 static void _load_pass_param(	Line 137 static void _load_pass_param(
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");	Value& vmode_name=params. as_no_junction(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_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")	Value* third_param=params.count()>2?&params.as_no_junction(2, "filename or options must not be code")
:0;	:0;
HashStringValue* third_param_hash=third_param?third_param->get_hash():0;	HashStringValue* third_param_hash=third_param?third_param->get_hash():0;
int alt_filename_param_index=2;	size_t alt_filename_param_index=2;
if(third_param_hash)	if(third_param_hash)
alt_filename_param_index++;	alt_filename_param_index++;

File_read_result file=file_read(r.charsets.source(), lfile_name,	File_read_result file=file_read(r.charsets, lfile_name,
vmode_name.as_string()==TEXT_MODE_NAME,	vmode_name.as_string()==TEXT_MODE_NAME,
third_param_hash	third_param_hash
);	);

const char *user_file_name=params->count()>alt_filename_param_index?	const char *user_file_name=params.count()>alt_filename_param_index?
params->as_string(alt_filename_param_index, "filename must be string").cstr()	params.as_string(alt_filename_param_index, "filename must be string").cstr()
:lfile_name.cstr(String::L_FILE_SPEC);	:lfile_name.cstr(String::L_FILE_SPEC);

Value* vcontent_type=0;	Value* vcontent_type=0;
Line 165 static void _load(Request& r, MethodPara	Line 168 static void _load(Request& r, MethodPara
file.headers->for_each(_load_pass_param, &self.fields());	file.headers->for_each(_load_pass_param, &self.fields());
}	}

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");	Value& vfile_name=params.as_no_junction(0, "file name must not be code");

const String& lfile_name=vfile_name.as_string();	const String& lfile_name=vfile_name.as_string();

Line 186 static void _stat(Request& r, MethodPara	Line 189 static void _stat(Request& r, MethodPara
}	}

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++) {
	char c=*validator;
	if(!(c>='A' && c<='Z' \|\| c>='0' && c<='9' \|\| c=='_' \|\| c=='-'))
	return false;
	}
if(strncasecmp(key, "HTTP_", 5)==0)	if(strncasecmp(key, "HTTP_", 5)==0)
return true;	return true;
if(strncasecmp(key, "CGI_", 4)==0)	if(strncasecmp(key, "CGI_", 4)==0)
Line 200 static bool is_safe_env_key(const char*	Line 208 static bool is_safe_env_key(const char*
struct Append_env_pair_info {	struct Append_env_pair_info {
HashStringString* env;	HashStringString* env;
Value* vstdin;	Value* vstdin;
	Value* vcharset;
};	};
#endif	#endif
static void append_env_pair(	static void append_env_pair(
Line 208 static void append_env_pair(	Line 217 static void append_env_pair(
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) {
	info->vcharset=avalue;
} else {	} else {
if(!is_safe_env_key(akey.cstr()))	if(!is_safe_env_key(akey.cstr()))
throw Exception("parser.runtime",	throw Exception("parser.runtime",
Line 224 struct Pass_cgi_header_attribute_info {	Line 235 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) {
int colon_pos=astring->pos(":", 1);	size_t colon_pos=astring->pos(':');
if(colon_pos>0) {	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()));	Value* value=new VString(astring->mid(colon_pos+1, astring->length()));
Line 237 static void pass_cgi_header_attribute(	Line 248 static void pass_cgi_header_attribute(
}	}
}	}
/// @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& vfile_name=params.as_no_junction(0, "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 248 static void _exec_cgi(Request& r, Method	Line 259 static void _exec_cgi(Request& r, Method
#define ECSTR(name, value_cstr) \	#define ECSTR(name, value_cstr) \
if(value_cstr) \	if(value_cstr) \
env.put( \	env.put( \
StringBody(#name), \	String::Body(#name), \
StringBody(value_cstr)); \	String::Body(value_cstr, 0)); \
// passing SAPI::environment	// passing SAPI::environment
if(const char const pairs=SAPI::environment(r.sapi_info)) {	if(const char const pairs=SAPI::environment(r.sapi_info)) {
while(const char* pair=*pairs++)	while(const char* pair=*pairs++)
if(const char* eq_at=strchr(pair, '='))	if(const char* eq_at=strchr(pair, '='))
env.put(	if(eq_at[1]) // has value
StringBody(pair, eq_at-pair),	env.put(
StringBody(eq_at+1));	pa_strdup(pair, eq_at-pair),
	pa_strdup(eq_at+1, 0));
}	}

// const	// const
Line 273 static void _exec_cgi(Request& r, Method	Line 285 static void _exec_cgi(Request& r, Method
//String content_length(content_length_cstr);	//String content_length(content_length_cstr);
ECSTR(CONTENT_LENGTH, content_length_cstr);	ECSTR(CONTENT_LENGTH, content_length_cstr);
// SCRIPT_*	// SCRIPT_*
env.put(StringBody("SCRIPT_NAME"), script_name);	env.put(String::Body("SCRIPT_NAME"), script_name);
//env.put(StringBody("SCRIPT_FILENAME"), ??&script_name);	//env.put(String::Body("SCRIPT_FILENAME"), ??&script_name);

bool stdin_specified=false;	bool stdin_specified=false;
// environment & stdin from param	// environment & stdin from param
String in;	String *in=new String();
if(params->count()>1) {	Charset *charset=0; // default script works raw_in 'source' charset = no transcoding needed
Value& venv=params->as_no_junction(1, "env must not be code");	if(params.count()>1) {
	Value& venv=params.as_no_junction(1, "env must not be code");
if(HashStringValue* user_env=venv.get_hash()) {	if(HashStringValue* user_env=venv.get_hash()) {
Append_env_pair_info info;	Append_env_pair_info info={&env, 0, 0};
info.env=&env;
user_env->for_each(append_env_pair, &info);	user_env->for_each(append_env_pair, &info);
	// $.stdin
if(info.vstdin) {	if(info.vstdin) {
stdin_specified=true;	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);	in->append(*sstdin, String::L_CLEAN, true);
} else	} else
if(VFile* vfile=static_cast<VFile *>(info.vstdin->as("file", false)))	if(VFile* vfile=static_cast<VFile *>(info.vstdin->as("file", false)))
in.append((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");
}	}
	// $.charset
	if(info.vcharset)
	charset=&charsets.get(info.vcharset->as_string()
	.change_case(r.charsets.source(), String::CC_UPPER));
}	}
}	}

// argv from params	// argv from params
ArrayString argv;	ArrayString argv;
if(params->count()>2) {	if(params.count()>2) {
for(int i=2; i<params->count(); i++)	for(size_t i=2; i<params.count(); i++)
argv+=&params->as_string(i, "parameter must be string");	argv+=&params.as_string(i, "parameter must be string");
}	}

// passing POST data	// transcode if necessary
if(!stdin_specified) // if $.stdin[...] not specified	if(charset) {
in.append(r.request_info.post_data, r.request_info.post_size, String::L_CLEAN);	Charset::transcode(env, r.charsets.source(), *charset);
	Charset::transcode(argv, r.charsets.source(), *charset);
	in=&Charset::transcode(in, r.charsets.source(), charset);
	}
	// @todo
	// ifdef WIN32 do OEM->ANSI transcode on some(.cmd?) programs to
	// 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;
	String *real_err=&execution.err;
	// transcode if necessary
	if(charset) {
	real_out=&Charset::transcode(real_out, charset, r.charsets.source());
	real_err=&Charset::transcode(real_err, charset, r.charsets.source());
	}

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

const String* body=&execution.out; // ^file:exec	const String* body=real_out; // ^file:exec
Value* content_type=0;
const char* eol_marker=0; size_t eol_marker_size;	const char* eol_marker=0; size_t eol_marker_size;
const String* header=0;	const String* header=0;
if(cgi) { // ^file:cgi	if(cgi) { // ^file:cgi
// construct with 'out' body and header	// construct with 'out' body and header
int dos_pos=execution.out.pos("\r\n\r\n", 4);	size_t dos_pos=real_out->pos("\r\n\r\n", 4);
int unix_pos=execution.out.pos("\n\n", 2);	size_t unix_pos=real_out->pos("\n\n", 2);

bool unix_header_break;	bool unix_header_break;
switch((dos_pos >= 0?10:00) + (unix_pos >= 0?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;
Line 344 static void _exec_cgi(Request& r, Method	Line 374 static void _exec_cgi(Request& r, Method
"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)execution.out.length(), execution.out.cstr(),	(uint)real_out->length(), real_out->cstr(),
(uint)execution.err.length(), execution.err.cstr());	(uint)real_err->length(), real_err->cstr());
break; //never reached	break; //never reached
}	}

Line 358 static void _exec_cgi(Request& r, Method	Line 388 static void _exec_cgi(Request& r, Method
eol_marker="\r\n"; eol_marker_size=2;	eol_marker="\r\n"; eol_marker_size=2;
}	}

header=&execution.out.mid(0, header_break_pos);	header=&real_out->mid(0, header_break_pos);
body=&execution.out.mid(header_break_pos+eol_marker_size*2, execution.out.length());	body=&real_out->mid(header_break_pos+eol_marker_size*2, real_out->length());
}	}
// body	// body
self.set(false/not tainted/, body->cstr(), body->length());	self.set(false/not tainted/, body->cstr(), body->length());
Line 369 static void _exec_cgi(Request& r, Method	Line 399 static void _exec_cgi(Request& r, Method
ArrayString rows;	ArrayString rows;
size_t pos_after=0;	size_t pos_after=0;
header->split(rows, pos_after, eol_marker);	header->split(rows, pos_after, eol_marker);
Pass_cgi_header_attribute_info info;	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();
rows.for_each(pass_cgi_header_attribute, &info);	rows.for_each(pass_cgi_header_attribute, &info);
Line 381 static void _exec_cgi(Request& r, Method	Line 411 static void _exec_cgi(Request& r, Method
self.fields().put(file_status_name, new VInt(execution.status));	self.fields().put(file_status_name, new VInt(execution.status));

// $stderr	// $stderr
if(execution.err.length())	if(real_err->length())
self.fields().put(	self.fields().put(
StringBody("stderr"),	String::Body("stderr"),
new VString(execution.err));	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);
}	}
static void _cgi(Request& r, MethodParams* params) {	static void _cgi(Request& r, MethodParams& params) {
_exec_cgi(r, params, true);	_exec_cgi(r, params, true);
}	}

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");

const String* regexp;	const String* regexp;
pcre *regexp_code;	pcre *regexp_code;
const int ovecsize=(1/match/)*3;	const int ovecsize=(1/match/)*3;
int ovector[ovecsize];	int ovector[ovecsize];
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();
const char* errptr;	const char* errptr;
Line 414 static void _list(Request& r, MethodPara	Line 444 static void _list(Request& r, MethodPara
throw Exception(0,	throw Exception(0,
&regexp->mid(erroffset, regexp->length()),	&regexp->mid(erroffset, regexp->length()),
"regular expression syntax error - %s", errptr);	"regular expression syntax error - %s", errptr);
} else	} else {
	regexp=0; // not used, just to calm down compiler
regexp_code=0;	regexp_code=0;
	}


const char* absolute_path_cstr=r.absolute(relative_path.as_string()).cstr(String::L_FILE_SPEC);	const char* absolute_path_cstr=r.absolute(relative_path.as_string()).cstr(String::L_FILE_SPEC);
Line 469 static void lock_execute_body(int , void	Line 501 static void lock_execute_body(int , void
// execute body	// execute body
info.r->write_assign_lang(info.r->process(*info.body_code));	info.r->write_assign_lang(info.r->process(*info.body_code));
};	};
static void _lock(Request& r, MethodParams* params) {	static void _lock(Request& r, MethodParams& params) {
Lock_execute_body_info info;	const String& file_spec=r.absolute(params.as_string(0, "file name must be string"));
info.r=&r;	Lock_execute_body_info info={
const String& file_spec=r.absolute(params->as_string(0, "file name must be string"));	&r,
info.body_code=&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) {
size_t size;	size_t size=0; // just to calm down compiler
if(beforelast)	if(beforelast)
size=s.length();	size=s.length();
int at;	size_t at;
while((at=s.pos(StringBody(substr, substr_size), after))>=0) {	while((at=s.pos(String::Body(substr, substr_size), after))!=STRING_NOT_FOUND) {
size_t newafter=at+substr_size/skip substr/;	size_t newafter=at+substr_size/skip substr/;
if(beforelast && newafter==size)	if(beforelast && newafter==size)
break;	break;
Line 493 static int lastposafter(const String& s,	Line 526 static int lastposafter(const String& s,
return after;	return after;
}	}

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_no_junction(0, "file name must not be code").as_string();
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 524 static void _find(Request& r, MethodPara	Line 557 static void _find(Request& r, MethodPara
}	}

// no way, not found	// no way, not found
if(params->count()==2) {	if(params.count()==2) {
Value& not_found_code=params->as_junction(1, "not-found param must be 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");
// /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);
Line 541 static void _dirname(Request& r, MethodP	Line 574 static void _dirname(Request& r, MethodP
r.write_assign_lang(String(".", 1));	r.write_assign_lang(String(".", 1));
}	}

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

static void _fullpath(Request& r, MethodParams* params) {	static void _fullpath(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");
const String* result;	const String* result;
if(file_spec.first_char()=='/')	if(file_spec.first_char()=='/')
result=&file_spec;	result=&file_spec;
Line 583 static void _fullpath(Request& r, Method	Line 616 static void _fullpath(Request& r, Method
r.write_assign_lang(*result);	r.write_assign_lang(*result);
}	}

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

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

	#ifndef DOXYGEN
	class File_sql_event_handlers: public SQL_Driver_query_event_handlers {
	const String& statement_string; const char* statement_cstr;
	int got_columns;
	int got_cells;
	public:
	String::C value;
	String* user_file_name;
	String* user_content_type;
	public:
	File_sql_event_handlers(
	const String& astatement_string, const char* astatement_cstr):
	statement_string(astatement_string), statement_cstr(astatement_cstr),
	got_columns(0),
	got_cells(0),
	user_file_name(0),
	user_content_type(0) {}

	bool add_column(SQL_Error& error, const char* /str/, size_t /length/) {
	if(got_columns++==3) {
	error=SQL_Error("parser.runtime", "result must contain not more then 3 columns");
	return true;
	}
	return false;
	}
	bool before_rows(SQL_Error& /error/ ) { /* ignore */ return false; }
	bool add_row(SQL_Error& /error/) { /* ignore */ return false; }
	bool add_row_cell(SQL_Error& error, const char* str, size_t length) {
	try {
	switch(got_cells++) {
	case 0:
	value=String::C(str, length);
	break;
	case 1:
	user_file_name=new String(str, length, true);
	break;
	case 2:
	user_content_type=new String(str, length, true);
	break;
	default:
	error=SQL_Error("parser.runtime", "result must not contain more then one row, three rows");
	return true;
	}
	return false;
	} catch(...) {
	error=SQL_Error("exception occured in File_sql_event_handlers::add_row_cell");
	return true;
	}
	}
	};
	#endif
	static void _sql(Request& r, MethodParams& params) {
	const String* user_file_name=0;
	if(params.get(0)->is_string())
	user_file_name=&params.get(0)->as_string();

	Value& statement=params.as_junction(params.count()-1, "statement must be code");

	Temp_lang temp_lang(r, String::L_SQL);
	const String& statement_string=r.process_to_string(statement);
	const char* statement_cstr=
	statement_string.cstr(String::L_UNSPECIFIED, r.connection());
	File_sql_event_handlers handlers(statement_string, statement_cstr);
	r.connection()->query(
	statement_cstr,
	0, 0,
	0, 0,
	handlers,
	statement_string);

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

	if(!user_file_name)
	user_file_name=handlers.user_file_name;

	const char* user_file_name_cstr=user_file_name? 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);
	self.set(true/tainted/, handlers.value.str, handlers.value.length, user_file_name_cstr, vcontent_type);
	}

// constructor	// constructor

Line 635 MFile::MFile(): Methoded("file") {	Line 763 MFile::MFile(): Methoded("file") {
add_native_method("justext", Method::CT_STATIC, _justext, 1, 1);	add_native_method("justext", Method::CT_STATIC, _justext, 1, 1);
// /some/page.html: ^file:fullpath[a.gif] => /some/a.gif	// /some/page.html: ^file:fullpath[a.gif] => /some/a.gif
add_native_method("fullpath", Method::CT_STATIC, _fullpath, 1, 1);	add_native_method("fullpath", Method::CT_STATIC, _fullpath, 1, 1);

	// ^file.sql-string[]
	add_native_method("sql-string", Method::CT_DYNAMIC, _sql_string, 0, 0);

	// ^file::sql[[alt_name]]{}
	add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 2);
}	}

E-mail:

Removed from v.1.107.2.16.2.8
changed lines
	Added in v.1.123