rallhook 0.7.0

data/ext/rallhook_base/restrict_def.h

@@ -0,0 +1,37 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+#ifndef __RESTRICT_DEF_H
+#define __RESTRICT_DEF_H
+
+#include "ruby.h"
+
+void init_restrict_def();
+
+void disable_overwrite(VALUE current_thread);
+void enable_overwrite(VALUE current_thread);
+
+void shadow_redirect(VALUE* klass, VALUE* recv, ID* mid);
+
+VALUE unshadow(VALUE klass) ;
+
+VALUE shadow_or_create(VALUE klass);
+
+#endif

data/ext/rallhook_base/ruby_redirect.c

@@ -0,0 +1,122 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario/rallhook
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+#include "ruby_redirect.h"
+#include "ruby_symbols.h"
+#include "rb_call_fake.h"
+#include "hook_rb_call.h"
+#include "pthread.h"
+
+int code_changed = 0;
+
+REDIRECTHANDLER current_redirect_handler;
+
+void init_redirect();
+
+int put_redirect_handler_( REDIRECTHANDLER redirect_handler) {
+	current_redirect_handler = redirect_handler;
+
+	if (!code_changed) {
+		// insert inconditional jmp from rb_call to rb_call_copy
+
+		#ifdef __i386__
+		rb_call_copy = (RBCALL)hook_rb_call(rb_call_fake_regs);
+		#endif
+
+		#ifdef __x86_64__
+		rb_call_copy = (RBCALL)hook_rb_call(rb_call_fake);
+		#endif
+		// calibrate protocol of rb_call
+		#ifdef __i386__
+		is_calibrate = 1;
+
+		VALUE test_value = LONG2FIX(0);
+
+		calibrate_recv = test_value;
+		calibrate_klass = CLASS_OF(test_value);
+		calibrate_mid = rb_intern("to_s");
+
+		rb_funcall(test_value, calibrate_mid, 0);
+
+
+		#endif
+
+		if (!rb_call_copy) {
+			rb_raise( rb_eFatal, "libruby incompatible with rallhook");
+		}
+
+		#ifdef RUBY1_9
+			#ifdef __i386__
+
+			rb_eval_string("def Object.___calibrate_x(x); end");
+
+			calibrate_recv = rb_cObject;
+			calibrate_klass = CLASS_OF(rb_cObject);
+			calibrate_mid = rb_intern("___calibrate_x");
+
+			vm_call_method_copy = (VMCALLMETHOD)hook_vm_call_method(vm_call_method_fake_regs);
+			vm_is_calibrate = 1;
+
+			char code[256];
+			snprintf(code, sizeof(code), "Object.___calibrate_x(%i)", test_value);
+			rb_eval_string(code);
+
+			#endif
+			#ifdef __x86_64__
+			vm_call_method_copy = (VMCALLMETHOD)hook_vm_call_method(vm_call_method_fake);
+			#endif
+
+			if (!vm_call_method_copy) {
+				rb_raise( rb_eFatal, "libruby incompatible with rallhook");
+			}
+		#endif
+
+		code_changed = 1;
+	}
+
+	return 0;
+}
+
+
+pthread_mutex_t put_redirect_handler_mutex;
+
+int put_redirect_handler( REDIRECTHANDLER redirect_handler) {
+
+	pthread_mutex_lock(&put_redirect_handler_mutex);
+	put_redirect_handler_(redirect_handler);
+	pthread_mutex_unlock(&put_redirect_handler_mutex);
+}
+
+
+void init_redirect() {
+
+	pthread_mutexattr_t attr;
+
+	pthread_mutexattr_init(&attr);
+	pthread_mutexattr_settype(&attr,  PTHREAD_MUTEX_NORMAL);
+
+	pthread_mutex_init( &put_redirect_handler_mutex, &attr);
+
+	init_hook_rb_call();
+	rb_call_fake_init();
+}
+
+
+

data/ext/rallhook_base/ruby_redirect.h

@@ -0,0 +1,33 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario/rallhook
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+#ifndef __RUBY_REDIRECT_H
+#define __RUBY_REDIRECT_H
+
+// Acts as facade of the division between the ruby interpreter modification
+
+#include <ruby.h>
+
+typedef void (*REDIRECTHANDLER) ( VALUE* klass, VALUE* recv, ID* mid );
+int put_redirect_handler( REDIRECTHANDLER redirect_handler);
+
+void init_redirect();
+
+#endif

data/ext/rallhook_base/ruby_symbols.c

@@ -0,0 +1,43 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario/rallhook
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ruby_symbols.h"
+#include "ruby.h"
+
+void* ruby_resolv(unsigned char* p_base, const char* symbol_name) {
+	VALUE rb_mCymbol = rb_eval_string("Cymbol");
+	VALUE rb_str_symbol_name = rb_str_new2(symbol_name);
+
+	VALUE rb_offset = rb_funcall(rb_mCymbol,rb_intern("resolv"), 1, rb_str_symbol_name);
+
+	unsigned long long offset = FIX2LONG(rb_offset);
+
+	return (p_base + offset);
+}
+
+
+const char* current_libruby() {
+	VALUE rb_mCymbol = rb_eval_string("Cymbol");
+	VALUE rb_strSharedName = rb_funcall(rb_mCymbol,rb_intern("ruby_shared_name"), 0);
+
+	return rb_string_value_ptr(&rb_strSharedName);
+}
+

data/ext/rallhook_base/ruby_symbols.h

@@ -0,0 +1,28 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario/rallhook
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef __RUBY_SYMBOLS_H
+#define __RUBY_SYMBOLS_H
+
+void* ruby_resolv(unsigned char* p_base, const char* symbol_name);
+const char* current_libruby();
+
+#endif

data/ext/rallhook_base/ruby_version.h

@@ -0,0 +1,21 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario/rallhook
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+

data/lib/rallhook/thread_hook.rb

@@ -0,0 +1,37 @@
+=begin
+
+This file is part of the rallhook project, http://github.com/tario/
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+class Thread
+
+  class << self
+    alias :original_new :new
+
+    private :original_new
+
+    def new
+      parent = current
+      original_new do
+        parent.acquire_attributes do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/rallhook.rb

@@ -0,0 +1,384 @@
+=begin
+
+This file is part of the rallhook project, http://github.com/tario/
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+require "rubygems"
+require "rallhook_base"
+require "rallhook/thread_hook"
+
+module RallHook
+#
+#Internal class used for return method redirection messages
+#Example:
+# ...
+# class X
+#   def foo
+#   end
+# end
+# def handle_method
+#   return RallHook::Redirect.new(X, X.new, :foo)
+# end
+# ...
+#
+#Note: Use x.redirect(:foo) instead (see Object#redirect )
+#
+  class Redirect
+		include MethodRedirect
+		
+		attr_reader :recv
+
+		def initialize(klass, recv, m, unhook = nil)
+			@klass = klass
+			@recv = recv
+			@method = m
+      @unhook = unhook
+		end
+	end
+#
+#Internal class used by RallHook::Helper#return_value
+#
+	class ReturnHolder
+	 	def initialize(v)
+			@value = v
+    end
+    def value(*x)
+      @value
+    end
+  end
+
+#
+#This module brings together classes and methods to facilitate the handling
+#
+	module Helper
+
+#Equivalent to:
+# recv.redirect(m, klass)
+		def redirect_call(klass, recv, m)
+			::RallHook::Redirect.new(klass,recv,m)
+		end
+
+#Return a value as return value of the method being handled
+#Example:
+#
+# include RallHook::Helper
+# def handle_method
+#   return_value(4) # all methods called returns 4
+# end
+#
+		def return_value(v)
+      recv = ReturnHolder.new(v)
+      klass = recv.class
+      m = :value
+			redirect_call(klass, recv, m)
+	  end
+
+#
+#This class acts as base to define classes that acts as receptors and wrappers of
+#redirected methods. Allows interception of methods with its parameters and controlled recall
+#in a hooking logic
+#
+#Example 1: basic modifications of arguments
+#
+# class MethodHandler
+#  include RallHook::Helper
+#
+#  class FooMethodWrapper < RallHook::MethodWrapper
+#    def call(foo_argument)
+#      original_call(foo_argument + 5) # add 5 in all calls to foo
+#    end
+#  end
+#
+#  def handle_method (klass,recv,m,method_id)
+#   if m == :foo
+#    FooMethodWrapper.redirect_handler(klass,recv,m,method_id)
+#   else
+#    nil
+#   end
+#  end
+# end
+#
+# ... hooking using MethodHandler ( see Hook#hook, README and examples)
+#
+#
+#Example 2: generic recall of methods
+#
+# class MethodHandler
+#  include RallHook::Helper
+#
+#  class GenericMethodWrapper < RallHook::MethodWrapper
+#    def call(*x)
+#      # call with reyield if block_given
+#      if block_given?
+#        original_call(*x) do |*a|
+#          yield(*a)
+#        end
+#      else
+#        original_call(*x)
+#      end
+#    end
+#  end
+#
+#  def handle_method (klass,recv,m,method_id)
+#    return GenericMethodWrapper.redirect_handler(klass,recv,m,method_id)
+#  end
+# end
+#
+# ... hooking using MethodHandler ( see Hook#hook, README and examples)
+#
+#
+    class MethodWrapper
+
+      attr_accessor :klass, :recv, :method_name, :method_id
+
+#Reactivate the hook status to intercept methods
+#Allow to pass a block to enable the hook status only in that block
+#
+#Example:
+# class MethodHandler
+#  include RallHook::Helper
+#
+#  class FooMethodWrapper < RallHook::MethodWrapper
+#    def call(foo_argument)
+#      original_call(foo_argument + 5) # add 5 in all calls to foo
+#      rehook do  # the print "hello world hooked" are intercepted too
+#         print "hello world hooked\n"
+#      end
+#    end
+#  end
+#
+#  ... definition of handle_method that use  FooMethodWrapper as redirect, etc...
+#
+#Note: is not necesary to use rehook to hook the nested calls in original_call
+#MethodWrapper#original_call does that internally
+#
+      def rehook
+        if block_given?
+          ::RallHook::Hook.rehook do
+            yield
+          end
+        else
+          ::RallHook::Hook.rehook
+        end
+      end
+
+#
+#Same as Hook#from
+#
+      def from(a)
+        ::RallHook::Hook.from(a)
+        self
+      end
+
+#
+#Recall the original method(specified in initialization parameters)
+#
+      def original_call(*args)
+       mname = self.method_name
+       mklass = self.klass
+       mid = self.method_id
+       recv_ = self.recv
+
+       # original calls over the shadow of the class, not the original one
+       m = recv_.specific_method(mklass.shadow,mname)
+
+       if block_given?
+         from(3).rehook do
+           m.call(*args) do |*blockargs|
+             yield(*blockargs)
+           end
+         end
+       else
+         from(3).rehook do
+           m.call(*args)
+         end
+       end
+      end
+
+#
+#Target of redirection, should be implemented to intercept the call
+#
+      def call(*args)
+      end
+
+      def call_with_rehook(*args)
+        if block_given?
+          call(*args) do |*x|
+            yield(*x)
+          end
+        else
+          call(*args)
+        end
+      ensure
+        rehook
+      end
+
+#
+#Makes a redirect_handler to wrap a method call with this MethodWrapper. Example:
+#
+# FooMethodWrapper.redirect_handler(klass,recv,m,method_id)
+#
+      def self.redirect_handler(klass,recv,method_name, method_id)
+        if method_name
+
+          mw = self.new
+          mw.klass = klass
+          mw.recv = recv
+          mw.method_name = method_name
+          mw.method_id = method_id
+          if block_given?
+            yield(mw)
+          end
+          mw.redirect_with_unhook(:call_with_rehook)
+        else
+          nil
+        end
+      end
+
+    end
+  end
+
+
+
+class HookHandler
+
+#default method_handler of a Hook does nothing with any method call
+  def handle_method
+    nil
+  end
+
+#enable the hook. Example
+#
+#  class MethodHandler < Hook
+#    def handle_method
+#      nil # do nothing
+#    end
+#  end
+#
+#  MethodHandler.hook do
+#     print "hello world\n"
+#  end
+#
+
+  def hook
+    if block_given?
+      ::RallHook::Hook.hook self do
+        yield
+      end
+    else
+      ::RallHook::Hook.hook self
+    end
+  end
+
+#Instance handler and activate the hook
+#Example:
+#
+#  class MethodHandler < Hook
+#    def handle_method
+#      nil # do nothing
+#    end
+#  end
+#
+#  MethodHandler.hook do
+#    print "hello world\n"
+#  end
+
+  def self.hook
+    if block_given?
+      self.new.hook do
+        yield
+      end
+    else
+      self.new.hook
+    end
+  end
+end
+
+
+
+end
+
+# To facilitate the use of hooking/redirection features,
+# rallhook defines some methods in the Object class
+#
+
+class Object
+
+
+# Same as redirect, but disable the hook/interception of methods (dont call handle_redirect) before
+# make the call, the hook status may be restored with Hook#rehook
+# Anyway, it is desirable to use MethodWrapper instead to "wrap" method calls
+#
+# see RallHook::Helper::MethodWrapper
+#
+  def redirect_with_unhook(method_name, klass = nil)
+    if klass
+      ::RallHook::Redirect.new(klass,self,method_name,true)
+    else
+      ::RallHook::Redirect.new(self.class,self,method_name,true)
+    end
+
+  end
+
+# Generates a redirect message to return it in handle_method to cause the redirection of
+# the method that is beign processed with the object as receiver, the method_name the new target
+# and the class as second parameter if specified
+#
+# Example:
+#   class X
+#     def foo(*args)
+#     end
+#   end
+#
+#   class MethodHandler
+#     @@x = x.new
+#     def handle_method(klass, recv, m , method_id)
+#       if m == :bar then
+#         # redirect bar calls to foo in x
+#         return x.redirect(:foo)
+#       end
+#       nil # do nothing
+#     end
+#   end
+#
+#   # hook using MethodHandler, etc... (see README and examples)
+#
+#
+  def redirect(method_name, klass = nil)
+		if klass
+			::RallHook::Redirect.new(klass,self,method_name)
+		else
+			::RallHook::Redirect.new(self.class,self,method_name)
+		end
+  end
+
+  def specific_method(arg1, arg2=nil)
+    if arg2
+      method_name = arg2
+      klass = arg1
+
+      if instance_of? Class
+        method(method_name)
+      else
+        klass.shadow.instance_method(method_name).unchecked_bind(self)
+      end
+    else
+      method(arg1)
+    end
+  end
+end