yarv-diff:270
From: ko1 atdot.net
Date: 16 Feb 2006 17:32:10 -0000
Subject: [yarv-diff:270] r433 - in trunk: . ext/win32ole yarvtest
Author: ko1
Date: 2006-02-17 02:32:10 +0900 (Fri, 17 Feb 2006)
New Revision: 433
Modified:
trunk/
trunk/ChangeLog
trunk/eval.c
trunk/eval_jump.h
trunk/eval_load.c
trunk/eval_method.h
trunk/eval_proc.c
trunk/eval_safe.h
trunk/eval_thread.c
trunk/ext/win32ole/win32ole.c
trunk/gc.c
trunk/ruby.h
trunk/signal.c
trunk/test.rb
trunk/thread.c
trunk/variable.c
trunk/vm.c
trunk/yarvtest/test_proc.rb
Log:
r656@lermite: ko1 | 2006-02-17 02:31:40 +0900
* eval_safe.h, ruby.h : remove ruby_safe_level and add
rb_safe_level() and rb_set_safe_level_force()
* eval.c : use above functions
* eval_jump.h : ditto
* eval_load.c : ditto
* eval_method.h : ditto
* eval_proc.c : ditto
* eval_thread.c : ditto
* gc.c : ditto
* signal.c : ditto
* variable.c : ditto
* ext/win32ole/win32ole.c : ditto
* vm.c (th_invoke_proc) : save and restore safe level
* yarvtest/test_proc.rb : add tests for above
* thread.c : remove unused functions
Property changes on: trunk
___________________________________________________________________
Name: svk:merge
- 81cd9672-7512-7e48-ae48-6936450e977d:/local/yarv/trunk:654
+ 81cd9672-7512-7e48-ae48-6936450e977d:/local/yarv/trunk:656
Modified: trunk/ChangeLog
===================================================================
--- trunk/ChangeLog 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/ChangeLog 2006-02-16 17:32:10 UTC (rev 433)
@@ -4,6 +4,39 @@
# from Mon, 03 May 2004 01:24:19 +0900
#
+2006-02-17(Fri) 02:20:32 +0900 Koichi Sasada <ko1 atdot.net>
+
+ * eval_safe.h, ruby.h : remove ruby_safe_level and add
+ rb_safe_level() and rb_set_safe_level_force()
+
+ * eval.c : use above functions
+
+ * eval_jump.h : ditto
+
+ * eval_load.c : ditto
+
+ * eval_method.h : ditto
+
+ * eval_proc.c : ditto
+
+ * eval_thread.c : ditto
+
+ * gc.c : ditto
+
+ * signal.c : ditto
+
+ * variable.c : ditto
+
+ * ext/win32ole/win32ole.c : ditto
+
+ * vm.c (th_invoke_proc) : save and restore safe level
+
+ * yarvtest/test_proc.rb : add tests for above
+
+ * thread.c : remove unused functions
+
+
+
2006-02-17(Fri) 01:08:23 +0900 Koichi Sasada <ko1 atdot.net>
* compile.c, insns.def : remove a setspecial second unused operand
Modified: trunk/eval.c
===================================================================
--- trunk/eval.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/eval.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -223,7 +223,7 @@
vm->exit_code = 0;
}
- ruby_safe_level = 0;
+ GET_THREAD()->safe_level = 0;
Init_stack((void *)&state);
PUSH_THREAD_TAG();
if ((state = EXEC_TAG()) == 0) {
@@ -346,29 +346,30 @@
}
VALUE
-rb_eval_cmd(cmd, arg, level)
- VALUE cmd, arg;
- int level;
+rb_eval_cmd(VALUE cmd, VALUE arg, int level)
{
int state;
VALUE val = Qnil; /* OK */
- volatile int safe = ruby_safe_level;
+ volatile int safe = rb_safe_level();
if (OBJ_TAINTED(cmd)) {
level = 4;
}
if (TYPE(cmd) != T_STRING) {
+
PUSH_TAG(PROT_NONE);
- ruby_safe_level = level;
+ rb_set_safe_level_force(level);
if ((state = EXEC_TAG()) == 0) {
val =
- rb_funcall2(cmd, rb_intern("call"), RARRAY(arg)->len,
- RARRAY(arg)->ptr);
+ rb_funcall2(cmd, rb_intern("call"), RARRAY(arg)->len,
+ RARRAY(arg)->ptr);
}
- ruby_safe_level = safe;
POP_TAG();
+
+ rb_set_safe_level_force(safe);
+
if (state)
- JUMP_TAG(state);
+ JUMP_TAG(state);
return val;
}
@@ -376,9 +377,9 @@
if ((state = EXEC_TAG()) == 0) {
val = eval(ruby_top_self, cmd, Qnil, 0, 0);
}
- ruby_safe_level = safe;
POP_TAG();
+ rb_set_safe_level_force(safe);
th_jump_tag_but_local_jump(state, val);
return val;
}
@@ -2057,7 +2058,7 @@
int line = 1;
rb_scan_args(argc, argv, "13", &src, &scope, &vfile, &vline);
- if (ruby_safe_level >= 4) {
+ if (rb_safe_level() >= 4) {
StringValue(src);
if (!NIL_P(scope) && !OBJ_TAINTED(scope)) {
rb_raise(rb_eSecurityError,
@@ -2162,7 +2163,7 @@
{
VALUE args[4];
- if (ruby_safe_level >= 4) {
+ if (rb_safe_level() >= 4) {
StringValue(src);
}
else {
@@ -2193,7 +2194,7 @@
rb_raise(rb_eArgError, "block not supplied");
}
else {
- if (ruby_safe_level >= 4) {
+ if (rb_safe_level() >= 4) {
StringValue(argv[0]);
}
else {
@@ -2342,7 +2343,7 @@
static void
secure_visibility(VALUE self)
{
- if (ruby_safe_level >= 4 && !OBJ_TAINTED(self)) {
+ if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
rb_raise(rb_eSecurityError,
"Insecure: can't change method visibility");
}
Modified: trunk/eval_jump.h
===================================================================
--- trunk/eval_jump.h 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/eval_jump.h 2006-02-16 17:32:10 UTC (rev 433)
@@ -325,21 +325,21 @@
static struct end_proc_data *end_procs, *ephemeral_end_procs, *tmp_end_procs;
void
-rb_set_end_proc(func, data)
- void (*func) _((VALUE));
- VALUE data;
+rb_set_end_proc(void (*func)(VALUE), VALUE data)
{
struct end_proc_data *link = ALLOC(struct end_proc_data);
struct end_proc_data **list;
- if (ruby_wrapper)
+ if (ruby_wrapper) {
list = &ephemeral_end_procs;
- else
+ }
+ else {
list = &end_procs;
+ }
link->next = *list;
link->func = func;
link->data = data;
- link->safe = ruby_safe_level;
+ link->safe = rb_safe_level();
*list = link;
}
@@ -370,7 +370,7 @@
{
struct end_proc_data *link, *tmp;
int status;
- volatile int safe = ruby_safe_level;
+ volatile int safe = rb_safe_level();
while (ephemeral_end_procs) {
tmp_end_procs = link = ephemeral_end_procs;
@@ -378,7 +378,7 @@
while (link) {
PUSH_TAG(PROT_NONE);
if ((status = EXEC_TAG()) == 0) {
- ruby_safe_level = link->safe;
+ rb_set_safe_level_force(link->safe);
(*link->func) (link->data);
}
POP_TAG();
@@ -396,7 +396,7 @@
while (link) {
PUSH_TAG(PROT_NONE);
if ((status = EXEC_TAG()) == 0) {
- ruby_safe_level = link->safe;
+ rb_set_safe_level_force(link->safe);
(*link->func) (link->data);
}
POP_TAG();
@@ -408,7 +408,7 @@
free(tmp);
}
}
- ruby_safe_level = safe;
+ rb_set_safe_level_force(safe);
}
void
Modified: trunk/eval_load.c
===================================================================
--- trunk/eval_load.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/eval_load.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -249,7 +249,7 @@
VALUE
rb_f_require(VALUE obj, VALUE fname)
{
- return rb_require_safe(fname, ruby_safe_level);
+ return rb_require_safe(fname, rb_safe_level());
}
static int
@@ -358,7 +358,7 @@
long handle;
int found;
- ruby_safe_level = safe;
+ rb_set_safe_level_force(safe);
FilePathValue(fname);
*(volatile VALUE *)&fname = rb_str_new4(fname);
found = search_required(fname, &path);
@@ -367,7 +367,7 @@
result = Qfalse;
}
else {
- ruby_safe_level = 0;
+ rb_set_safe_level_force(0);
switch (found) {
case 'r':
/* loading ruby library should be serialized. */
@@ -377,7 +377,7 @@
/* partial state */
ftptr = ruby_strdup(RSTRING(path)->ptr);
st_insert(loading_tbl, (st_data_t) ftptr,
- (st_data_t) rb_vm_curr_thread());
+ (st_data_t) GET_THREAD()->self);
rb_load(path, 0);
break;
@@ -420,7 +420,7 @@
{
VALUE fn = rb_str_new2(fname);
OBJ_FREEZE(fn);
- return rb_require_safe(fn, ruby_safe_level);
+ return rb_require_safe(fn, rb_safe_level());
}
/*
Modified: trunk/eval_method.h
===================================================================
--- trunk/eval_method.h 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/eval_method.h 2006-02-16 17:32:10 UTC (rev 433)
@@ -99,7 +99,7 @@
if (NIL_P(klass)) {
klass = rb_cObject;
}
- if (ruby_safe_level >= 4 && (klass == rb_cObject || !OBJ_TAINTED(klass))) {
+ if (rb_safe_level() >= 4 && (klass == rb_cObject || !OBJ_TAINTED(klass))) {
rb_raise(rb_eSecurityError, "Insecure: can't define method");
}
if (!FL_TEST(klass, FL_SINGLETON) &&
@@ -254,7 +254,7 @@
if (klass == rb_cObject) {
rb_secure(4);
}
- if (ruby_safe_level >= 4 && !OBJ_TAINTED(klass)) {
+ if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) {
rb_raise(rb_eSecurityError, "Insecure: can't remove method");
}
if (OBJ_FROZEN(klass))
@@ -412,7 +412,7 @@
if (ruby_cbase() == rb_cObject && klass == rb_cObject) {
rb_secure(4);
}
- if (ruby_safe_level >= 4 && !OBJ_TAINTED(klass)) {
+ if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) {
rb_raise(rb_eSecurityError, "Insecure: can't undef `%s'",
rb_id2name(id));
}
Modified: trunk/eval_proc.c
===================================================================
--- trunk/eval_proc.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/eval_proc.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -110,6 +110,7 @@
"tried to create Proc object without a block");
}
}
+
cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
procval = th_make_proc(th, cfp, block);
@@ -314,14 +315,6 @@
* eval("param", b) #=> 99
*/
-static VALUE
-proc_binding(proc)
- VALUE proc;
-{
- UNSUPPORTED(proc_binding);
- return Qnil;
-}
-
void
bm_mark(struct METHOD *data)
{
@@ -708,9 +701,10 @@
}
PUSH_TAG(PROT_NONE);
if (OBJ_TAINTED(method)) {
- safe = ruby_safe_level;
- if (ruby_safe_level < 4)
- ruby_safe_level = 4;
+ safe = rb_safe_level();
+ if (rb_safe_level() < 4) {
+ rb_set_safe_level_force(4);
+ }
}
if ((state = EXEC_TAG()) == 0) {
PASS_PASSED_BLOCK();
@@ -720,7 +714,7 @@
}
POP_TAG();
if (safe >= 0)
- ruby_safe_level = safe;
+ rb_set_safe_level_force(safe);
if (state)
JUMP_TAG(state);
return result;
Modified: trunk/eval_safe.h
===================================================================
--- trunk/eval_safe.h 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/eval_safe.h 2006-02-16 17:32:10 UTC (rev 433)
@@ -2,7 +2,6 @@
* This file is included by eval.c
*/
-int ruby_safe_level = 0;
/* safe-level:
0 - strings from streams/environment/ARGV are tainted (default)
1 - no dangerous operation by tainted value
@@ -11,6 +10,18 @@
4 - no global (non-tainted) variable modification/no direct output
*/
+int
+rb_safe_level()
+{
+ return GET_THREAD()->safe_level;
+}
+
+void
+rb_set_safe_level_force(int safe)
+{
+ GET_THREAD()->safe_level = safe;
+}
+
static VALUE safe_getter _((void));
static void safe_setter _((VALUE val));
@@ -38,7 +49,7 @@
static VALUE
safe_getter(void)
{
- return INT2NUM(ruby_safe_level);
+ return INT2NUM(rb_safe_level());
}
static void
@@ -61,14 +72,14 @@
void
rb_secure(int level)
{
- if (level <= ruby_safe_level) {
+ if (level <= rb_safe_level()) {
if (rb_frame_callee()) {
rb_raise(rb_eSecurityError, "Insecure operation `%s' at level %d",
- rb_id2name(rb_frame_callee()), ruby_safe_level);
+ rb_id2name(rb_frame_callee()), rb_safe_level());
}
else {
rb_raise(rb_eSecurityError, "Insecure operation at level %d",
- ruby_safe_level);
+ rb_safe_level());
}
}
}
@@ -83,7 +94,7 @@
void
rb_check_safe_obj(VALUE x)
{
- if (ruby_safe_level > 0 && OBJ_TAINTED(x)) {
+ if (rb_safe_level() > 0 && OBJ_TAINTED(x)) {
if (rb_frame_callee()) {
rb_raise(rb_eSecurityError, "Insecure operation - %s",
rb_id2name(rb_frame_callee()));
Modified: trunk/eval_thread.c
===================================================================
--- trunk/eval_thread.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/eval_thread.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -4,15 +4,6 @@
#include "eval_intern.h"
-static rb_thread_t curr_thread = 0;
-static rb_thread_t main_thread;
-
-rb_thread_t
-rb_vm_curr_thread()
-{
- return curr_thread;
-}
-
#ifdef __ia64__
#if defined(__FreeBSD__)
/*
@@ -381,105 +372,6 @@
(rb_thread_save_context(th),\
rb_thread_switch((FLUSH_REGISTER_WINDOWS, ruby_setjmp((th)->context))))
-NORETURN(static void rb_thread_restore_context _((rb_thread_t, int)));
-NOINLINE(static void stack_extend _((rb_thread_t, int)));
-
-static void
-stack_extend(th, exit)
- rb_thread_t th;
- int exit;
-{
- VALUE space[1024];
-
- memset(space, 0, 1); /* prevent array from optimization */
- rb_thread_restore_context(th, exit);
-}
-
-static void
-rb_thread_restore_context(th, exit)
- rb_thread_t th;
- int exit;
-{
- VALUE v;
- static rb_thread_t tmp;
- static int ex;
- static VALUE tval;
-
- if (!th->stk_ptr)
- rb_bug("unsaved context");
-
-#if STACK_GROW_DIRECTION < 0
- if (&v > th->stk_pos)
- stack_extend(th, exit);
-#elif STACK_GROW_DIRECTION > 0
- if (&v < th->stk_pos + th->stk_len)
- stack_extend(th, exit);
-#else
- if (&v < rb_gc_stack_start) {
- /* Stack grows downward */
- if (&v > th->stk_pos)
- stack_extend(th, exit);
- }
- else {
- /* Stack grows upward */
- if (&v < th->stk_pos + th->stk_len)
- stack_extend(th, exit);
- }
-#endif
-
- rb_trap_immediate = 0; /* inhibit interrupts from here */
- // prot_tag = th->tag;
- // tracing = th->tracing;
- GET_THREAD()->errinfo = th->errinfo;
- rb_last_status = th->last_status;
- ruby_safe_level = th->safe;
-
- ruby_current_node = th->node;
-
-#ifdef SAVE_WIN32_EXCEPTION_LIST
- win32_set_exception_list(th->win32_exception_list);
-#endif
- tmp = th;
- ex = exit;
- FLUSH_REGISTER_WINDOWS;
- MEMCPY(tmp->stk_pos, tmp->stk_ptr, VALUE, tmp->stk_len);
-#ifdef __ia64__
- {
- VALUE *base;
-#if defined(HAVE_UNWIND_H) && defined(HAVE__UNW_CREATECONTEXTFORSELF)
- _Unwind_Context *unwctx = _UNW_createContextForSelf();
-
- _UNW_currentContext(unwctx);
- base = (VALUE *)(long)_UNW_getAR(unwctx, _UNW_AR_BSP);
- _UNW_destroyContext(unwctx);
-#else
- base = (VALUE *)__libc_ia64_register_backing_store_base;
-#endif
- MEMCPY(base, tmp->bstr_ptr, VALUE, tmp->bstr_len);
- }
-#endif
-
- tval = rb_lastline_get();
- rb_lastline_set(tmp->last_line);
- tmp->last_line = tval;
- tval = rb_backref_get();
- rb_backref_set(tmp->last_match);
- tmp->last_match = tval;
-
- ruby_longjmp(tmp->context, ex);
-}
-
-static void
-rb_thread_die(th)
- rb_thread_t th;
-{
- th->thgroup = 0;
- th->status = THREAD_KILLED;
- if (th->stk_ptr)
- free(th->stk_ptr);
- th->stk_ptr = 0;
-}
-
void
rb_thread_fd_close(fd)
int fd;
@@ -487,37 +379,9 @@
// TODO: fix me
}
-NORETURN(static void rb_thread_main_jump _((VALUE, int)));
-static void
-rb_thread_main_jump(err, tag)
- VALUE err;
- int tag;
-{
- UNSUPPORTED(rb_thread_main_jump);
-}
-
-NORETURN(static void rb_thread_deadlock _((void)));
-static void
-rb_thread_deadlock()
-{
- char msg[21 + SIZEOF_LONG * 2];
- VALUE e;
-
- sprintf(msg, "Thread(%p): deadlock", (void *)curr_thread->thread);
- e = rb_exc_new2(rb_eFatal, msg);
- if (curr_thread == main_thread) {
- rb_exc_raise(e);
- }
- rb_thread_main_jump(e, RESTORE_RAISE);
-}
-
void
rb_thread_schedule()
{
- // printf("rb_thread_schedule()\n");
- // TODO: fix me
- // ignore
- /* UNSUPPORTED(rb_thread_schedule); */
}
VALUE
@@ -746,21 +610,9 @@
}
void
-rb_thread_atfork()
+rb_thread_atfork(void)
{
- rb_thread_t th;
-
- if (rb_thread_alone())
- return;
- FOREACH_THREAD(th) {
- if (th != curr_thread) {
- rb_thread_die(th);
- }
- }
- END_FOREACH(th);
- main_thread = curr_thread;
- curr_thread->next = curr_thread;
- curr_thread->prev = curr_thread;
+ // TODO
}
Modified: trunk/ext/win32ole/win32ole.c
===================================================================
--- trunk/ext/win32ole/win32ole.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/ext/win32ole/win32ole.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -1683,7 +1683,7 @@
ole_initialize();
rb_scan_args(argc, argv, "1*", &svr_name, &others);
- if (ruby_safe_level > 0 && OBJ_TAINTED(svr_name)) {
+ if (rb_safe_level() > 0 && OBJ_TAINTED(svr_name)) {
rb_raise(rb_eSecurityError, "Insecure Object Connection - %s",
StringValuePtr(svr_name));
}
@@ -2086,12 +2086,12 @@
rb_call_super(0, 0);
rb_scan_args(argc, argv, "11*", &svr_name, &host, &others);
- if (ruby_safe_level > 0 && OBJ_TAINTED(svr_name)) {
+ if (rb_safe_level() > 0 && OBJ_TAINTED(svr_name)) {
rb_raise(rb_eSecurityError, "Insecure Object Creation - %s",
StringValuePtr(svr_name));
}
if (!NIL_P(host)) {
- if (ruby_safe_level > 0 && OBJ_TAINTED(host)) {
+ if (rb_safe_level() > 0 && OBJ_TAINTED(host)) {
rb_raise(rb_eSecurityError, "Insecure Object Creation - %s",
StringValuePtr(svr_name));
}
@@ -6722,7 +6722,7 @@
}
if(TYPE(itf) != T_NIL) {
- if (ruby_safe_level > 0 && OBJ_TAINTED(itf)) {
+ if (rb_safe_level() > 0 && OBJ_TAINTED(itf)) {
rb_raise(rb_eSecurityError, "Insecure Event Creation - %s",
StringValuePtr(itf));
}
Modified: trunk/gc.c
===================================================================
--- trunk/gc.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/gc.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -1744,7 +1744,7 @@
need_call_final = 1;
FL_SET(obj, FL_FINALIZE);
- block = rb_ary_new3(2, INT2FIX(ruby_safe_level), block);
+ block = rb_ary_new3(2, INT2FIX(rb_safe_level()), block);
if (!finalizer_table) {
finalizer_table = st_init_numtable();
@@ -1788,7 +1788,7 @@
objid = rb_obj_id(obj); /* make obj into id */
rb_thread_critical = Qtrue;
args[1] = 0;
- args[2] = (VALUE)ruby_safe_level;
+ args[2] = (VALUE)rb_safe_level();
for (i=0; i<RARRAY(finalizers)->len; i++) {
args[0] = RARRAY(finalizers)->ptr[i];
if (!args[1]) args[1] = rb_ary_new3(1, objid);
Modified: trunk/ruby.h
===================================================================
--- trunk/ruby.h 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/ruby.h 2006-02-16 17:32:10 UTC (rev 433)
@@ -256,9 +256,9 @@
#define FilePathValue(v) ((v) = rb_get_path(v))
void rb_secure(int);
-RUBY_EXTERN int ruby_safe_level;
-#define rb_safe_level() (ruby_safe_level)
+int rb_safe_level();
void rb_set_safe_level(int);
+void rb_set_safe_level_force(int);
void rb_secure_update(VALUE);
long rb_num2long(VALUE);
Modified: trunk/signal.c
===================================================================
--- trunk/signal.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/signal.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -689,7 +689,7 @@
}
trap_list[sig].cmd = command;
- trap_list[sig].safe = ruby_safe_level;
+ trap_list[sig].safe = rb_safe_level();
/* enable at least specified signal. */
#ifndef _WIN32
#ifdef HAVE_SIGPROCMASK
Modified: trunk/test.rb
===================================================================
--- trunk/test.rb 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/test.rb 2006-02-16 17:32:10 UTC (rev 433)
@@ -1,4 +1,18 @@
+require 'test/unit'
+class TestSafe < Test::Unit::TestCase
+ def test_safe
+ safe = $SAFE
+ c = Class.new
+ x = c.new
+ p = proc {$SAFE += 1}
+ c.class_eval {define_method(:inc, p)}
+ assert_equal(safe + 1,
+ proc {x.method(:inc).to_proc.call; $SAFE}.call)
+ end
+end
+__END__
+
p proc{
# p 1
}.to_s
Modified: trunk/thread.c
===================================================================
--- trunk/thread.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/thread.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -1155,7 +1155,7 @@
VALUE val;
GetThreadVal(thread, th);
- if (ruby_safe_level >= 4 && th != GET_THREAD()) {
+ if (rb_safe_level() >= 4 && th != GET_THREAD()) {
rb_raise(rb_eSecurityError, "Insecure: thread locals");
}
if (!th->local_storage) {
@@ -1200,7 +1200,7 @@
yarv_thread_t *th;
GetThreadVal(thread, th);
- if (ruby_safe_level >= 4 && th != GET_THREAD()) {
+ if (rb_safe_level() >= 4 && th != GET_THREAD()) {
rb_raise(rb_eSecurityError, "Insecure: can't modify thread locals");
}
if (OBJ_FROZEN(thread)) {
Modified: trunk/variable.c
===================================================================
--- trunk/variable.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/variable.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -1187,7 +1187,7 @@
fn = rb_str_new2(file);
FL_UNSET(fn, FL_TAINT);
OBJ_FREEZE(fn);
- st_insert(tbl, id, (st_data_t)rb_node_newnode(NODE_MEMO, fn, ruby_safe_level, 0));
+ st_insert(tbl, id, (st_data_t)rb_node_newnode(NODE_MEMO, fn, rb_safe_level(), 0));
}
static NODE*
Modified: trunk/vm.c
===================================================================
--- trunk/vm.c 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/vm.c 2006-02-16 17:32:10 UTC (rev 433)
@@ -379,7 +379,7 @@
proc->block.iseq = block->iseq;
proc->block.proc = procval;
proc->envval = envval;
-
+ proc->safe_level = th->safe_level;
proc->special_cref_stack = lfp_get_special_cref(block->lfp);
return procval;
}
@@ -679,15 +679,18 @@
{
VALUE val = Qundef;
int state;
+ volatile int stored_safe = th->safe_level;
NODE *stored_special_cref_stack = 0;
-
- if (proc->special_cref_stack) {
- stored_special_cref_stack =
- lfp_set_special_cref(proc->block.lfp, proc->special_cref_stack);
- }
TH_PUSH_TAG(th);
if ((state = EXEC_TAG()) == 0) {
+
+ if (proc->special_cref_stack) {
+ stored_special_cref_stack =
+ lfp_set_special_cref(proc->block.lfp, proc->special_cref_stack);
+ }
+ th->safe_level = proc->safe_level;
+
if (BUILTIN_TYPE(proc->block.iseq) == T_NODE) {
val = th_invoke_yield_cfunc(th, &proc->block, argc, argv);
}
@@ -709,11 +712,11 @@
}
TH_POP_TAG();
- /* restore cref */
+ th->safe_level = stored_safe;
if (stored_special_cref_stack) {
lfp_set_special_cref(proc->block.lfp, stored_special_cref_stack);
}
-
+
if (state) {
JUMP_TAG(state);
}
@@ -1104,7 +1107,7 @@
noex = NOEX_PUBLIC;
if (st_lookup(RCLASS(klass)->m_tbl, id, (void *)&newbody)) {
- if (ruby_safe_level >= 4) {
+ if (rb_safe_level() >= 4) {
rb_raise(rb_eSecurityError, "redefining method prohibited");
}
if (RTEST(ruby_verbose)) {
Modified: trunk/yarvtest/test_proc.rb
===================================================================
--- trunk/yarvtest/test_proc.rb 2006-02-16 16:13:06 UTC (rev 432)
+++ trunk/yarvtest/test_proc.rb 2006-02-16 17:32:10 UTC (rev 433)
@@ -244,5 +244,21 @@
b.call.foo
}
end
+
+ def test_safe
+ ae %q{
+ pr = proc{
+ $SAFE
+ }
+ $SAFE = 1
+ pr.call
+ }
+ ae %q{
+ pr = proc{
+ $SAFE += 1
+ }
+ [pr.call, $SAFE]
+ }
+ end
end
--
ML: yarv-diff quickml.atdot.net
Info: http://www.atdot.net/~ko1/quickml