This file is indexed.

/usr/share/pyshared/defusedxml/common.py is in python-defusedxml 0.4.1-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
# defusedxml
#
# Copyright (c) 2013 by Christian Heimes <christian@python.org>
# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/psf/license for licensing details.
"""Common constants, exceptions and helpe functions
"""
import sys
from types import MethodType

PY3 = sys.version_info[0] == 3
PY26 = sys.version_info[:2] == (2, 6)
PY31 = sys.version_info[:2] == (3, 1)


class DefusedXmlException(ValueError):
    """Base exception
    """
    def __repr__(self):
        return str(self)


class DTDForbidden(DefusedXmlException):
    """Document type definition is forbidden
    """
    def __init__(self, name, sysid, pubid):
        super(DTDForbidden, self).__init__()
        self.name = name
        self.sysid = sysid
        self.pubid = pubid

    def __str__(self):
        tpl = "DTDForbidden(name='{}', system_id={!r}, public_id={!r})"
        return tpl.format(self.name, self.sysid, self.pubid)


class EntitiesForbidden(DefusedXmlException):
    """Entity definition is forbidden
    """
    def __init__(self, name, value, base, sysid, pubid, notation_name):
        super(EntitiesForbidden, self).__init__()
        self.name = name
        self.value = value
        self.base = base
        self.sysid = sysid
        self.pubid = pubid
        self.notation_name = notation_name

    def __str__(self):
        tpl = "EntitiesForbidden(name='{}', system_id={!r}, public_id={!r})"
        return tpl.format(self.name, self.sysid, self.pubid)


class ExternalReferenceForbidden(DefusedXmlException):
    """Resolving an external reference is forbidden
    """
    def __init__(self, context, base, sysid, pubid):
        super(ExternalReferenceForbidden, self).__init__()
        self.context = context
        self.base = base
        self.sysid = sysid
        self.pubid = pubid

    def __str__(self):
        tpl = "ExternalReferenceForbidden(system_id='{}', public_id={})"
        return tpl.format(self.sysid, self.pubid)


class NotSupportedError(DefusedXmlException):
    """The operation is not supported
    """


def _apply_defusing(defused_mod):
    assert defused_mod is sys.modules[defused_mod.__name__]
    stdlib_name = defused_mod.__origin__
    __import__(stdlib_name, {}, {}, ["*"])
    stdlib_mod = sys.modules[stdlib_name]
    stdlib_names = set(dir(stdlib_mod))
    for name, obj in vars(defused_mod).items():
        if name.startswith("_") or name not in stdlib_names:
            continue
        setattr(stdlib_mod, name, obj)
    return stdlib_mod


def _generate_etree_functions(DefusedXMLParser, _TreeBuilder,
            _IterParseIterator, _parse, _iterparse):
    """Factory for functions needed by etree, dependent on whether
    cElementTree or ElementTree is used."""

    def parse(source, parser=None, forbid_dtd=False, forbid_entities=True,
              forbid_external=True):
        if parser is None:
            parser = DefusedXMLParser(target=_TreeBuilder(),
                                      forbid_dtd=forbid_dtd,
                                      forbid_entities=forbid_entities,
                                      forbid_external=forbid_external)
        return _parse(source, parser)

    if PY26 or PY31:
        def bind(xmlparser, funcname, hookname):
            func = getattr(DefusedXMLParser, funcname)
            if PY26:
                # unbound -> function
                func = func.__func__
                method = MethodType(func, xmlparser, xmlparser.__class__)
            else:
                method = MethodType(func, xmlparser)
            # set hook
            setattr(xmlparser._parser, hookname, method)

        def iterparse(source, events=None, forbid_dtd=False,
                      forbid_entities=True, forbid_external=True):
            it = _iterparse(source, events)
            xmlparser = it._parser
            if forbid_dtd:
                bind(xmlparser, "defused_start_doctype_decl",
                     "StartDoctypeDeclHandler")
            if forbid_entities:
                bind(xmlparser, "defused_entity_decl",
                     "EntityDeclHandler")
                bind(xmlparser, "defused_unparsed_entity_decl",
                     "UnparsedEntityDeclHandler")
            if forbid_external:
                bind(xmlparser, "defused_external_entity_ref_handler",
                     "ExternalEntityRefHandler")
            return it
    elif PY3:
        def iterparse(source, events=None, parser=None, forbid_dtd=False,
                      forbid_entities=True, forbid_external=True):
            close_source = False
            if not hasattr(source, "read"):
                source = open(source, "rb")
                close_source = True
            if not parser:
                parser = DefusedXMLParser(target=_TreeBuilder(),
                                          forbid_dtd=forbid_dtd,
                                          forbid_entities=forbid_entities,
                                          forbid_external=forbid_external)
            return _IterParseIterator(source, events, parser, close_source)
    else:
        # Python 2.7
        def iterparse(source, events=None, parser=None, forbid_dtd=False,
                      forbid_entities=True, forbid_external=True):
            if parser is None:
                parser = DefusedXMLParser(target=_TreeBuilder(),
                                          forbid_dtd=forbid_dtd,
                                          forbid_entities=forbid_entities,
                                          forbid_external=forbid_external)
            return _iterparse(source, events, parser)

    def fromstring(text, forbid_dtd=False, forbid_entities=True,
                   forbid_external=True):
        parser = DefusedXMLParser(target=_TreeBuilder(),
                                  forbid_dtd=forbid_dtd,
                                  forbid_entities=forbid_entities,
                                  forbid_external=forbid_external)
        parser.feed(text)
        return parser.close()


    return parse, iterparse, fromstring