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.51 and 1.87

version 1.51, 2001/08/28 09:39:30	version 1.87, 2002/06/18 14:22:45
Line 1	Line 1
/** @file	/** @file
Parser: @b file parser class.	Parser: @b file parser class.

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

$Id$	$Id$
*/	*/
static const char *RCSId="$Id$";

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

Line 22 static const char *RCSId="$Id$";	Line 20 static const char *RCSId="$Id$";
#include "pa_vdate.h"	#include "pa_vdate.h"
#include "pa_dir.h"	#include "pa_dir.h"
#include "pa_vtable.h"	#include "pa_vtable.h"
	#include "pa_charset.h"
// consts

// defines	// defines

#define FILE_CLASS_NAME "file"

#define TEXT_MODE_NAME "text"	#define TEXT_MODE_NAME "text"

	// consts

	/// from apache-1.3\|src\|support\|suexec.c
	static const char *suexec_safe_env_lst[]={
	"AUTH_TYPE",
	"CONTENT_LENGTH",
	"CONTENT_TYPE",
	"DATE_GMT",
	"DATE_LOCAL",
	"DOCUMENT_NAME",
	"DOCUMENT_PATH_INFO",
	"DOCUMENT_ROOT",
	"DOCUMENT_URI",
	"FILEPATH_INFO",
	"GATEWAY_INTERFACE",
	"LAST_MODIFIED",
	"PATH_INFO",
	"PATH_TRANSLATED",
	"QUERY_STRING",
	"QUERY_STRING_UNESCAPED",
	"REMOTE_ADDR",
	"REMOTE_HOST",
	"REMOTE_IDENT",
	"REMOTE_PORT",
	"REMOTE_USER",
	"REDIRECT_QUERY_STRING",
	"REDIRECT_STATUS",
	"REDIRECT_URL",
	"REQUEST_METHOD",
	"REQUEST_URI",
	"SCRIPT_FILENAME",
	"SCRIPT_NAME",
	"SCRIPT_URI",
	"SCRIPT_URL",
	"SERVER_ADMIN",
	"SERVER_NAME",
	"SERVER_ADDR",
	"SERVER_PORT",
	"SERVER_PROTOCOL",
	"SERVER_SOFTWARE",
	"UNIQUE_ID",
	"USER_NAME",
	"TZ",
	NULL
	};

// class	// class

class MFile : public Methoded {	class MFile : public Methoded {
Line 62 static void _save(Request& r, const Stri	Line 103 static void _save(Request& r, const Stri
}	}

static void _delete(Request& r, const String&, MethodParams *params) {	static void _delete(Request& r, const String&, MethodParams *params) {
Pool& pool=r.pool();
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(pool, r.absolute(vfile_name.as_string()));	file_delete(r.absolute(vfile_name.as_string()));
}	}

static void _move(Request& r, const String&, MethodParams *params) {	static void _move(Request& r, const String&, MethodParams *params) {
Pool& pool=r.pool();
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(pool,	file_move(
r.absolute(vfrom_file_name.as_string()),	r.absolute(vfrom_file_name.as_string()),
r.absolute(vto_file_name.as_string()));	r.absolute(vto_file_name.as_string()));
}	}
Line 88 static void _find(Request& r, const Stri	Line 127 static void _find(Request& r, const Stri

// passed file name simply exists in current dir	// passed file name simply exists in current dir
if(file_readable(r.absolute(lfile_name))) {	if(file_readable(r.absolute(lfile_name))) {
r.write_no_lang(*new(pool) VString(lfile_name));	r.write_no_lang(lfile_name);
return;	return;
}	}

// scan .. dirs for result	// scan .. dirs for result
for(int i=0; i<FIND_MONKEY_MAX_HOPS; i++) {	for(int i=0; i<FIND_MONKEY_MAX_HOPS; i++) {
String test_name(pool);	String local_test_name(pool);
for(int j=0; j<i; j++)	for(int j=0; j<i; j++)
test_name.APPEND_CONST("../");	local_test_name.APPEND_CONST("../");
test_name.append(lfile_name, String::UL_CLEAN);	local_test_name.append(lfile_name, String::UL_CLEAN);
if(file_readable(r.absolute(test_name))) {	if(file_readable(r.absolute(local_test_name))) {
r.write_no_lang(new(pool) VString(new(pool) String(test_name)));	r.write_no_lang(*new(pool) String(local_test_name));
return;	return;
}	}
}	}
Line 122 static void _load(Request& r, const Stri	Line 161 static void _load(Request& r, const Stri
file_read(pool, r.absolute(lfile_name), data, size,	file_read(pool, r.absolute(lfile_name), data, size,
vmode_name.as_string()==TEXT_MODE_NAME);	vmode_name.as_string()==TEXT_MODE_NAME);

char *user_file_name=params->size()>2?params->get(2).as_string().cstr()	char *user_file_name=params->size()>2?
:lfile_name.cstr(String::UL_FILE_NAME);	params->as_string(2, "filename must be string").cstr(String::UL_FILE_SPEC)
	:lfile_name.cstr(String::UL_FILE_SPEC);

static_cast<VFile >(r.self)->set(true/tainted*/, data, size,	static_cast<VFile >(r.self)->set(true/tainted*/, data, size,
user_file_name, &r.mime_type_of(user_file_name));	user_file_name, new(pool) VString(r.mime_type_of(user_file_name)));
}	}

static void _stat(Request& r, const String& method_name, MethodParams *params) {	static void _stat(Request& r, const String& method_name, MethodParams *params) {
Line 149 static void _stat(Request& r, const Stri	Line 189 static void _stat(Request& r, const Stri
ff.put(*new(pool) String(pool, "cdate"), new(pool) VDate(pool, ctime));	ff.put(*new(pool) String(pool, "cdate"), new(pool) VDate(pool, ctime));
}	}

	static bool is_safe_env_key(const char *key) {
	if(strnicmp(key, "HTTP_", 5)==0)
	return true;
	if(strncasecmp(key, "CGI_", 4)==0)
	return true;
	for(int i=0; suexec_safe_env_lst[i]; i++) {
	if(strcasecmp(key, suexec_safe_env_lst[i])==0)
	return true;
	}
	return false;
	}
static void append_env_pair(const Hash::Key& key, Hash::Val value, void info) {	static void append_env_pair(const Hash::Key& key, Hash::Val value, void info) {
Hash& hash=static_cast<Hash >(info);	Hash& hash=static_cast<Hash >(info);
	if(!is_safe_env_key(key.cstr()))
	throw Exception("parser.runtime",
	&key,
	"not safe environment variable");
hash.put(key, &static_cast<Value *>(value)->as_string());	hash.put(key, &static_cast<Value *>(value)->as_string());
}	}

static void pass_cgi_header_attribute(Array::Item value, void info) {	static void pass_cgi_header_attribute(Array::Item value, void info) {
String& string=static_cast<String >(value);	String& string=static_cast<String >(value);
Hash& hash=static_cast<Hash >(info);	Hash& hash=static_cast<Hash >(info);
Line 162 static void pass_cgi_header_attribute(Ar	Line 216 static void pass_cgi_header_attribute(Ar
hash.put(string.mid(0, colon_pos),	hash.put(string.mid(0, colon_pos),
new(string.pool()) VString(string.mid(colon_pos+1, string.size())));	new(string.pool()) VString(string.mid(colon_pos+1, string.size())));
}	}
/// @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, const String& method_name, MethodParams *params,	static void _exec_cgi(Request& r, const String& method_name, MethodParams *params,
bool cgi) {	bool cgi) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Line 172 static void _exec_cgi(Request& r, const	Line 227 static void _exec_cgi(Request& r, const
const String& script_name=r.absolute(vfile_name.as_string());	const String& script_name=r.absolute(vfile_name.as_string());

Hash env(pool);	Hash env(pool);
#define PASS(key) \	#define ECSTR(name, value_cstr) \
String key(pool); \	String name##key(pool, #name); \
if(const char *value=SAPI::get_env(pool, #key)) { \	String name##value(pool); \
key.APPEND_CONST(value); \	if(value_cstr) { \
env.put(String(pool, #key), &key); \	name##value.APPEND_CONST(value_cstr); \
}	env.put(name##key, &name##value); \
#define INFO(key, value) \
String value(pool); \
if(r.info.value) { \
value.APPEND_CONST(r.info.value); \
env.put(String(pool, key), &value); \
}	}
	// passing SAPI::environment
	if(const char const pairs=SAPI::environment(pool)) {
	while(const char pair=pairs++)
	if(const char *eq_at=strchr(pair, '=')) {
	String& key=*new(pool) String(pool, pair, eq_at-pair);
	String& value=*new(pool) String(pool, eq_at+1);
	env.put(key, &value);
	}
	}

// const	// const
String gateway_interface(pool, "CGI/1.1");	ECSTR(GATEWAY_INTERFACE, "CGI/1.1");
env.put(String(pool, "GATEWAY_INTERFACE"), &gateway_interface);
// from Request.info	// from Request.info
INFO("DOCUMENT_ROOT", document_root);	ECSTR(DOCUMENT_ROOT, r.info.document_root);
INFO("PATH_TRANSLATED", path_translated);	ECSTR(PATH_TRANSLATED, r.info.path_translated);
INFO("SERVER_PROTOCOL", method);	ECSTR(REQUEST_METHOD, r.info.method);
INFO("QUERY_STRING", query_string);	ECSTR(QUERY_STRING, r.info.query_string);
INFO("REQUEST_URI", uri);	ECSTR(REQUEST_URI, r.info.uri);
INFO("CONTENT_TYPE", content_type);	ECSTR(CONTENT_TYPE, r.info.content_type);
char content_length_cstr[MAX_NUMBER];	char content_length_cstr[MAX_NUMBER];
snprintf(content_length_cstr, MAX_NUMBER, "%u", r.info.content_length);	snprintf(content_length_cstr, MAX_NUMBER, "%u", r.info.content_length);
String content_length(pool, content_length_cstr);	String content_length(pool, content_length_cstr);
env.put(String(pool, "CONTENT_LENGTH"), &content_length);	ECSTR(CONTENT_LENGTH, content_length_cstr);
INFO("HTTP_COOKIE", cookie);	// SCRIPT_*
INFO("HTTP_USER_AGENT", user_agent);	env.put(*new(pool) String(pool, "SCRIPT_NAME"), &script_name);
// passing some SAPI:get_env-s	//env.put(*new(pool) String(pool, "SCRIPT_FILENAME"), ??&script_name);
PASS(SERVER_NAME);
PASS(SERVER_PORT);
PASS(HTTP_REFERER);
PASS(REMOTE_ADDR);
PASS(REMOTE_HOST);
PASS(REMOTE_USER);
// SCRIPT_NAME
env.put(String(pool, "SCRIPT_NAME"), &script_name);
#ifdef WIN32
// WIN32 shell
PASS(COMSPEC);
#endif

if(params->size()>1) {	if(params->size()>1) {
Value& venv=params->as_no_junction(1, "env must not be code");	Value& venv=params->as_no_junction(1, "env must not be code");
if(Hash *user_env=venv.get_hash())	if(Hash *user_env=venv.get_hash(&method_name))
user_env->for_each(append_env_pair, &env);	user_env->for_each(append_env_pair, &env);
}	}

Line 225 static void _exec_cgi(Request& r, const	Line 271 static void _exec_cgi(Request& r, const
if(params->size()>2) {	if(params->size()>2) {
argv=new(pool) Array(pool, params->size()-2);	argv=new(pool) Array(pool, params->size()-2);
for(int i=2; i<params->size(); i++)	for(int i=2; i<params->size(); i++)
*argv+=&params->get(i).as_string();	*argv+=&params->as_string(i, "parameter must be string");
}	}

const String in(pool, r.post_data, r.post_size);	String in(pool);
	in.APPEND(r.post_data, r.post_size, String::UL_CLEAN, "passing post data", 0);
String out(pool);	String out(pool);
//out.APPEND_CONST("content-type:text/plain\nheader:test-header\n\ntest-body");	//out.APPEND_CONST("content-type:text/plain\nheader:test-header\n\ntest-body");
//out<<in;	//out<<in;
String& err=*new(pool) String(pool);	String& err=*new(pool) String(pool);
int status=pa_exec(script_name, &env, argv, in, out, err);	int status=pa_exec(false/forced_allow/, script_name, &env, argv, in, out, err);

VFile& self=static_cast<VFile >(r.self);	VFile& self=static_cast<VFile >(r.self);

Line 249 static void _exec_cgi(Request& r, const	Line 296 static void _exec_cgi(Request& r, const
}	}
if(pos<0) {	if(pos<0) {
delim_size=0; // calm down, compiler	delim_size=0; // calm down, compiler
PTHROW(0, 0,	throw Exception(0,
&method_name,	&method_name,
"output does not contain CGI header; exit code=%d; outsize=%u; out: \"%s\"; errsize=%u; err: \"%s\"",	"output does not contain CGI header; exit status=%d; stdoutsize=%u; stdout: \"%s\"; stderrsize=%u; stderr: \"%s\"",
status,	status,
(uint)out.size(), out.cstr(),	(uint)out.size(), out.cstr(),
(uint)err.size(), err.cstr());	(uint)err.size(), err.cstr());
Line 268 static void _exec_cgi(Request& r, const	Line 315 static void _exec_cgi(Request& r, const
}	}
}	}
// body	// body
self.set(false/not tainted/, body->cstr(String::UL_AS_IS), body->size());	self.set(false/not tainted/, body->cstr(), body->size());

// $status	// $status
self.fields().put(	self.fields().put(
Line 298 static void _list(Request& r, const Stri	Line 345 static void _list(Request& r, const Stri

const String *regexp;	const String *regexp;
pcre *regexp_code;	pcre *regexp_code;
int ovecsize;	const int ovecsize=(1/match/)*3;
int *ovector;	int ovector[ovecsize];
if(params->size()>1) {	if(params->size()>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(String::UL_AS_IS);	const char *pattern=regexp->cstr();
const char *errptr;	const char *errptr;
int erroffset;	int erroffset;
regexp_code=pcre_compile(pattern, PCRE_EXTRA \| PCRE_DOTALL,	regexp_code=pcre_compile(pattern, PCRE_EXTRA \| PCRE_DOTALL,
&errptr, &erroffset,	&errptr, &erroffset,
r.pcre_tables);	pool.get_client_charset().pcre_tables);

if(!regexp_code)	if(!regexp_code)
PTHROW(0, 0,	throw Exception(0,
&regexp->mid(erroffset, regexp->size()),	&regexp->mid(erroffset, regexp->size()),
"regular expression syntax error - %s", errptr);	"regular expression syntax error - %s", errptr);

ovector=(int )pool.malloc(sizeof(int)(ovecsize=(1/match/)*3));
} else	} else
regexp_code=0;	regexp_code=0;


const char* absolute_path_cstr=r.absolute(relative_path.as_string())	const char* absolute_path_cstr=r.absolute(relative_path.as_string())
.cstr(String::UL_FILE_NAME);	.cstr(String::UL_FILE_SPEC);

Array& columns=*new(pool) Array(pool);	Array& columns=*new(pool) Array(pool);
columns+=new(pool) String(pool, "name");	columns+=new(pool) String(pool, "name");
Line 339 static void _list(Request& r, const Stri	Line 384 static void _list(Request& r, const Stri
suits=false;	suits=false;
else if(exec_result<0) {	else if(exec_result<0) {
(*pcre_free)(regexp_code);	(*pcre_free)(regexp_code);
PTHROW(0, 0,	throw Exception(0,
regexp,	regexp,
"regular expression execute (%d)",	"regular expression execute (%d)",
exec_result);	exec_result);
Line 350 static void _list(Request& r, const Stri	Line 395 static void _list(Request& r, const Stri
char file_name_cstr=(char )pool.malloc(file_name_size);	char file_name_cstr=(char )pool.malloc(file_name_size);
memcpy(file_name_cstr, ffblk.ff_name, file_name_size);	memcpy(file_name_cstr, ffblk.ff_name, file_name_size);
String &file_name=*new(pool) String(pool);	String &file_name=*new(pool) String(pool);
file_name.APPEND(file_name_cstr, file_name_size, String::UL_FILE_NAME,	file_name.APPEND(file_name_cstr, file_name_size, String::UL_FILE_SPEC,
method_name.origin().file, method_name.origin().line);	method_name.origin().file, method_name.origin().line);

Array& row=*new(pool) Array(pool);	Array& row=*new(pool) Array(pool);
Line 362 static void _list(Request& r, const Stri	Line 407 static void _list(Request& r, const Stri
if(regexp_code)	if(regexp_code)
(*pcre_free)(regexp_code);	(*pcre_free)(regexp_code);

	// write out result
VTable& result=*new(pool) VTable(pool, &table);	VTable& result=*new(pool) VTable(pool, &table);
result.set_name(method_name);
r.write_no_lang(result);	r.write_no_lang(result);
}	}

// constructor	#ifndef DOXYGEN
	struct Lock_execute_body_info {
	Request *r;
	Value *body_code;
	};
	#endif
	static void lock_execute_body(int , void *context) {
	Lock_execute_body_info& info=static_cast<Lock_execute_body_info >(context);

	// execute body
	info.r->write_assign_lang(info.r->process(*info.body_code));
	};
	static void _lock(Request& r, const String& method_name, MethodParams *params) {
	const String& file_spec=r.absolute(params->as_string(0, "file name must be string"));
	Value& body_code=params->as_junction(1, "body must be code");

MFile::MFile(Pool& apool) : Methoded(apool) {	Lock_execute_body_info info={&r, &body_code};
set_name(*NEW String(pool(), FILE_CLASS_NAME));	file_write_action_under_lock(file_spec, "lock", lock_execute_body, &info);
	}

	// constructor

	MFile::MFile(Pool& apool) : Methoded(apool, "file") {
// ^save[mode;file-name]	// ^save[mode;file-name]
add_native_method("save", Method::CT_DYNAMIC, _save, 2, 2);	add_native_method("save", Method::CT_DYNAMIC, _save, 2, 2);

Line 407 MFile::MFile(Pool& apool) : Methoded(apo	Line 469 MFile::MFile(Pool& apool) : Methoded(apo
// ^file:list[path][regexp]	// ^file:list[path][regexp]
add_native_method("list", Method::CT_STATIC, _list, 1, 2);	add_native_method("list", Method::CT_STATIC, _list, 1, 2);

	// ^file:lock[path]{code}
	add_native_method("lock", Method::CT_STATIC, _lock, 2, 2);

}	}

// global variable	// global variable

E-mail:

Removed from v.1.51
changed lines
	Added in v.1.87