mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-09-18 22:50:26 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 11

A few lines were indented using tabs instead of spaces -- fix them.

Browse source
This commit is contained in:
Guido van Rossum 1998-03-26 22:10:50 +00:00
parent 45e2fbc2e7
commit 3ec38f0ee4
1 changed files with 178 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

356
Lib/rexec.py
View file

@ -26,84 +26,84 @@ import ihooks
class FileBase: class FileBase:
ok_file_methods = ('fileno', 'flush', 'isatty', 'read', 'readline', ok_file_methods = ('fileno', 'flush', 'isatty', 'read', 'readline',
'readlines', 'seek', 'tell', 'write', 'writelines') 'readlines', 'seek', 'tell', 'write', 'writelines')
class FileWrapper(FileBase): class FileWrapper(FileBase):
# XXX This is just like a Bastion -- should use that! # XXX This is just like a Bastion -- should use that!
def __init__(self, f): def __init__(self, f):
self.f = f self.f = f
for m in self.ok_file_methods: for m in self.ok_file_methods:
if not hasattr(self, m) and hasattr(f, m): if not hasattr(self, m) and hasattr(f, m):
setattr(self, m, getattr(f, m)) setattr(self, m, getattr(f, m))
def close(self): def close(self):
self.flush() self.flush()
TEMPLATE = """ TEMPLATE = """
def %s(self, *args): def %s(self, *args):
return apply(getattr(self.mod, self.name).%s, args) return apply(getattr(self.mod, self.name).%s, args)
""" """
class FileDelegate(FileBase): class FileDelegate(FileBase):
def __init__(self, mod, name): def __init__(self, mod, name):
self.mod = mod self.mod = mod
self.name = name self.name = name
for m in FileBase.ok_file_methods + ('close',): for m in FileBase.ok_file_methods + ('close',):
exec TEMPLATE % (m, m) exec TEMPLATE % (m, m)
class RHooks(ihooks.Hooks): class RHooks(ihooks.Hooks):
def __init__(self, *args): def __init__(self, *args):
# Hacks to support both old and new interfaces: # Hacks to support both old and new interfaces:
# old interface was RHooks(rexec[, verbose]) # old interface was RHooks(rexec[, verbose])
# new interface is RHooks([verbose]) # new interface is RHooks([verbose])
verbose = 0 verbose = 0
rexec = None rexec = None
if args and type(args[-1]) == type(0): if args and type(args[-1]) == type(0):
verbose = args[-1] verbose = args[-1]
args = args[:-1] args = args[:-1]
if args and hasattr(args[0], '__class__'): if args and hasattr(args[0], '__class__'):
rexec = args[0] rexec = args[0]
args = args[1:] args = args[1:]
if args: if args:
raise TypeError, "too many arguments" raise TypeError, "too many arguments"
ihooks.Hooks.__init__(self, verbose) ihooks.Hooks.__init__(self, verbose)
self.rexec = rexec self.rexec = rexec
def set_rexec(self, rexec): def set_rexec(self, rexec):
# Called by RExec instance to complete initialization # Called by RExec instance to complete initialization
self.rexec = rexec self.rexec = rexec
def is_builtin(self, name): def is_builtin(self, name):
return self.rexec.is_builtin(name) return self.rexec.is_builtin(name)
def init_builtin(self, name): def init_builtin(self, name):
m = __import__(name) m = __import__(name)
return self.rexec.copy_except(m, ()) return self.rexec.copy_except(m, ())
def init_frozen(self, name): raise SystemError, "don't use this" def init_frozen(self, name): raise SystemError, "don't use this"
def load_source(self, *args): raise SystemError, "don't use this" def load_source(self, *args): raise SystemError, "don't use this"
def load_compiled(self, *args): raise SystemError, "don't use this" def load_compiled(self, *args): raise SystemError, "don't use this"
def load_dynamic(self, name, filename, file): def load_dynamic(self, name, filename, file):
return self.rexec.load_dynamic(name, filename, file) return self.rexec.load_dynamic(name, filename, file)
def add_module(self, name): def add_module(self, name):
return self.rexec.add_module(name) return self.rexec.add_module(name)
def modules_dict(self): def modules_dict(self):
return self.rexec.modules return self.rexec.modules
def default_path(self): def default_path(self):
return self.rexec.modules['sys'].path return self.rexec.modules['sys'].path
class RModuleLoader(ihooks.FancyModuleLoader): class RModuleLoader(ihooks.FancyModuleLoader):
@ -119,8 +119,8 @@ class RModuleImporter(ihooks.ModuleImporter):
def reload(self, module, path=None): def reload(self, module, path=None):
if path is None and hasattr(module, '__filename__'): if path is None and hasattr(module, '__filename__'):
head, tail = os.path.split(module.__filename__) head, tail = os.path.split(module.__filename__)
path = [os.path.join(head, '')] path = [os.path.join(head, '')]
return ihooks.ModuleImporter.reload(self, module, path) return ihooks.ModuleImporter.reload(self, module, path)
@ -128,149 +128,149 @@ class RExec(ihooks._Verbose):
"""Restricted Execution environment.""" """Restricted Execution environment."""
ok_path = tuple(sys.path) # That's a policy decision ok_path = tuple(sys.path) # That's a policy decision
ok_builtin_modules = ('audioop', 'array', 'binascii', ok_builtin_modules = ('audioop', 'array', 'binascii',
'cmath', 'errno', 'imageop', 'cmath', 'errno', 'imageop',
'marshal', 'math', 'md5', 'operator', 'marshal', 'math', 'md5', 'operator',
'parser', 'regex', 'pcre', 'rotor', 'select', 'parser', 'regex', 'pcre', 'rotor', 'select',
'strop', 'struct', 'time') 'strop', 'struct', 'time')
ok_posix_names = ('error', 'fstat', 'listdir', 'lstat', 'readlink', ok_posix_names = ('error', 'fstat', 'listdir', 'lstat', 'readlink',
'stat', 'times', 'uname', 'getpid', 'getppid', 'stat', 'times', 'uname', 'getpid', 'getppid',
'getcwd', 'getuid', 'getgid', 'geteuid', 'getegid') 'getcwd', 'getuid', 'getgid', 'geteuid', 'getegid')
ok_sys_names = ('ps1', 'ps2', 'copyright', 'version', ok_sys_names = ('ps1', 'ps2', 'copyright', 'version',
'platform', 'exit', 'maxint') 'platform', 'exit', 'maxint')
nok_builtin_names = ('open', 'reload', '__import__') nok_builtin_names = ('open', 'reload', '__import__')
def __init__(self, hooks = None, verbose = 0): def __init__(self, hooks = None, verbose = 0):
ihooks._Verbose.__init__(self, verbose) ihooks._Verbose.__init__(self, verbose)
# XXX There's a circular reference here: # XXX There's a circular reference here:
self.hooks = hooks or RHooks(verbose) self.hooks = hooks or RHooks(verbose)
self.hooks.set_rexec(self) self.hooks.set_rexec(self)
self.modules = {} self.modules = {}
self.ok_dynamic_modules = self.ok_builtin_modules self.ok_dynamic_modules = self.ok_builtin_modules
list = [] list = []
for mname in self.ok_builtin_modules: for mname in self.ok_builtin_modules:
if mname in sys.builtin_module_names: if mname in sys.builtin_module_names:
list.append(mname) list.append(mname)
self.ok_builtin_modules = tuple(list) self.ok_builtin_modules = tuple(list)
self.set_trusted_path() self.set_trusted_path()
self.make_builtin() self.make_builtin()
self.make_initial_modules() self.make_initial_modules()
# make_sys must be last because it adds the already created # make_sys must be last because it adds the already created
# modules to its builtin_module_names # modules to its builtin_module_names
self.make_sys() self.make_sys()
self.loader = RModuleLoader(self.hooks, verbose) self.loader = RModuleLoader(self.hooks, verbose)
self.importer = RModuleImporter(self.loader, verbose) self.importer = RModuleImporter(self.loader, verbose)
def set_trusted_path(self): def set_trusted_path(self):
# Set the path from which dynamic modules may be loaded. # Set the path from which dynamic modules may be loaded.
# Those dynamic modules must also occur in ok_builtin_modules # Those dynamic modules must also occur in ok_builtin_modules
self.trusted_path = filter(os.path.isabs, sys.path) self.trusted_path = filter(os.path.isabs, sys.path)
def load_dynamic(self, name, filename, file): def load_dynamic(self, name, filename, file):
if name not in self.ok_dynamic_modules: if name not in self.ok_dynamic_modules:
raise ImportError, "untrusted dynamic module: %s" % name raise ImportError, "untrusted dynamic module: %s" % name
if sys.modules.has_key(name): if sys.modules.has_key(name):
src = sys.modules[name] src = sys.modules[name]
else: else:
import imp import imp
src = imp.load_dynamic(name, filename, file) src = imp.load_dynamic(name, filename, file)
dst = self.copy_except(src, []) dst = self.copy_except(src, [])
return dst return dst
def make_initial_modules(self): def make_initial_modules(self):
self.make_main() self.make_main()
self.make_osname() self.make_osname()
# Helpers for RHooks # Helpers for RHooks
def is_builtin(self, mname): def is_builtin(self, mname):
return mname in self.ok_builtin_modules return mname in self.ok_builtin_modules
# The make_* methods create specific built-in modules # The make_* methods create specific built-in modules
def make_builtin(self): def make_builtin(self):
m = self.copy_except(__builtin__, self.nok_builtin_names) m = self.copy_except(__builtin__, self.nok_builtin_names)
m.__import__ = self.r_import m.__import__ = self.r_import
m.reload = self.r_reload m.reload = self.r_reload
m.open = self.r_open m.open = self.r_open
def make_main(self): def make_main(self):
m = self.add_module('__main__') m = self.add_module('__main__')
def make_osname(self): def make_osname(self):
osname = os.name osname = os.name
src = __import__(osname) src = __import__(osname)
dst = self.copy_only(src, self.ok_posix_names) dst = self.copy_only(src, self.ok_posix_names)
dst.environ = e = {} dst.environ = e = {}
for key, value in os.environ.items(): for key, value in os.environ.items():
e[key] = value e[key] = value
def make_sys(self): def make_sys(self):
m = self.copy_only(sys, self.ok_sys_names) m = self.copy_only(sys, self.ok_sys_names)
m.modules = self.modules m.modules = self.modules
m.argv = ['RESTRICTED'] m.argv = ['RESTRICTED']
m.path = map(None, self.ok_path) m.path = map(None, self.ok_path)
m = self.modules['sys'] m = self.modules['sys']
l = self.modules.keys() + list(self.ok_builtin_modules) l = self.modules.keys() + list(self.ok_builtin_modules)
l.sort() l.sort()
m.builtin_module_names = tuple(l) m.builtin_module_names = tuple(l)
# The copy_* methods copy existing modules with some changes # The copy_* methods copy existing modules with some changes
def copy_except(self, src, exceptions): def copy_except(self, src, exceptions):
dst = self.copy_none(src) dst = self.copy_none(src)
for name in dir(src): for name in dir(src):
setattr(dst, name, getattr(src, name)) setattr(dst, name, getattr(src, name))
for name in exceptions: for name in exceptions:
try: try:
delattr(dst, name) delattr(dst, name)
except AttributeError: except AttributeError:
pass pass
return dst return dst
def copy_only(self, src, names): def copy_only(self, src, names):
dst = self.copy_none(src) dst = self.copy_none(src)
for name in names: for name in names:
try: try:
value = getattr(src, name) value = getattr(src, name)
except AttributeError: except AttributeError:
continue continue
setattr(dst, name, value) setattr(dst, name, value)
return dst return dst
def copy_none(self, src): def copy_none(self, src):
return self.add_module(src.__name__) return self.add_module(src.__name__)
# Add a module -- return an existing module or create one # Add a module -- return an existing module or create one
def add_module(self, mname): def add_module(self, mname):
if self.modules.has_key(mname): if self.modules.has_key(mname):
return self.modules[mname] return self.modules[mname]
self.modules[mname] = m = self.hooks.new_module(mname) self.modules[mname] = m = self.hooks.new_module(mname)
m.__builtins__ = self.modules['__builtin__'] m.__builtins__ = self.modules['__builtin__']
return m return m
# The r* methods are public interfaces # The r* methods are public interfaces
def r_exec(self, code): def r_exec(self, code):
m = self.add_module('__main__') m = self.add_module('__main__')
exec code in m.__dict__ exec code in m.__dict__
def r_eval(self, code): def r_eval(self, code):
m = self.add_module('__main__') m = self.add_module('__main__')
return eval(code, m.__dict__) return eval(code, m.__dict__)
def r_execfile(self, file): def r_execfile(self, file):
m = self.add_module('__main__') m = self.add_module('__main__')
return execfile(file, m.__dict__) return execfile(file, m.__dict__)
def r_import(self, mname, globals={}, locals={}, fromlist=[]): def r_import(self, mname, globals={}, locals={}, fromlist=[]):
return self.importer.import_module(mname, globals, locals, fromlist) return self.importer.import_module(mname, globals, locals, fromlist)
def r_reload(self, m): def r_reload(self, m):
return self.importer.reload(m) return self.importer.reload(m)
@ -282,33 +282,33 @@ class RExec(ihooks._Verbose):
def make_delegate_files(self): def make_delegate_files(self):
s = self.modules['sys'] s = self.modules['sys']
self.delegate_stdin = FileDelegate(s, 'stdin') self.delegate_stdin = FileDelegate(s, 'stdin')
self.delegate_stdout = FileDelegate(s, 'stdout') self.delegate_stdout = FileDelegate(s, 'stdout')
self.delegate_stderr = FileDelegate(s, 'stderr') self.delegate_stderr = FileDelegate(s, 'stderr')
self.restricted_stdin = FileWrapper(sys.stdin) self.restricted_stdin = FileWrapper(sys.stdin)
self.restricted_stdout = FileWrapper(sys.stdout) self.restricted_stdout = FileWrapper(sys.stdout)
self.restricted_stderr = FileWrapper(sys.stderr) self.restricted_stderr = FileWrapper(sys.stderr)
def set_files(self): def set_files(self):
if not hasattr(self, 'save_stdin'): if not hasattr(self, 'save_stdin'):
self.save_files() self.save_files()
if not hasattr(self, 'delegate_stdin'): if not hasattr(self, 'delegate_stdin'):
self.make_delegate_files() self.make_delegate_files()
s = self.modules['sys'] s = self.modules['sys']
s.stdin = self.restricted_stdin s.stdin = self.restricted_stdin
s.stdout = self.restricted_stdout s.stdout = self.restricted_stdout
s.stderr = self.restricted_stderr s.stderr = self.restricted_stderr
sys.stdin = self.delegate_stdin sys.stdin = self.delegate_stdin
sys.stdout = self.delegate_stdout sys.stdout = self.delegate_stdout
sys.stderr = self.delegate_stderr sys.stderr = self.delegate_stderr
def reset_files(self): def reset_files(self):
self.restore_files() self.restore_files()
s = self.modules['sys'] s = self.modules['sys']
self.restricted_stdin = s.stdin self.restricted_stdin = s.stdin
self.restricted_stdout = s.stdout self.restricted_stdout = s.stdout
self.restricted_stderr = s.stderr self.restricted_stderr = s.stderr
def save_files(self): def save_files(self):
self.save_stdin = sys.stdin self.save_stdin = sys.stdin
@ -316,20 +316,20 @@ class RExec(ihooks._Verbose):
self.save_stderr = sys.stderr self.save_stderr = sys.stderr
def restore_files(self): def restore_files(self):
sys.stdin = self.save_stdin sys.stdin = self.save_stdin
sys.stdout = self.save_stdout sys.stdout = self.save_stdout
sys.stderr = self.save_stderr sys.stderr = self.save_stderr
def s_apply(self, func, args=(), kw=None): def s_apply(self, func, args=(), kw=None):
self.save_files() self.save_files()
try: try:
self.set_files() self.set_files()
if kw: if kw:
r = apply(func, args, kw) r = apply(func, args, kw)
else: else:
r = apply(func, args) r = apply(func, args)
finally: finally:
self.restore_files() self.restore_files()
def s_exec(self, *args): def s_exec(self, *args):
self.s_apply(self.r_exec, args) self.s_apply(self.r_exec, args)
@ -363,20 +363,20 @@ def test():
print "*** RESTRICTED *** Python", sys.version print "*** RESTRICTED *** Python", sys.version
print sys.copyright print sys.copyright
while 1: while 1:
try: try:
try: try:
s = raw_input('>>> ') s = raw_input('>>> ')
except EOFError: except EOFError:
print print
break break
if s and s[0] != '#': if s and s[0] != '#':
s = s + '\n' s = s + '\n'
c = compile(s, '<stdin>', 'single') c = compile(s, '<stdin>', 'single')
r.r_exec(c) r.r_exec(c)
except SystemExit, n: except SystemExit, n:
sys.exit(n) sys.exit(n)
except: except:
traceback.print_exc() traceback.print_exc()
if __name__ == '__main__': if __name__ == '__main__':