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.44 and 1.57

version 1.44, 2001/07/20 09:40:46	version 1.57, 2001/10/08 14:09:18
Line 2	Line 2
Parser: @b file parser class.	Parser: @b file parser class.

Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)

Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)

$Id$	$Id$
*/	*/
static const char *RCSId="$Id$";
	#include "pa_config_includes.h"

	#include "pcre.h"

#include "classes.h"	#include "classes.h"
#include "pa_request.h"	#include "pa_request.h"
Line 16 static const char *RCSId="$Id$";	Line 18 static const char *RCSId="$Id$";
#include "pa_vint.h"	#include "pa_vint.h"
#include "pa_exec.h"	#include "pa_exec.h"
#include "pa_vdate.h"	#include "pa_vdate.h"
	#include "pa_dir.h"
	#include "pa_vtable.h"

// consts	// consts

Line 23 static const char *RCSId="$Id$";	Line 27 static const char *RCSId="$Id$";

#define FILE_CLASS_NAME "file"	#define FILE_CLASS_NAME "file"

	#define TEXT_MODE_NAME "text"

// class	// class

class MFile : public Methoded {	class MFile : public Methoded {
Line 45 const int FIND_MONKEY_MAX_HOPS=10;	Line 51 const int FIND_MONKEY_MAX_HOPS=10;
// methods	// methods

static void _save(Request& r, const String&, MethodParams *params) {	static void _save(Request& r, const String&, MethodParams *params) {
Value& vfile_name=params->as_no_junction(0, "file name 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");

// save	// save
static_cast<VFile *>(r.self)->save(r.absolute(vfile_name.as_string()));	static_cast<VFile *>(r.self)->save(r.absolute(vfile_name.as_string()),
	vmode_name.as_string()==TEXT_MODE_NAME);
}	}

static void _delete(Request& r, const String&, MethodParams *params) {	static void _delete(Request& r, const String&, MethodParams *params) {
Line 59 static void _delete(Request& r, const St	Line 67 static void _delete(Request& r, const St
file_delete(pool, r.absolute(vfile_name.as_string()));	file_delete(pool, r.absolute(vfile_name.as_string()));
}	}

	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& vto_file_name=params->as_no_junction(1, "to file name must not be code");

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

static void _find(Request& r, const String& method_name, MethodParams *params) {	static void _find(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	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");
Line 92 static void _find(Request& r, const Stri	Line 111 static void _find(Request& r, const Stri

static void _load(Request& r, const String& method_name, MethodParams *params) {	static void _load(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Value& vfile_name=params->as_no_junction(0, "file name 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");

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

void *data; size_t size;	void *data; size_t size;
file_read(pool, r.absolute(lfile_name), data, size, false/binary/);	file_read(pool, r.absolute(lfile_name), data, size,
	vmode_name.as_string()==TEXT_MODE_NAME);

char *user_file_name=params->size()==1?lfile_name.cstr(String::UL_FILE_NAME)	char *user_file_name=params->size()>2?params->get(2).as_string().cstr()
:params->get(1).as_string().cstr();	: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 205 static void _exec_cgi(Request& r, const	Line 226 static void _exec_cgi(Request& r, const
*argv+=&params->get(i).as_string();	*argv+=&params->get(i).as_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;
Line 228 static void _exec_cgi(Request& r, const	Line 250 static void _exec_cgi(Request& r, const
delim_size=0; // calm down, compiler	delim_size=0; // calm down, compiler
PTHROW(0, 0,	PTHROW(0, 0,
&method_name,	&method_name,
"output does not contain CGI header; exit code=%d; size=%u; text: \"%s\"",	"output does not contain CGI header; exit code=%d; outsize=%u; out: \"%s\"; errsize=%u; err: \"%s\"",
status, (uint)out.size(), out.cstr());	status,
	(uint)out.size(), out.cstr(),
	(uint)err.size(), err.cstr());
}	}

const String& header=out.mid(0, pos);	const String& header=out.mid(0, pos);
Line 266 static void _cgi(Request& r, const Strin	Line 290 static void _cgi(Request& r, const Strin
_exec_cgi(r, method_name, params, true);	_exec_cgi(r, method_name, params, true);
}	}

	static void _list(Request& r, const String& method_name, MethodParams *params) {
	Pool& pool=r.pool();

	Value& relative_path=params->as_no_junction(0, "path must not be code");

	const String *regexp;
	pcre *regexp_code;
	int ovecsize;
	int *ovector;
	if(params->size()>1) {
	regexp=&params->as_no_junction(1, "regexp must not be code").as_string();

	const char *pattern=regexp->cstr(String::UL_AS_IS);
	const char *errptr;
	int erroffset;
	regexp_code=pcre_compile(pattern, PCRE_EXTRA \| PCRE_DOTALL,
	&errptr, &erroffset,
	r.pcre_tables());

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

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


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

	Array& columns=*new(pool) Array(pool);
	columns+=new(pool) String(pool, "name");
	Table& table=*new(pool) Table(pool, &method_name, &columns);

	LOAD_DIR(absolute_path_cstr,
	size_t file_name_size=strlen(ffblk.ff_name);
	bool suits=true;
	if(regexp_code) {
	int exec_result=pcre_exec(regexp_code, 0,
	ffblk.ff_name, file_name_size, 0,
	0, ovector, ovecsize);

	if(exec_result==PCRE_ERROR_NOMATCH)
	suits=false;
	else if(exec_result<0) {
	(*pcre_free)(regexp_code);
	PTHROW(0, 0,
	regexp,
	"regular expression execute (%d)",
	exec_result);
	}
	}

	if(suits) {
	char file_name_cstr=(char )pool.malloc(file_name_size);
	memcpy(file_name_cstr, ffblk.ff_name, file_name_size);
	String &file_name=*new(pool) String(pool);
	file_name.APPEND(file_name_cstr, file_name_size, String::UL_FILE_SPEC,
	method_name.origin().file, method_name.origin().line);

	Array& row=*new(pool) Array(pool);
	row+=&file_name;
	table+=&row;
	}
	);

	if(regexp_code)
	(*pcre_free)(regexp_code);

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

// constructor	// constructor

Line 273 MFile::MFile(Pool& apool) : Methoded(apo	Line 372 MFile::MFile(Pool& apool) : Methoded(apo
set_name(*NEW String(pool(), FILE_CLASS_NAME));	set_name(*NEW String(pool(), FILE_CLASS_NAME));


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

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

// ^find[file-name]	// ^find[file-name]
// ^find[file-name]{when-not-found}	// ^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);

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

// ^stat[disk-name]	// ^stat[disk-name]
add_native_method("stat", Method::CT_DYNAMIC, _stat, 1, 1);	add_native_method("stat", Method::CT_DYNAMIC, _stat, 1, 1);
Line 299 MFile::MFile(Pool& apool) : Methoded(apo	Line 401 MFile::MFile(Pool& apool) : Methoded(apo
// ^exec[file-name;env hash]	// ^exec[file-name;env hash]
// ^exec[file-name;env hash;1cmd;2line;3ar;4g;5s]	// ^exec[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, 2+10);

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

}	}

// global variable	// global variable

E-mail:

Removed from v.1.44
changed lines
	Added in v.1.57