InstallingTheSandbox: ruby-1.8.5-sandbox_needs.patch

ruby-1.8.

@@ -827 +827 @@
  *     Errno.constants   #=> E2BIG, EACCES, EADDRINUSE, EADDRNOTAVAIL, ...
  */
 
-static st_table *syserr_tbl;
+st_table *rb_syserr_tbl;
 
 static VALUE
 set_syserr(n, name)
@@ -836 +836 @@
 {
     VALUE error;
 
-    if (!st_lookup(syserr_tbl, n, &error)) {
+    if (!st_lookup(rb_syserr_tbl, n, &error)) {
         error = rb_define_class_under(rb_mErrno, name, rb_eSystemCallError);
         rb_define_const(error, "Errno", INT2NUM(n));
-        st_add_direct(syserr_tbl, n, error);
+        st_add_direct(rb_syserr_tbl, n, error);
     }
     else {
         rb_define_const(rb_mErrno, name, error);
@@ -853 +853 @@
 {
     VALUE error;
 
-    if (!st_lookup(syserr_tbl, n, &error)) {
+    if (!st_lookup(rb_syserr_tbl, n, &error)) {
         char name[8];   /* some Windows' errno have 5 digits. */
 
         snprintf(name, sizeof(name), "E%03d", n);
@@ -891 +891 @@
         if (argc == 1 && FIXNUM_P(mesg)) {
             error = mesg; mesg = Qnil;
         }
-        if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &klass)) {
+        if (!NIL_P(error) && st_lookup(rb_syserr_tbl, NUM2LONG(error), &klass)) {
             /* change class */
             if (TYPE(self) != T_OBJECT) { /* insurance to avoid type crash */
                 rb_raise(rb_eTypeError, "invalid instance type");
@@ -1031 +1031 @@
     rb_eSecurityError = rb_define_class("SecurityError", rb_eStandardError);
     rb_eNoMemError = rb_define_class("NoMemoryError", rb_eException);
 
-    syserr_tbl = st_init_numtable();
+    rb_syserr_tbl = st_init_numtable();
     rb_eSystemCallError = rb_define_class("SystemCallError", rb_eStandardError);
     rb_define_method(rb_eSystemCallError, "initialize", syserr_initialize, -1);
     rb_define_method(rb_eSystemCallError, "errno", syserr_errno, 0);

ruby-1.8.

@@ -29 +29 @@
 #endif
 
 #include <stdio.h>
-#if defined(HAVE_GETCONTEXT) && defined(HAVE_SETCONTEXT)
-#include <ucontext.h>
-#define USE_CONTEXT
-#endif
-#include <setjmp.h>
 
 #include "st.h"
 #include "dln.h"
@@ -90 +85 @@
 #endif
 
 #ifdef USE_CONTEXT
-typedef struct {
-    ucontext_t context;
-    volatile int status;
-} rb_jmpbuf_t[1];
 
 NORETURN(static void rb_jump_context(rb_jmpbuf_t, int));
 static inline void
@@ -201 +192 @@
      POST_GETCONTEXT, \
      (j)->status)
 #else
-typedef jmp_buf rb_jmpbuf_t;
 #  if !defined(setjmp) && defined(HAVE__SETJMP)
 #    define ruby_setjmp(env) _setjmp(env)
 #    define ruby_longjmp(env,val) _longjmp(env,val)
@@ -250 +240 @@
 #define SCOPE_SET(f)  (scope_vmode=(f))
 #define SCOPE_TEST(f) (scope_vmode&(f))
 
+VALUE (*ruby_sandbox_save)(struct thread *) = NULL; 
+VALUE (*ruby_sandbox_restore)(struct thread *) = NULL; 
 NODE* ruby_current_node;
 int ruby_safe_level = 0;
 /* safe-level:
@@ -1061 +1053 @@
 #define POP_CLASS() ruby_class = _class; \
 } while (0)
 
-static NODE *ruby_cref = 0;
-static NODE *top_cref;
+NODE *ruby_cref = 0;
+NODE *ruby_top_cref;
 #define PUSH_CREF(c) ruby_cref = NEW_NODE(NODE_CREF,(c),0,ruby_cref)
 #define POP_CREF() ruby_cref = ruby_cref->nd_next
 
@@ -1078 +1070 @@
     ruby_scope = _scope;                \
     scope_vmode = SCOPE_PUBLIC
 
-typedef struct thread * rb_thread_t;
-static rb_thread_t curr_thread = 0;
-static rb_thread_t main_thread;
+rb_thread_t curr_thread = 0;
+rb_thread_t main_thread;
 static void scope_dup _((struct SCOPE *));
 
 #define POP_SCOPE()                     \
@@ -1391 +1382 @@
         rb_call_inits();
         ruby_class = rb_cObject;
         ruby_frame->self = ruby_top_self;
-        top_cref = rb_node_newnode(NODE_CREF,rb_cObject,0,0);
-        ruby_cref = top_cref;
+        ruby_top_cref = rb_node_newnode(NODE_CREF,rb_cObject,0,0);
+        ruby_cref = ruby_top_cref;
         rb_define_global_const("TOPLEVEL_BINDING", rb_f_binding(ruby_top_self));
 #ifdef __MACOS__
         _macruby_init();
@@ -1437 +1428 @@
 static int thread_set_raised();
 static int thread_reset_raised();
 
+static int thread_no_ensure _((void));
+
 static VALUE exception_error;
 static VALUE sysstack_error;
 
@@ -3307 +3300 @@
             result = rb_eval(self, node->nd_head);
         }
         POP_TAG();
-        if (node->nd_ensr) {
+        if (node->nd_ensr && !thread_no_ensure()) {
             VALUE retval = prot_tag->retval; /* save retval */
             VALUE errinfo = ruby_errinfo;
 
@@ -4740 +4733 @@
     return Qfalse;
 }
 
-static VALUE rb_eThreadError;
+VALUE rb_eThreadError;
 
 NORETURN(static void proc_jump_error(int, VALUE));
 static void
@@ -5453 +5446 @@
     }
     POP_TAG();
     retval = prot_tag ? prot_tag->retval : Qnil;        /* save retval */
+    if (!thread_no_ensure()) {
     (*e_proc)(data2);
+    }
     if (prot_tag) return_value(retval);
     if (state) JUMP_TAG(state);
     return result;
@@ -6797 +6792 @@
     ruby_errinfo = Qnil;        /* ensure */
     PUSH_VARS();
     PUSH_CLASS(ruby_wrapper);
-    ruby_cref = top_cref;
+    ruby_cref = ruby_top_cref;
     if (!wrap) {
         rb_secure(4);           /* should alter global state */
         ruby_class = rb_cObject;
@@ -9757 +9752 @@
 
 extern VALUE rb_last_status;
 
-enum thread_status {
-    THREAD_TO_KILL,
-    THREAD_RUNNABLE,
-    THREAD_STOPPED,
-    THREAD_KILLED,
-};
-
 #define WAIT_FD         (1<<0)
 #define WAIT_SELECT     (1<<1)
 #define WAIT_TIME       (1<<2)
@@ -9781 +9769 @@
 # endif
 #endif
 
-/* typedef struct thread * rb_thread_t; */
-
-struct thread {
-    struct thread *next, *prev;
-    rb_jmpbuf_t context;
-#ifdef SAVE_WIN32_EXCEPTION_LIST
-    DWORD win32_exception_list;
-#endif
-
-    VALUE result;
-
-    long   stk_len;
-    long   stk_max;
-    VALUE *stk_ptr;
-    VALUE *stk_pos;
-#ifdef __ia64__
-    VALUE *bstr_ptr;
-    long   bstr_len;
-#endif
-
-    struct FRAME *frame;
-    struct SCOPE *scope;
-    struct RVarmap *dyna_vars;
-    struct BLOCK *block;
-    struct iter *iter;
-    struct tag *tag;
-    VALUE klass;
-    VALUE wrapper;
-    NODE *cref;
-
-    int flags;          /* misc. states (vmode/rb_trap_immediate/raised) */
-
-    NODE *node;
-
-    int tracing;
-    VALUE errinfo;
-    VALUE last_status;
-    VALUE last_line;
-    VALUE last_match;
-
-    int safe;
-
-    enum thread_status status;
-    int wait_for;
-    int fd;
-    fd_set readfds;
-    fd_set writefds;
-    fd_set exceptfds;
-    int select_value;
-    double delay;
-    rb_thread_t join;
-
-    int abort;
-    int priority;
-    VALUE thgroup;
-
-    st_table *locals;
-
-    VALUE thread;
-};
-
 #define THREAD_RAISED 0x200      /* temporary flag */
 #define THREAD_TERMINATING 0x400 /* persistent flag */
-#define THREAD_FLAGS_MASK  0x400 /* mask for persistent flags */
+#define THREAD_NO_ENSURE 0x800   /* persistent flag */
+#define THREAD_FLAGS_MASK  0xc00 /* mask for persistent flags */
 
 #define FOREACH_THREAD_FROM(f,x) x = f; do { x = x->next;
 #define END_FOREACH_FROM(f,x) } while (x != f)
@@ -9912 +9840 @@
     return 1;
 }
 
+static int
+thread_no_ensure()
+{
+    return ((curr_thread->flags & THREAD_NO_ENSURE) == THREAD_NO_ENSURE);
+}
+
 static void rb_thread_ready _((rb_thread_t));
 
 static VALUE run_trap_eval _((VALUE));
@@ -10042 +9976 @@
     rb_gc_mark(th->last_match);
     rb_mark_tbl(th->locals);
     rb_gc_mark(th->thgroup);
+    rb_gc_mark_maybe(th->sandbox);
 
     /* mark data in copied stack */
     if (th == curr_thread) return;
@@ -10246 +10181 @@
     th->safe = ruby_safe_level;
 
     th->node = ruby_current_node;
+    if (ruby_sandbox_save != NULL)
+    {
+      ruby_sandbox_save(th);
+    }
 }
 
 static int
@@ -10336 +10275 @@
 #endif
 
     rb_trap_immediate = 0;      /* inhibit interrupts from here */
+    if (ruby_sandbox_restore != NULL)
+    {
+      ruby_sandbox_restore(th);
+    }
     ruby_frame = th->frame;
     ruby_scope = th->scope;
     ruby_class = th->klass;
@@ -11201 +11144 @@
 }
 
 
+static void
+kill_thread(th, flags)
+    rb_thread_t th;
+    int flags;
+{
+    if (th != curr_thread && th->safe < 4) {
+        rb_secure(4);
+    }
+    if (th->status == THREAD_TO_KILL || th->status == THREAD_KILLED)
+        return;
+    if (th == th->next || th == main_thread) rb_exit(EXIT_SUCCESS);
+
+    rb_thread_ready(th);
+    th->flags |= flags;
+    th->status = THREAD_TO_KILL;
+    if (!rb_thread_critical) rb_thread_schedule();
+}
+
+
 /*
  *  call-seq:
- *     thr.exit        => thr or nil
- *     thr.kill        => thr or nil
- *     thr.terminate   => thr or nil
- *  
- *  Terminates <i>thr</i> and schedules another thread to be run. If this thread
- *  is already marked to be killed, <code>exit</code> returns the
- *  <code>Thread</code>. If this is the main thread, or the last thread, exits
- *  the process.
+ *     thr.exit        => thr
+ *     thr.kill        => thr
+ *     thr.terminate   => thr
+ *  
+ *  Terminates <i>thr</i> and schedules another thread to be run, returning
+ *  the terminated <code>Thread</code>.  If this is the main thread, or the
+ *  last thread, exits the process.
  */
 
 VALUE
@@ -11219 +11180 @@
 {
     rb_thread_t th = rb_thread_check(thread);
 
-    if (th != curr_thread && th->safe < 4) {
-        rb_secure(4);
-    }
-    if (th->status == THREAD_TO_KILL || th->status == THREAD_KILLED)
+    kill_thread(th, 0);
         return thread;
-    if (th == th->next || th == main_thread) rb_exit(EXIT_SUCCESS);
+}
 
-    rb_thread_ready(th);
-    th->status = THREAD_TO_KILL;
-    if (!rb_thread_critical) rb_thread_schedule();
+
+/*
+ *  call-seq:
+ *     thr.exit!        => thr
+ *     thr.kill!        => thr
+ *     thr.terminate!   => thr
+ *  
+ *  Terminates <i>thr</i> without calling ensure clauses and schedules
+ *  another thread to be run, returning the terminated <code>Thread</code>.
+ *  If this is the main thread, or the last thread, exits the process.
+ *
+ *  See <code>Thread#exit</code> for the safer version.
+ */
+
+static VALUE
+rb_thread_kill_bang(thread)
+    VALUE thread;
+{
+    rb_thread_t th = rb_thread_check(thread);
+    kill_thread(th, THREAD_NO_ENSURE);
     return thread;
 }
 
-
 /*
  *  call-seq:
  *     Thread.kill(thread)   => thread
@@ -11626 +11600 @@
     th->thgroup = thgroup_default;\
     th->locals = 0;\
     th->thread = 0;\
+    if (curr_thread == 0) {\
+      th->sandbox = Qnil;\
+    } else {\
+      th->sandbox = curr_thread->sandbox;\
+    }\
 } while (0)
 
 static rb_thread_t
@@ -12883 +12862 @@
     rb_define_method(rb_cThread, "kill", rb_thread_kill, 0);
     rb_define_method(rb_cThread, "terminate", rb_thread_kill, 0);
     rb_define_method(rb_cThread, "exit", rb_thread_kill, 0);
+    rb_define_method(rb_cThread, "kill!", rb_thread_kill_bang, 0);
+    rb_define_method(rb_cThread, "terminate!", rb_thread_kill_bang, 0);
+    rb_define_method(rb_cThread, "exit!", rb_thread_kill_bang, 0);
     rb_define_method(rb_cThread, "value", rb_thread_value, 0);
     rb_define_method(rb_cThread, "status", rb_thread_status, 0);
     rb_define_method(rb_cThread, "join", rb_thread_join_m, -1);

ruby-1.8.

@@ -151 +151 @@
     } u3;
 } NODE;
 
+extern NODE *ruby_cref;
+extern NODE *ruby_top_cref;
+
 #define RNODE(obj)  (R_CAST(RNode)(obj))
 
 #define nd_type(n) ((int)(((RNODE(n))->flags>>FL_USHIFT)&0xff))
@@ -371 +374 @@
 void rb_add_event_hook _((rb_event_hook_func_t,rb_event_t));
 int rb_remove_event_hook _((rb_event_hook_func_t));
 
+#if defined(HAVE_GETCONTEXT) && defined(HAVE_SETCONTEXT)
+#include <ucontext.h>
+#define USE_CONTEXT
+#endif
+#include <setjmp.h>
+#include "st.h"
+
+#ifdef USE_CONTEXT
+typedef struct {
+    ucontext_t context;
+    volatile int status;
+} rb_jmpbuf_t[1];
+#else
+typedef jmp_buf rb_jmpbuf_t;
+#endif
+
+enum thread_status {
+    THREAD_TO_KILL,
+    THREAD_RUNNABLE,
+    THREAD_STOPPED,
+    THREAD_KILLED,
+};
+
+typedef struct thread * rb_thread_t;
+
+struct thread {
+    struct thread *next, *prev;
+    rb_jmpbuf_t context;
+#ifdef SAVE_WIN32_EXCEPTION_LIST
+    DWORD win32_exception_list;
+#endif
+
+    VALUE result;
+
+    long   stk_len;
+    long   stk_max;
+    VALUE *stk_ptr;
+    VALUE *stk_pos;
+#ifdef __ia64__
+    VALUE *bstr_ptr;
+    long   bstr_len;
+#endif
+
+    struct FRAME *frame;
+    struct SCOPE *scope;
+    struct RVarmap *dyna_vars;
+    struct BLOCK *block;
+    struct iter *iter;
+    struct tag *tag;
+    VALUE klass;
+    VALUE wrapper;
+    NODE *cref;
+
+    int flags;          /* misc. states (vmode/rb_trap_immediate/raised) */
+
+    NODE *node;
+
+    int tracing;
+    VALUE errinfo;
+    VALUE last_status;
+    VALUE last_line;
+    VALUE last_match;
+
+    int safe;
+
+    enum thread_status status;
+    int wait_for;
+    int fd;
+    fd_set readfds;
+    fd_set writefds;
+    fd_set exceptfds;
+    int select_value;
+    double delay;
+    rb_thread_t join;
+
+    int abort;
+    int priority;
+    VALUE thgroup;
+
+    st_table *locals;
+
+    VALUE thread;
+
+    VALUE sandbox;
+};
+
+extern VALUE (*ruby_sandbox_save)(struct thread *); 
+extern VALUE (*ruby_sandbox_restore)(struct thread *); 
+extern rb_thread_t curr_thread;
+extern rb_thread_t main_thread;
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif

ruby-1.8.

@@ -626 +626 @@
 RUBY_EXTERN VALUE rb_eRuntimeError;
 RUBY_EXTERN VALUE rb_eSecurityError;
 RUBY_EXTERN VALUE rb_eSystemCallError;
+RUBY_EXTERN VALUE rb_eThreadError;
 RUBY_EXTERN VALUE rb_eTypeError;
 RUBY_EXTERN VALUE rb_eZeroDivError;
 RUBY_EXTERN VALUE rb_eNotImpError;