home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_688 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  15.0 KB  |  460 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from warnings import warnpy3k
  5. warnpy3k('the rexec module has been removed in Python 3.0', stacklevel = 2)
  6. del warnpy3k
  7. import sys
  8. import __builtin__
  9. import os
  10. import ihooks
  11. import imp
  12. __all__ = [
  13.     'RExec']
  14.  
  15. class FileBase:
  16.     ok_file_methods = ('fileno', 'flush', 'isatty', 'read', 'readline', 'readlines', 'seek', 'tell', 'write', 'writelines', 'xreadlines', '__iter__')
  17.  
  18.  
  19. class FileWrapper(FileBase):
  20.     
  21.     def __init__(self, f):
  22.         for m in self.ok_file_methods:
  23.             if not hasattr(self, m) and hasattr(f, m):
  24.                 setattr(self, m, getattr(f, m))
  25.                 continue
  26.         
  27.  
  28.     
  29.     def close(self):
  30.         self.flush()
  31.  
  32.  
  33. TEMPLATE = '\ndef %s(self, *args):\n        return getattr(self.mod, self.name).%s(*args)\n'
  34.  
  35. class FileDelegate(FileBase):
  36.     
  37.     def __init__(self, mod, name):
  38.         self.mod = mod
  39.         self.name = name
  40.  
  41.     for m in FileBase.ok_file_methods + ('close',):
  42.         exec TEMPLATE % (m, m)
  43.     
  44.  
  45.  
  46. class RHooks(ihooks.Hooks):
  47.     
  48.     def __init__(self, *args):
  49.         verbose = 0
  50.         rexec = None
  51.         if args and type(args[-1]) == type(0):
  52.             verbose = args[-1]
  53.             args = args[:-1]
  54.         
  55.         if args and hasattr(args[0], '__class__'):
  56.             rexec = args[0]
  57.             args = args[1:]
  58.         
  59.         if args:
  60.             raise TypeError, 'too many arguments'
  61.         args
  62.         ihooks.Hooks.__init__(self, verbose)
  63.         self.rexec = rexec
  64.  
  65.     
  66.     def set_rexec(self, rexec):
  67.         self.rexec = rexec
  68.  
  69.     
  70.     def get_suffixes(self):
  71.         return self.rexec.get_suffixes()
  72.  
  73.     
  74.     def is_builtin(self, name):
  75.         return self.rexec.is_builtin(name)
  76.  
  77.     
  78.     def init_builtin(self, name):
  79.         m = __import__(name)
  80.         return self.rexec.copy_except(m, ())
  81.  
  82.     
  83.     def init_frozen(self, name):
  84.         raise SystemError, "don't use this"
  85.  
  86.     
  87.     def load_source(self, *args):
  88.         raise SystemError, "don't use this"
  89.  
  90.     
  91.     def load_compiled(self, *args):
  92.         raise SystemError, "don't use this"
  93.  
  94.     
  95.     def load_package(self, *args):
  96.         raise SystemError, "don't use this"
  97.  
  98.     
  99.     def load_dynamic(self, name, filename, file):
  100.         return self.rexec.load_dynamic(name, filename, file)
  101.  
  102.     
  103.     def add_module(self, name):
  104.         return self.rexec.add_module(name)
  105.  
  106.     
  107.     def modules_dict(self):
  108.         return self.rexec.modules
  109.  
  110.     
  111.     def default_path(self):
  112.         return self.rexec.modules['sys'].path
  113.  
  114.  
  115. RModuleLoader = ihooks.FancyModuleLoader
  116. RModuleImporter = ihooks.ModuleImporter
  117.  
  118. class RExec(ihooks._Verbose):
  119.     ok_path = tuple(sys.path)
  120.     ok_builtin_modules = ('audioop', 'array', 'binascii', 'cmath', 'errno', 'imageop', 'marshal', 'math', 'md5', 'operator', 'parser', 'select', 'sha', '_sre', 'strop', 'struct', 'time', '_weakref')
  121.     ok_posix_names = ('error', 'fstat', 'listdir', 'lstat', 'readlink', 'stat', 'times', 'uname', 'getpid', 'getppid', 'getcwd', 'getuid', 'getgid', 'geteuid', 'getegid')
  122.     ok_sys_names = ('byteorder', 'copyright', 'exit', 'getdefaultencoding', 'getrefcount', 'hexversion', 'maxint', 'maxunicode', 'platform', 'ps1', 'ps2', 'version', 'version_info')
  123.     nok_builtin_names = ('open', 'file', 'reload', '__import__')
  124.     ok_file_types = (imp.C_EXTENSION, imp.PY_SOURCE)
  125.     
  126.     def __init__(self, hooks = None, verbose = 0):
  127.         raise RuntimeError, 'This code is not secure in Python 2.2 and later'
  128.         ihooks._Verbose.__init__(self, verbose)
  129.         if not hooks:
  130.             pass
  131.         self.hooks = RHooks(verbose)
  132.         self.hooks.set_rexec(self)
  133.         self.modules = { }
  134.         self.ok_dynamic_modules = self.ok_builtin_modules
  135.         list = []
  136.         for mname in self.ok_builtin_modules:
  137.             if mname in sys.builtin_module_names:
  138.                 list.append(mname)
  139.                 continue
  140.         
  141.         self.ok_builtin_modules = tuple(list)
  142.         self.set_trusted_path()
  143.         self.make_builtin()
  144.         self.make_initial_modules()
  145.         self.make_sys()
  146.         self.loader = RModuleLoader(self.hooks, verbose)
  147.         self.importer = RModuleImporter(self.loader, verbose)
  148.  
  149.     
  150.     def set_trusted_path(self):
  151.         self.trusted_path = filter(os.path.isabs, sys.path)
  152.  
  153.     
  154.     def load_dynamic(self, name, filename, file):
  155.         if name not in self.ok_dynamic_modules:
  156.             raise ImportError, 'untrusted dynamic module: %s' % name
  157.         name not in self.ok_dynamic_modules
  158.         if name in sys.modules:
  159.             src = sys.modules[name]
  160.         else:
  161.             src = imp.load_dynamic(name, filename, file)
  162.         dst = self.copy_except(src, [])
  163.         return dst
  164.  
  165.     
  166.     def make_initial_modules(self):
  167.         self.make_main()
  168.         self.make_osname()
  169.  
  170.     
  171.     def get_suffixes(self):
  172.         return _[1]
  173.  
  174.     
  175.     def is_builtin(self, mname):
  176.         return mname in self.ok_builtin_modules
  177.  
  178.     
  179.     def make_builtin(self):
  180.         m = self.copy_except(__builtin__, self.nok_builtin_names)
  181.         m.__import__ = self.r_import
  182.         m.reload = self.r_reload
  183.         m.open = m.file = self.r_open
  184.  
  185.     
  186.     def make_main(self):
  187.         m = self.add_module('__main__')
  188.  
  189.     
  190.     def make_osname(self):
  191.         osname = os.name
  192.         src = __import__(osname)
  193.         dst = self.copy_only(src, self.ok_posix_names)
  194.         dst.environ = e = { }
  195.         for key, value in os.environ.items():
  196.             e[key] = value
  197.         
  198.  
  199.     
  200.     def make_sys(self):
  201.         m = self.copy_only(sys, self.ok_sys_names)
  202.         m.modules = self.modules
  203.         m.argv = [
  204.             'RESTRICTED']
  205.         m.path = map(None, self.ok_path)
  206.         m.exc_info = self.r_exc_info
  207.         m = self.modules['sys']
  208.         l = self.modules.keys() + list(self.ok_builtin_modules)
  209.         l.sort()
  210.         m.builtin_module_names = tuple(l)
  211.  
  212.     
  213.     def copy_except(self, src, exceptions):
  214.         dst = self.copy_none(src)
  215.         for name in dir(src):
  216.             setattr(dst, name, getattr(src, name))
  217.         
  218.         for name in exceptions:
  219.             
  220.             try:
  221.                 delattr(dst, name)
  222.             continue
  223.             except AttributeError:
  224.                 continue
  225.             
  226.  
  227.         
  228.         return dst
  229.  
  230.     
  231.     def copy_only(self, src, names):
  232.         dst = self.copy_none(src)
  233.         for name in names:
  234.             
  235.             try:
  236.                 value = getattr(src, name)
  237.             except AttributeError:
  238.                 continue
  239.  
  240.             setattr(dst, name, value)
  241.         
  242.         return dst
  243.  
  244.     
  245.     def copy_none(self, src):
  246.         m = self.add_module(src.__name__)
  247.         m.__doc__ = src.__doc__
  248.         return m
  249.  
  250.     
  251.     def add_module(self, mname):
  252.         m = self.modules.get(mname)
  253.         if m is None:
  254.             self.modules[mname] = m = self.hooks.new_module(mname)
  255.         
  256.         m.__builtins__ = self.modules['__builtin__']
  257.         return m
  258.  
  259.     
  260.     def r_exec(self, code):
  261.         m = self.add_module('__main__')
  262.         exec code in m.__dict__
  263.  
  264.     
  265.     def r_eval(self, code):
  266.         m = self.add_module('__main__')
  267.         return eval(code, m.__dict__)
  268.  
  269.     
  270.     def r_execfile(self, file):
  271.         m = self.add_module('__main__')
  272.         execfile(file, m.__dict__)
  273.  
  274.     
  275.     def r_import(self, mname, globals = { }, locals = { }, fromlist = []):
  276.         return self.importer.import_module(mname, globals, locals, fromlist)
  277.  
  278.     
  279.     def r_reload(self, m):
  280.         return self.importer.reload(m)
  281.  
  282.     
  283.     def r_unload(self, m):
  284.         return self.importer.unload(m)
  285.  
  286.     
  287.     def make_delegate_files(self):
  288.         s = self.modules['sys']
  289.         self.delegate_stdin = FileDelegate(s, 'stdin')
  290.         self.delegate_stdout = FileDelegate(s, 'stdout')
  291.         self.delegate_stderr = FileDelegate(s, 'stderr')
  292.         self.restricted_stdin = FileWrapper(sys.stdin)
  293.         self.restricted_stdout = FileWrapper(sys.stdout)
  294.         self.restricted_stderr = FileWrapper(sys.stderr)
  295.  
  296.     
  297.     def set_files(self):
  298.         if not hasattr(self, 'save_stdin'):
  299.             self.save_files()
  300.         
  301.         if not hasattr(self, 'delegate_stdin'):
  302.             self.make_delegate_files()
  303.         
  304.         s = self.modules['sys']
  305.         s.stdin = self.restricted_stdin
  306.         s.stdout = self.restricted_stdout
  307.         s.stderr = self.restricted_stderr
  308.         sys.stdin = self.delegate_stdin
  309.         sys.stdout = self.delegate_stdout
  310.         sys.stderr = self.delegate_stderr
  311.  
  312.     
  313.     def reset_files(self):
  314.         self.restore_files()
  315.         s = self.modules['sys']
  316.         self.restricted_stdin = s.stdin
  317.         self.restricted_stdout = s.stdout
  318.         self.restricted_stderr = s.stderr
  319.  
  320.     
  321.     def save_files(self):
  322.         self.save_stdin = sys.stdin
  323.         self.save_stdout = sys.stdout
  324.         self.save_stderr = sys.stderr
  325.  
  326.     
  327.     def restore_files(self):
  328.         sys.stdin = self.save_stdin
  329.         sys.stdout = self.save_stdout
  330.         sys.stderr = self.save_stderr
  331.  
  332.     
  333.     def s_apply(self, func, args = (), kw = { }):
  334.         self.save_files()
  335.         
  336.         try:
  337.             self.set_files()
  338.             r = func(*args, **kw)
  339.         finally:
  340.             self.restore_files()
  341.  
  342.         return r
  343.  
  344.     
  345.     def s_exec(self, *args):
  346.         return self.s_apply(self.r_exec, args)
  347.  
  348.     
  349.     def s_eval(self, *args):
  350.         return self.s_apply(self.r_eval, args)
  351.  
  352.     
  353.     def s_execfile(self, *args):
  354.         return self.s_apply(self.r_execfile, args)
  355.  
  356.     
  357.     def s_import(self, *args):
  358.         return self.s_apply(self.r_import, args)
  359.  
  360.     
  361.     def s_reload(self, *args):
  362.         return self.s_apply(self.r_reload, args)
  363.  
  364.     
  365.     def s_unload(self, *args):
  366.         return self.s_apply(self.r_unload, args)
  367.  
  368.     
  369.     def r_open(self, file, mode = 'r', buf = -1):
  370.         mode = str(mode)
  371.         if mode not in ('r', 'rb'):
  372.             raise IOError, "can't open files for writing in restricted mode"
  373.         mode not in ('r', 'rb')
  374.         return open(file, mode, buf)
  375.  
  376.     
  377.     def r_exc_info(self):
  378.         (ty, va, tr) = sys.exc_info()
  379.         tr = None
  380.         return (ty, va, tr)
  381.  
  382.  
  383.  
  384. def test():
  385.     import getopt
  386.     import traceback
  387.     (opts, args) = getopt.getopt(sys.argv[1:], 'vt:')
  388.     verbose = 0
  389.     trusted = []
  390.     for o, a in opts:
  391.         if o == '-v':
  392.             verbose = verbose + 1
  393.         
  394.         if o == '-t':
  395.             trusted.append(a)
  396.             continue
  397.     
  398.     r = RExec(verbose = verbose)
  399.     if trusted:
  400.         r.ok_builtin_modules = r.ok_builtin_modules + tuple(trusted)
  401.     
  402.     if args:
  403.         r.modules['sys'].argv = args
  404.         r.modules['sys'].path.insert(0, os.path.dirname(args[0]))
  405.     else:
  406.         r.modules['sys'].path.insert(0, '')
  407.     fp = sys.stdin
  408.     if args and args[0] != '-':
  409.         
  410.         try:
  411.             fp = open(args[0])
  412.         except IOError:
  413.             msg = None
  414.             print "%s: can't open file %r" % (sys.argv[0], args[0])
  415.             return 1
  416.         
  417.  
  418.     None<EXCEPTION MATCH>IOError
  419.     if fp.isatty():
  420.         
  421.         try:
  422.             import readline
  423.         except ImportError:
  424.             pass
  425.  
  426.         import code
  427.         
  428.         class RestrictedConsole('RestrictedConsole', (code.InteractiveConsole,)):
  429.             
  430.             def runcode(self, co):
  431.                 self.locals['__builtins__'] = r.modules['__builtin__']
  432.                 r.s_apply(code.InteractiveConsole.runcode, (self, co))
  433.  
  434.  
  435.         
  436.         try:
  437.             RestrictedConsole(r.modules['__main__'].__dict__).interact()
  438.         except SystemExit:
  439.             n = None
  440.             return n
  441.         
  442.  
  443.     None<EXCEPTION MATCH>SystemExit
  444.     text = fp.read()
  445.     fp.close()
  446.     c = compile(text, fp.name, 'exec')
  447.     
  448.     try:
  449.         r.s_exec(c)
  450.     except SystemExit:
  451.         n = None
  452.         return n
  453.         traceback.print_exc()
  454.         return 1
  455.  
  456.  
  457. if __name__ == '__main__':
  458.     sys.exit(test())
  459.  
  460.