#############################################################################
#
# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE
#
##############################################################################

__version__='$Revision: 1.16.2.3 $'[11:-2]

import sys

import RestrictedPython
from RestrictedPython.Guards import safe_builtins, full_write_guard
from RestrictedPython.Utilities import utility_builtins
from RestrictedPython.Eval import RestrictionCapableEval
from SecurityManagement import getSecurityManager
from SecurityInfo import secureModule
from SimpleObjectPolicies import Containers, ContainerAssertions
from zExceptions import Unauthorized

_marker = []  # Create a new marker object.

safe_builtins = safe_builtins.copy()
safe_builtins.update(utility_builtins)

# AccessControl.Implementation inserts these names into this module as
# module globals:  aq_validate, guarded_getattr

def initialize(impl):
    # Called by AccessControl.Implementation.setImplementation()
    # whenever the selected implementation changes.
    global guarded_getattr
    guarded_getattr = impl.guarded_getattr
    safe_builtins['getattr'] = guarded_getattr


def guarded_hasattr(object, name):
    try:
        guarded_getattr(object, name)
    except (AttributeError, Unauthorized):
        return 0
    return 1
safe_builtins['hasattr'] = guarded_hasattr

SliceType = type(slice(0))
def guarded_getitem(object, index):
    if type(index) is SliceType:
        if index.step is not None:
            v = object[index]
        else:
            start = index.start
            stop = index.stop
            if start is None:
                start = 0
            if stop is None:
                v = object[start:]
            else:
                v = object[start:stop]
        # We don't guard slices.
        return v
    v = object[index]
    if Containers(type(object)) and Containers(type(v)):
        # Simple type.  Short circuit.
        return v
    if getSecurityManager().validate(object, object, index, v):
        return v
    raise Unauthorized, 'unauthorized access to element %s' % `i`

if sys.version_info < (2, 2):
    # Can't use nested scopes, so we create callable instances
    class get_dict_get:
        def __init__(self, d, name):
            self.d = d

        def __call__(self, key, default=None):
            try:
                return guarded_getitem(self.d, key)
            except KeyError:
                return default

    class get_dict_pop:
        def __init__(self, d, name):
            self.d = d

        def __call__(self, key, default=_marker):
            try:
                v = guarded_getitem(self.d, key)
            except KeyError:
                if default is not _marker:
                    return default
                raise
            else:
                del self.d[key]
                return v

    # Dict methods not in Python 2.1
    get_iter = 0

    class get_list_pop:
        def __init__(self, lst, name):
            self.lst = lst

        def __call__(self, index=-1):
            # XXX This is not thread safe, but we don't expect
            # XXX thread interactions between python scripts <wink>
            v = guarded_getitem(self.lst, index)
            del self.lst[index]
            return v

else:
    # Python 2.2 or better: Create functions using nested scope to store state
    # This is less expensive then instantiating and calling instances
    def get_dict_get(d, name):
        def guarded_get(key, default=None):
            try:
                return guarded_getitem(d, key)
            except KeyError:
                return default
        return guarded_get

    def get_dict_pop(d, name):
        def guarded_pop(key, default=_marker):
            try:
                v = guarded_getitem(d, key)
            except KeyError:
                if default is not _marker:
                    return default
                raise
            else:
                del d[key]
                return v
        return guarded_pop

    def get_iter(c, name):
        iter = getattr(c, name)
        def guarded_iter():
            return SafeIter(iter(), c)
        return guarded_iter

    def get_list_pop(lst, name):
        def guarded_pop(index=-1):
            # XXX This is not thread safe, but we don't expect
            # XXX thread interactions between python scripts <wink>
            v = guarded_getitem(lst, index)
            del lst[index]
            return v
        return guarded_pop

# See comment in SimpleObjectPolicies for an explanation of what the
# dicts below actually mean.

dict_handlers = {
    'get':get_dict_get, 'has_key':1,
    'iterkeys': get_iter,  'itervalues':get_iter,
    'pop':get_dict_pop, }
def dict_attr_factory(attr, v, handlers = dict_handlers):
    return handlers.get(attr, 1)

ContainerAssertions[type({})] = dict_attr_factory

list_handlers = {'pop':get_list_pop, }
def list_attr_factory(attr, v, handlers = list_handlers):
    return handlers.get(attr, 1)

ContainerAssertions[type([])] = list_attr_factory

# This implementation of a "safe" iterator uses a global guard()
# function to implement the actual guard.  This check is defined as a
# global so that the implementation can be reused.

if sys.version_info < (2, 2):

    class SafeIter:
        def __init__(self, sequence, container=None):
            if container is None:
                container = sequence
            self.container = container
            self.sequence = sequenece
            self.next_index = 0

        def __getitem__(self, index):
            ob = self.sequence[self.next_index]
            self.next_index += 1
            guard(self.container, ob, self.next_index - 1)
            return ob

    def _error(index):
        raise Unauthorized, 'unauthorized access to element %s' % `index`

else:
    class SafeIter(object):
        #__slots__ = '_next', 'container'

        def __init__(self, ob, container=None):
            self._next = iter(ob).next
            if container is None:
                container = ob
            self.container = container

        def __iter__(self):
            return self

        def next(self):
            ob = self._next()
            guard(self.container, ob)
            return ob

    def _error(index):
        raise Unauthorized, 'unauthorized access to element'

    safe_builtins['iter'] = SafeIter


def guard(container, value, index=None):
    if Containers(type(container)) and Containers(type(value)):
        # Simple type.  Short circuit.
        return
    if getSecurityManager().validate(container, container, index, value):
        return
    _error(index)

# More replacement built-ins.

def guarded_filter(f, seq, skip_unauthorized=0):
    if type(seq) is type(''):
        return filter(f, seq)
    if f is None:
        def f(x): return x
    v = getSecurityManager().validate
    result = []
    a = result.append
    for el in seq:
        if v(seq, seq, None, el):
            if f(el): a(el)
        elif not skip_unauthorized:
            raise Unauthorized, 'unauthorized access to element'
    return result
safe_builtins['filter'] = guarded_filter

def guarded_reduce(f, seq, initial=_marker):
    if initial is _marker:
        return reduce(f, SafeIter(seq))
    else:
        return reduce(f, SafeIter(seq), initial)
safe_builtins['reduce'] = guarded_reduce

def guarded_max(item, *items):
    if items:
        item = [item]
        item.extend(items)
    return max(SafeIter(item))
safe_builtins['max'] = guarded_max

def guarded_min(item, *items):
    if items:
        item = [item]
        item.extend(items)
    return min(SafeIter(item))
safe_builtins['min'] = guarded_min

def guarded_map(f, *seqs):
    safe_seqs = []
    for seqno in range(len(seqs)):
        seq = guarded_getitem(seqs, seqno)
        safe_seqs.append(seq)
    return map(f, *safe_seqs)
safe_builtins['map'] = guarded_map

def guarded_import(mname, globals={}, locals={}, fromlist=None):
    mnameparts = mname.split('.')
    firstmname = mnameparts[0]
    validate = getSecurityManager().validate
    module = load_module(None, None, mnameparts, validate, globals, locals)
    if module is not None:
        if fromlist is None:
            fromlist = ()
        try:
            for name in fromlist:
                if name == '*':
                    raise ImportError, ('"from %s import *" is not allowed'
                                        % mname)
                v = getattr(module, name, None)
                if v is None:
                    v = load_module(module, mname, [name], validate,
                                    globals, locals)
                if not validate(module, module, name, v):
                    raise Unauthorized
            else:
                return __import__(mname, globals, locals, fromlist)
        except Unauthorized, why:
            raise ImportError, ('import of "%s" from "%s" is unauthorized. %s'
                                % (name, mname, why))
    raise ImportError, 'import of "%s" is unauthorized' % mname
safe_builtins['__import__'] = guarded_import

class GuardedListType:
    def __call__(self, *args, **kwargs):
        return list(*args, **kwargs)

    if sys.version_info >= (2, 4):
        def sorted(self, iterable, cmp=None, key=None, reverse=False):
            return list.sorted(iterable, cmp=None, key=None, reverse=False)
safe_builtins['list'] = GuardedListType()

class GuardedDictType:
    def __call__(self, *args, **kwargs):
        return dict(*args, **kwargs)

    def fromkeys(self, S, v=None):
        return dict.fromkeys(S,v)
safe_builtins['dict'] = GuardedDictType()

def guarded_enumerate(seq):
    return enumerate(SafeIter(seq))
safe_builtins['enumerate'] = guarded_enumerate

def guarded_sum(sequence, start=0):
    return sum(SafeIter(sequence), start)
safe_builtins['sum'] = guarded_sum

def load_module(module, mname, mnameparts, validate, globals, locals):
    modules = sys.modules
    while mnameparts:
        nextname = mnameparts.pop(0)
        if mname is None:
            mname = nextname
        else:
            mname = '%s.%s' % (mname, nextname)
        nextmodule = modules.get(mname, None)
        if nextmodule is None:
            nextmodule = secureModule(mname, globals, locals)
            if nextmodule is None:
                return
        else:
            secureModule(mname)
        if module and not validate(module, module, nextname, nextmodule):
            return
        module = nextmodule
    return module

# This version of apply is used by restricted Python, which transforms
# extended call syntax into a call of _apply_(), after tucking the callable
# into the first element of args.  For example,
#     f(3, eggs=1, spam=False)
# is changed to
#     _apply_(f, 3, eggs=1, spam=False)
def guarded_apply(func, *args, **kws):
    return builtin_guarded_apply(func, args, kws)

# This version is the safe_builtins apply() replacement, so needs to match the
# signature of __builtin__.apply.
def builtin_guarded_apply(func, args=(), kws={}):
    # Check the args elements.  args may be an arbitrary iterable, and
    # iterating over it may consume it, so we also need to save away
    # the arguments in a new list to pass on to the real apply().
    i, arglist = 0, []
    for elt in args:
        guard(args, elt, i)
        arglist.append(elt)
        i += 1
    # Check kws similarly.  Checking the keys may not be strictly necessary,
    # but better safe than sorry.  A new argument dict is created just in
    # case kws is a hostile user-defined instance that may do horrid things
    # as a side-effect of calling items().
    argdict = {}
    for k, v in kws.items():
        guard(kws, k)
        guard(kws, v, k)
        argdict[k] = v
    return func(*arglist, **argdict)

safe_builtins['apply'] = builtin_guarded_apply


# AccessControl clients generally need to set up a safe globals dict for
# use by restricted code.  The get_safe_globals() function returns such
# a dict, containing '__builtins__' mapped to our safe bulitins, and
# bindings for all the special functions inserted into Python code by
# RestrictionMutator transformations.  A client may wish to add more
# bindings to this dict.  It's generally safe to do so, as
# get_safe_globals returns a (shallow) copy of a canonical safe globals
# dict.
# Exception:  For obscure technical reasons, clients have to import
# guarded_getattr from this module (ZopeGuards) and plug it into the
# dict themselves, with key '_getattr_'.

_safe_globals = {'__builtins__': safe_builtins,
                 '_apply_':      guarded_apply,
                 '_getitem_':    guarded_getitem,
                 '_getiter_':    SafeIter,
                 '_print_':      RestrictedPython.PrintCollector,
                 '_write_':      full_write_guard,
                 # The correct implementation of _getattr_, aka
                 # guarded_getattr, isn't known until
                 # AccessControl.Implementation figures that out, then
                 # stuffs it into *this* module's globals bound to
                 # 'guarded_getattr'.  We can't know what that is at
                 ## '_getattr_':   guarded_getattr,
                }

get_safe_globals = _safe_globals.copy

RestrictionCapableEval.globals.update(_safe_globals)

