scratch: pydershell/pydershell.py comparison

comparison pydershell/pydershell.py @ 21:1950b0b5bcd8

It's now possible to expose python class instances to JS, if they're declared the right way (for security purposes).

author	Atul Varma <varmaa@toolness.com>
date	Mon, 07 Sep 2009 15:33:35 -0700
parents	8dd18f864351
children	9413bebf2ee6

comparison

equal deleted inserted replaced

-:8dd18f864351
+:1950b0b5bcd8
 import sys
 import time
 import threading
 import traceback
 import weakref
+import types
 import pydermonkey
 class ContextWatchdogThread(threading.Thread):
 """
 pass
 js_stack = js_stack['caller']
 lines.insert(0, "Traceback (most recent call last):")
 return '\n'.join(lines)
-class JSSandbox(object):
+class JsExposedObject(object):
+"""
+Trivial base/mixin class for any Python classes that choose to
+expose themselves to JS code.
+"""
+pass
+class JsSandbox(object):
 """
 A JS runtime and associated functionality capable of securely
 loading and executing scripts.
 """
 self.cx = cx
 self.curr_exc = None
 self.py_stack = None
 self.js_stack = None
 self.__py_to_js = {}
+self.__type_protos = {}
 self.root = self.wrap_jsobject(root, root)
 def finish(self):
 for jsobj in self.__py_to_js.values():
 self.cx.clear_object_private(jsobj)
 del self.__py_to_js
+del self.__type_protos
 del self.curr_exc
 del self.py_stack
 del self.js_stack
 del self.cx
 del self.rt
 if self.curr_exc != curr_exc:
 self.curr_exc = curr_exc
 self.py_stack = traceback.extract_stack()
 self.js_stack = cx.get_stack()
-def __wrap_pycallable(self, func):
+def __wrap_pycallable(self, func, pyproto=None):
 if func in self.__py_to_js:
 return self.__py_to_js[func]
 if hasattr(func, '__name__'):
 name = func.__name__
 else:
 name = ""
-def wrapper(func_cx, this, args):
+if pyproto:
-try:
+def wrapper(func_cx, this, args):
-arglist = []
+try:
-for arg in args:
+arglist = []
-arglist.append(self.wrap_jsobject(arg))
+for arg in args:
-# TODO: Fill in extra required params with pymonkey.undefined?
+arglist.append(self.wrap_jsobject(arg))
-# or automatically throw an exception to calling js code?
+instance = func_cx.get_object_private(this)
-return func(*arglist)
+if instance is None or not isinstance(instance, pyproto):
-except pydermonkey.error:
+raise pydermonkey.error("Method type mismatch")
-raise
-except Exception:
+# TODO: Fill in extra required params with
-raise InternalError()
+# pymonkey.undefined?  or automatically throw an
+# exception to calling js code?
+return self.wrap_pyobject(func(instance, *arglist))
+except pydermonkey.error:
+raise
+except Exception:
+raise InternalError()
+else:
+def wrapper(func_cx, this, args):
+try:
+arglist = []
+for arg in args:
+arglist.append(self.wrap_jsobject(arg))
+# TODO: Fill in extra required params with
+# pymonkey.undefined?  or automatically throw an
+# exception to calling js code?
+return self.wrap_pyobject(func(*arglist))
+except pydermonkey.error:
+raise
+except Exception:
+raise InternalError()
 wrapper.wrapped_pyobject = func
 wrapper.__name__ = name
 jsfunc = self.cx.new_function(wrapper, name)
 self.__py_to_js[func] = jsfunc
 return jsfunc
+def __wrap_pyinstance(self, value):
+pyproto = type(value)
+if pyproto not in self.__type_protos:
+jsproto = self.cx.new_object()
+for name in dir(pyproto):
+attr = getattr(pyproto, name)
+if (isinstance(attr, types.UnboundMethodType) and
+hasattr(attr, '__jsexposed__') and
+attr.__jsexposed__):
+jsmethod = self.__wrap_pycallable(attr, pyproto)
+self.cx.define_property(jsproto, name, jsmethod)
+self.__type_protos[pyproto] = jsproto
+return self.cx.new_object(value, self.__type_protos[pyproto])
 def wrap_pyobject(self, value):
+if (isinstance(value, (int, basestring, float, bool)) or
+value is pydermonkey.undefined or
+value is None):
+return value
 if isinstance(value, SafeJsObjectWrapper):
 # It's already wrapped, just unwrap it.
 return value.wrapped_jsobject
 elif callable(value):
 return self.__wrap_pycallable(value)
-elif isinstance(value, object):
+elif isinstance(value, JsExposedObject):
-raise NotImplementedError("TODO")
+return self.__wrap_pyinstance(value)
 else:
-# Here's hoping it's a primitive value.
+raise TypeError("Can't expose objects of type '' to JS." %
-return value
+type(value).__name__)
 def wrap_jsobject(self, jsvalue, this=None):
 if this is None:
 this = self.root.wrapped_jsobject
 if isinstance(jsvalue, pydermonkey.Function):
 if jsvalue.is_python:
 # It's a Python function, just unwrap it.
 return self.cx.get_object_private(jsvalue).wrapped_pyobject
 return SafeJsFunctionWrapper(self, jsvalue, this)
 elif isinstance(jsvalue, pydermonkey.Object):
-return SafeJsObjectWrapper(self, jsvalue, this)
+# It's a wrapped Python object instance, just unwrap it.
+instance = self.cx.get_object_private(jsvalue)
+if instance:
+if not isinstance(instance, JsExposedObject):
+raise AssertionError("Object private is not of type "
+"JsExposedObject")
+return instance
+else:
+return SafeJsObjectWrapper(self, jsvalue, this)
 else:
 # It's a primitive value.
 return jsvalue
 def run_script(self, filename):
 traceback.print_tb(e.exc_info[2])
 print e.exc_info[1]
 return retval
 if __name__ == '__main__':
-sandbox = JSSandbox()
+sandbox = JsSandbox()
+class Baz(JsExposedObject):
+def woozle(self, blap):
+return blap + 5
+woozle.__jsexposed__ = True
+def baz():
+return Baz()
+sandbox.root.baz = baz
 def bar(obj):
 print obj.bar()
 sandbox.root.bar = bar
 def foo(callback):
 return callback()
 sandbox.root.foo = foo
+def ensureBaz(baz):
+if not isinstance(baz, Baz):
+print "Uhoh"
+else:
+print "ok"
+sandbox.root.ensureBaz = ensureBaz
 def jsprint(string):
 print string
 sandbox.root['print'] = jsprint

Mercurial > scratch

comparison pydershell/pydershell.py @ 21:1950b0b5bcd8