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.129 and 1.169

version 1.129, 2004/08/17 10:00:33	version 1.169, 2008/05/14 10:17:05
Line 1	Line 1
/** @file	/** @file
Parser: @b file parser class.	Parser: @b file parser class.

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

Line 25 static const char * const IDENT_FILE_C="	Line 25 static const char * const IDENT_FILE_C="
#include "pa_charset.h"	#include "pa_charset.h"
#include "pa_charsets.h"	#include "pa_charsets.h"
#include "pa_sql_connection.h"	#include "pa_sql_connection.h"
	#include "pa_md5.h"

// defines	// defines

Line 33 static const char * const IDENT_FILE_C="	Line 34 static const char * const IDENT_FILE_C="
#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"

	// externs

	extern String sql_limit_name;
	extern String sql_offset_name;

// 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&, HashStringValue&) { return new VFile(); }

public: // Methoded	public: // Methoded
bool used_directly() { return true; }	bool used_directly() { return true; }
Line 106 static const String::Body cdate_name("cd	Line 114 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
GET_SELF(r, VFile).save(r.absolute(vfile_name.as_string()),	GET_SELF(r, VFile).save(r.absolute(vfile_name.as_string()),
Line 126 static void _save(Request& r, MethodPara	Line 138 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");	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()));
Line 142 static void _move(Request& r, MethodPara	Line 154 static void _move(Request& r, MethodPara
r.absolute(vto_file_name.as_string()));	r.absolute(vto_file_name.as_string()));
}	}

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

	int nCount=0;
	do {
	unsigned char buffer[FILE_BUFFER_SIZE];
	nCount = file_block_read(from_file, buffer, sizeof(buffer));
	int written=write(to_file, buffer, nCount);
	if( written < 0 )
	throw Exception(0,
	0,
	"write failed: %s (%d)", strerror(errno), errno);

	} while(nCount > 0);
	}

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

	static void _copy(Request& r, MethodParams& params) {
	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");

	String from_spec = r.absolute(vfrom_file_name.as_string());
	const String& to_spec = r.absolute(vto_file_name.as_string());

	file_write_action_under_lock(
	to_spec,
	"copy",
	copy_open_target,
	&from_spec);
	}

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,
Line 149 static void _load_pass_param(	Line 200 static void _load_pass_param(
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;
Line 158 static void _load(Request& r, MethodPara	Line 209 static void _load(Request& r, MethodPara
if(third_param_hash)	if(third_param_hash)
alt_filename_param_index++;	alt_filename_param_index++;

	HashStringValue* options=third_param_hash;
	size_t offset=0;
	size_t limit=0;
	if(options) {
	options=new HashStringValue(*options);
	if(Value voffset=(Value )options->get(sql_offset_name)) {
	offset=r.process_to_value(*voffset).as_int();
	}
	if(Value vlimit=(Value )options->get(sql_limit_name)) {
	limit=r.process_to_value(*vlimit).as_int();
	}
	// 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()),	is_text_mode(vmode_name.as_string()),
third_param_hash	options, true, 0, offset, limit
);	);

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, FILE_NAME_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;
if(file.headers)	if(file.headers){
{
if(Value* remote_content_type=file.headers->get("CONTENT-TYPE"))	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()));
}	}
Line 178 static void _load(Request& r, MethodPara	Line 241 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)
file.headers->for_each(_load_pass_param, &self.fields());	if(file.headers){
	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) {
	Value& vmode_name=params.as_no_junction(0, MODE_MUST_NOT_BE_CODE);
	if(!is_text_mode(vmode_name.as_string()))
	throw Exception(PARSER_RUNTIME,
	0,
	"only text mode is currently supported");

	const char* user_file_name_cstr=r.absolute(
	params.as_no_junction(1, FILE_NAME_MUST_NOT_BE_CODE).as_string()).cstr(String::L_FILE_SPEC);

	const String& content=params.as_string(2, "content must be string");
	const char* content_cstr=content.cstr(String::L_UNSPECIFIED); // explode content, honor tainting changes

	VString* vcontent_type=new VString(r.mime_type_of(user_file_name_cstr));

	VFile& self=GET_SELF(r, VFile);
	self.set(true/tainted/, content_cstr, strlen(content_cstr), user_file_name_cstr, vcontent_type);
}	}

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 193 static void _stat(Request& r, MethodPara	Line 288 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 220 static bool is_safe_env_key(const char*	Line 317 static bool is_safe_env_key(const char*
}	}
#ifndef DOXYGEN	#ifndef DOXYGEN
struct Append_env_pair_info {	struct Append_env_pair_info {
	Request_charsets* charsets;
HashStringString* env;	HashStringString* env;
Value* vstdin;	Value* vstdin;
Value* vcharset;
};	};
#endif	#endif
static void append_env_pair(	static void append_env_pair(
Line 232 static void append_env_pair(	Line 329 static void append_env_pair(
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) {
info->vcharset=avalue;	// 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(String::L_UNSPECIFIED));	info->env->put(akey, avalue->as_string().cstr_to_string_body(String::L_UNSPECIFIED, 0, info->charsets));
}	}
}	}
#ifndef DOXYGEN	#ifndef DOXYGEN
Line 252 static void pass_cgi_header_attribute(	Line 349 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()));	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=="CONTENT-TYPE")
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);
	}
	}

	inline size_t strpos(const char s1, const char s2) {
	const char *p = strstr(s1, s2);
	return (p==0)?STRING_NOT_FOUND:p-s1;
	}

/// @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 306 static void _exec_cgi(Request& r, Method	Line 431 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()) {
Append_env_pair_info info={&env, 0, 0};	// $.charset [previewing to handle URI pieces]
user_env->for_each(append_env_pair, &info);	if(Value* vcharset=user_env->get(CHARSET_EXEC_PARAM_NAME))
	charset=&charsets.get(vcharset->as_string()
	.change_case(r.charsets.source(), String::CC_UPPER));

	// $.others
	Append_env_pair_info info={&r.charsets, &env, 0};
	{
	// influence tainting
	// main target -- $.QUERY_STRING -- URLencoding of tainted pieces to String::L_URI lang
	Temp_client_charset temp(r.charsets, charset? *charset: r.charsets.source());
	user_env->for_each<Append_env_pair_info*>(append_env_pair, &info);
	}
// $.stdin	// $.stdin
if(info.vstdin) {	if(info.vstdin) {
stdin_specified=true;	stdin_specified=true;
Line 320 static void _exec_cgi(Request& r, Method	Line 456 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");
}	}
// $.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(param_index < params.count()) {
for(size_t i=2; i<params.count(); i++)	// influence tainting
argv+=&params.as_string(i, "parameter must be string");	// main target -- URLencoding of tainted pieces to String::L_URI lang
	Temp_client_charset temp(r.charsets, charset? *charset: r.charsets.source());

	for(size_t i=param_index; i<params.count(); i++) {
	Value& param=params.as_no_junction(i, PARAM_MUST_NOT_BE_CODE);
	if(param.is_defined()){
	if(param.is_string()){
	append_to_argv(r, argv, param.get_string());
	} else {
	Table* table=param.get_table();
	if(table){
	for(size_t i=0; i<table->count(); i++) {
	append_to_argv(r, argv, table->get(i)->get(0));
	}
	} else {
	throw Exception(PARSER_RUNTIME,
	0,
	"param must be string or table");
	}
	}
	}
	}
}	}

// transcode if necessary	// transcode if necessary
Line 349 static void _exec_cgi(Request& r, Method	Line 502 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(0,
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 516 static void lock_execute_body(int , void	Line 690 static void lock_execute_body(int , void
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) {
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={
&r,	&r,
&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 541 static int lastposafter(const String& s,	Line 719 static int lastposafter(const String& s,
}	}

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 549 static void _find(Request& r, MethodPara	Line 727 static void _find(Request& r, MethodPara
file_spec=&r.relative(r.request_info.uri, file_name);	file_spec=&r.relative(r.request_info.uri, file_name);

// easy way	// easy way
if(file_readable(r.absolute(*file_spec))) {	if(file_exist(r.absolute(*file_spec))) {
r.write_assign_lang(*file_spec);	r.write_assign_lang(*file_spec);
return;	return;
}	}
Line 564 static void _find(Request& r, MethodPara	Line 742 static void _find(Request& r, MethodPara
String test_name;	String test_name;
test_name<<*(dirname=&dirname->mid(0, after_monkey_slash));	test_name<<*(dirname=&dirname->mid(0, after_monkey_slash));
test_name<<basename;	test_name<<basename;
if(file_readable(r.absolute(test_name))) {	if(file_exist(r.absolute(test_name))) {
r.write_assign_lang(test_name);	r.write_assign_lang(test_name);
return;	return;
}	}
Line 578 static void _find(Request& r, MethodPara	Line 756 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);
Line 589 static void _dirname(Request& r, MethodP	Line 767 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)
Line 611 static void _justext(Request& r, MethodP	Line 789 static void _justext(Request& r, MethodP
}	}

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 644 class File_sql_event_handlers: public SQ	Line 822 class File_sql_event_handlers: public SQ
int got_cells;	int got_cells;
public:	public:
String::C value;	String::C value;
String* user_file_name;	const String* user_file_name;
String* user_content_type;	const String* user_content_type;
public:	public:
File_sql_event_handlers(	File_sql_event_handlers(
const String& astatement_string, const char* astatement_cstr):	const String& astatement_string, const char* astatement_cstr):
Line 657 public:	Line 835 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 671 public:	Line 849 public:
value=String::C(str, length);	value=String::C(str, length);
break;	break;
case 1:	case 1:
user_file_name=new String(str, length, true);	if(!user_file_name) // user not specified?
	user_file_name=new String(str, length, true);
break;	break;
case 2:	case 2:
user_content_type=new String(str, length, true);	if(!user_content_type) // user not specified?
	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 689 public:	Line 869 public:
};	};
#endif	#endif
static void _sql(Request& r, MethodParams& params) {	static void _sql(Request& r, MethodParams& params) {
const String* user_file_name=0;	Value& statement=params.as_junction(0, "statement must be code");
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);	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=	const char* statement_cstr=
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);

	if(params.count()>1)
	if(HashStringValue* options=
	params.as_no_junction(1, PARAM_MUST_NOT_BE_CODE).get_hash()) {
	int valid_options=0;
	if(Value* vfilename=options->get(NAME_NAME)) {
	valid_options++;
	handlers.user_file_name=&vfilename->as_string();
	}
	if(Value* vcontent_type=options->get(CONTENT_TYPE_NAME)) {
	valid_options++;
	handlers.user_content_type=&vcontent_type->as_string();
	}
	if(valid_options!=options->count())
	throw Exception(PARSER_RUNTIME,
	0,
	"called with invalid option");
	}


r.connection()->query(	r.connection()->query(
statement_cstr,	statement_cstr,
0, 0,	0, 0,
Line 708 static void _sql(Request& r, MethodParam	Line 904 static void _sql(Request& r, MethodParam
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");

if(!user_file_name)	const char* user_file_name_cstr=handlers.user_file_name? handlers.user_file_name->cstr(): 0;
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?	VString* vcontent_type=handlers.user_content_type?
new VString(*handlers.user_content_type)	new VString(*handlers.user_content_type)
Line 726 static void _sql(Request& r, MethodParam	Line 919 static void _sql(Request& r, MethodParam
self.set(true/tainted/, handlers.value.str, handlers.value.length, user_file_name_cstr, vcontent_type);	self.set(true/tainted/, handlers.value.str, handlers.value.length, user_file_name_cstr, vcontent_type);
}	}

	static void _base64(Request& r, MethodParams& params) {
	bool dynamic = !(&r.get_self() == file_class);
	if ( dynamic ){
	VFile& self=GET_SELF(r, VFile);
	if(params.count()) {
	// decode
	const char* cstr=params.as_string(0, PARAMETER_MUST_BE_STRING).cstr();
	char* decoded_cstr=0;
	size_t decoded_size=0;
	pa_base64_decode(cstr, strlen(cstr), decoded_cstr, decoded_size);
	if(decoded_cstr && decoded_size)
	self.set(true/tainted/, decoded_cstr, decoded_size);
	} else {
	// encode
	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*/));
	}
	} else {
	// encode
	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
	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*/));
	}
	}

	static void _crc32(Request& r, MethodParams& params) {
	unsigned long crc32 = 0;
	if(&r.get_self() == file_class) {
	// ^file:crc32[file-name]
	if(params.count()) {
	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
	crc32=pa_crc32(r.absolute(file_spec));
	} else {
	throw Exception(PARSER_RUNTIME,
	0,
	"file name must be defined");
	}
	} else {
	// ^file.crc32[]
	VFile& self=GET_SELF(r, VFile);
	crc32=pa_crc32(self.value_ptr(), self.value_size());
	}
	r.write_no_lang(*new VInt(crc32));
	}


	static void file_md5_file_action(
	struct stat& finfo,
	int f,
	const String& , const char* /fname/, bool,
	void *context)
	{
	PA_MD5_CTX& md5context=static_cast<PA_MD5_CTX >(context);
	if(finfo.st_size) {
	int nCount=0;
	do {
	unsigned char buffer[FILE_BUFFER_SIZE];
	nCount = file_block_read(f, buffer, sizeof(buffer));
	if ( nCount ){
	pa_MD5Update(&md5context, (const unsigned char*)buffer, nCount);
	}
	} while(nCount > 0);
	}
	}

	const char* pa_md5(const String& file_spec)
	{
	PA_MD5_CTX context;
	unsigned char digest[16];
	pa_MD5Init(&context);
	file_read_action_under_lock(file_spec, "md5", file_md5_file_action, &context);
	pa_MD5Final(digest, &context);

	return hex_string(digest, sizeof(digest), false);
	}

	const char* pa_md5(const char *in, size_t in_size)
	{
	PA_MD5_CTX context;
	unsigned char digest[16];
	pa_MD5Init(&context);
	pa_MD5Update(&context, (const unsigned char*)in, in_size);
	pa_MD5Final(digest, &context);

	return hex_string(digest, sizeof(digest), false);
	}

	static void _md5(Request& r, MethodParams& params) {
	const char* md5;
	if(&r.get_self() == file_class) {
	// ^file:md5[file-name]
	if(params.count()) {
	const String& file_spec=params.as_string(0, FILE_NAME_MUST_BE_STRING);
	md5=pa_md5(r.absolute(file_spec));
	} else {
	throw Exception(PARSER_RUNTIME,
	0,
	"file name must be defined");
	}
	} else {
	// ^file.md5[]
	VFile& self=GET_SELF(r, VFile);
	md5=pa_md5(self.value_ptr(), self.value_size());

	}
	r.write_no_lang(*new String(md5));
	}

// constructor	// constructor

MFile::MFile(): Methoded("file") {	MFile::MFile(): Methoded("file") {
// ^save[mode;file-name]	// ^file::create[text;user-name;string]
	// ^file::create[binary;user-name;SOMEDAY SOMETHING]
	add_native_method("create", Method::CT_DYNAMIC, _create, 3, 3);

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

// ^delete[file-name]	// ^file:delete[file-name]
add_native_method("delete", Method::CT_STATIC, _delete, 1, 1);	add_native_method("delete", Method::CT_STATIC, _delete, 1, 1);

// ^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);	add_native_method("move", Method::CT_STATIC, _move, 2, 2);

// ^load[mode;disk-name]	// ^file::load[mode;disk-name]
// ^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, 3);

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

// ^cgi[file-name]	// ^file::cgi[mode;file-name]
// ^cgi[file-name;env hash]	// ^file::cgi[mode;file-name;env hash]
// ^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+10);	add_native_method("cgi", Method::CT_DYNAMIC, _cgi, 1, 3+50);

// ^exec[file-name]	// ^file::exec[mode;file-name]
// ^exec[file-name;env hash]	// ^file::exec[mode;file-name;env hash]
// ^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+10);	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]
Line 762 MFile::MFile(): Methoded("file") {	Line 1067 MFile::MFile(): Methoded("file") {
// ^file:lock[path]{code}	// ^file:lock[path]{code}
add_native_method("lock", Method::CT_STATIC, _lock, 2, 2);	add_native_method("lock", Method::CT_STATIC, _lock, 2, 2);

// ^find[file-name]	// ^file:find[file-name]
// ^find[file-name]{when-not-found}	// ^file:find[file-name]{when-not-found}
add_native_method("find", Method::CT_STATIC, _find, 1, 2);	add_native_method("find", Method::CT_STATIC, _find, 1, 2);

// ^file:dirname[/a/some.tar.gz]=/a	// ^file:dirname[/a/some.tar.gz]=/a
Line 783 MFile::MFile(): Methoded("file") {	Line 1088 MFile::MFile(): Methoded("file") {

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

	// ^file::base64[string] << decode
	// ^file.base64[] << encode
	// ^file:base64[file-name] << encode
	add_native_method("base64", Method::CT_ANY, _base64, 0, 1);

	// ^file.crc32[]
	// ^file:crc32[file-name]
	add_native_method("crc32", Method::CT_ANY, _crc32, 0, 1);

	// ^file.md5[]
	// ^file:md5[file-name]
	add_native_method("md5", Method::CT_ANY, _md5, 0, 1);

	// ^file:copy[from-file-name;to-file-name]
	add_native_method("copy", Method::CT_STATIC, _copy, 2, 2);
}	}

E-mail:

Removed from v.1.129
changed lines
	Added in v.1.169